Delphi SysUtils.Supports意外返回true

我通常通过在接口中提供一种方法来解决这个问题(比如Spring.Collections.IEnumerable有一个ElementType属性来获取IEnumerable< T>的实际类型).

所以实现看起来像这样：

program GenericEventPublisher;

{$APPTYPE CONSOLE}

uses
  Spring,Spring.Collections,System.SysUtils;

type
  IEventHandler = interface
    ['{2E4BD8F4-4EB8-4B33-84F4-B70F42EF9208}']
    procedure Handle(const event: TObject);
  end;

  IEventHandler<T: class> = interface
    ['{82B7521E-D719-4051-BE2C-2EC449A92B22}']
    procedure Handle(const event: T);
    function GetHandledClass: TClass;
  end;

  IEventPublisher = interface
    ['{2A460EF0-AE27-480F-ACEA-1B897F2DE056}']
    procedure Subscribe(const subscriber: IEventHandler);
    procedure Publish(const event: TObject; ownsObject: Boolean = True);
  end;

  TEventHandlerBase<T: class> = class(TInterfacedObject,IEventHandler<T>)
  private
    function GetHandledClass: TClass;
    procedure Handle(const event: TObject); overload;
  public
    procedure Handle(const event: T); overload; virtual; abstract;
  end;

  TEvent1 = class
  end;

  TEvent2 = class
  end;

  TMyEventHandler1 = class(TEventHandlerBase<TEvent1>)
  public
    procedure Handle(const event: TEvent1); override;
  end;

  TMyEventHandler2 = class(TEventHandlerBase<TEvent2>)
  public
    procedure Handle(const event: TEvent2); override;
  end;

  TEventPublisher = class(TInterfacedObject,IEventPublisher)
  private
    fSubscribers: IList<IEventHandler>;
  public
    constructor Create;
    procedure Subscribe(const subscriber: IEventHandler);
    procedure Publish(const event: TObject; ownsObject: Boolean = True);
  end;

{ TEventPublisher }

constructor TEventPublisher.Create;
begin
  fSubscribers := TCollections.CreateList<IEventHandler>;
end;

procedure TEventPublisher.Publish(const event: TObject; ownsObject: Boolean);
var
  subscriber: IEventHandler;
  eventSubscriber: IEventHandler<TObject>;
begin
  for subscriber in fSubscribers do
    if Supports(subscriber,IEventHandler<TObject>,eventSubscriber)
      and (eventSubscriber.GetHandledClass = event.ClassType) then
        eventSubscriber.Handle(event);

  if ownsObject then
    event.Free;
end;

procedure TEventPublisher.Subscribe(const subscriber: IEventHandler);
begin
  fSubscribers.Add(subscriber)
end;

{ TEventHandlerBase<T> }

function TEventHandlerBase<T>.GetHandledClass: TClass;
begin
  Result := T;
end;

procedure TEventHandlerBase<T>.Handle(const event: TObject);
begin
  Assert(event is T);
  Handle(T(event));
end;

{ TMyEventHandler1 }

procedure TMyEventHandler1.Handle(const event: TEvent1);
begin
  Writeln(event.ClassName,' handled by ',ClassName);
end;

{ TMyEventHandler2 }

procedure TMyEventHandler2.Handle(const event: TEvent2);
begin
  Writeln(event.ClassName,ClassName);
end;

var
  eventPublisher: IEventPublisher;
begin
  eventPublisher := TEventPublisher.Create;
  eventPublisher.Subscribe(TMyEventHandler1.Create);
  eventPublisher.Subscribe(TMyEventHandler2.Create);
  eventPublisher.Publish(TEvent1.Create);
  eventPublisher.Publish(TEvent2.Create);
end.

由于接口上存在类约束,因此无论T的类型如何,都可以确保接口是二进制兼容的(因为它们只能是对象).对通用事件处理程序使用基类型也减少了要写入的额外代码.它只是将非泛型Handle方法重定向到必须在具体实现中实现的泛型方法.

此外,由于基类实现了两个接口,我们不需要将处理程序存储在TValue列表中,但可以使用非通用接口类型并轻松访问它们而无需RTTI.

现在,Publish方法正在使用一个小技巧,用IEventHandler< TObject>调用Support. – 因为eventSubscriber属于那种类型,我们可以将事件参数传递给它的Handle方法,这恰好是正确的 – 这是因为我之前解释过的二进制兼容性,因为我们只是处理不同的类作为T – story的类型如果我们没有那个类约束,那将完全不同.