Delphi SysUtils.Supports 意外返回 true

Question

我正在基于Spring4d文档的示例创建一个事件发布者。

不同之处在于订阅者必须明确订阅事件。

我想根据他们是否实现了IEventHandler<TEventType>接口来触发它们的处理过程。

当传入事件被发布时，我使用事件的类名和Spring4d的TType.FindType('IEventHandler<TEvent1>')找到IEventHandler<TEventType>类型引用。

然后，我循环遍历我的订阅者（实现IEventHandler接口的对象），并检查它是否支持例如IEventHandler类型。

问题是，即使订阅者没有实现接口，Supports方法也会返回true。

此外，我尝试列出例如TMyEventHandler2类型的接口。 它包含IEventHandler<TEvent2> ??

我认为这是由于IEventHandler<TEvent2>和IEventHandler<TEvent1>共享相同的GUID所导致的限制。

是否有解决方法？

使用以下类和接口：

TEvent1 = class(TObject)
end;

TEvent2 = class(TObject)
end;

IEventHandler = interface(IInvokable)
[guid]
procedure Handle(aEvent : TObject);
end;

IEventHandler<T : class> = interface(IEventHandler)
[guid]
procedure Handle(aEvent : T);
end;

TMyEventHandler1 = class(TObject, IEventHandler, IEventHandler<TEvent1>)
public 
procedure Handle(AEvent : TObject); overload;
procedure Handle(AEvent : TEvent1); overload;
end;

TMyEventHandler2 = class(TObject, IEventHandler, IEventHandler<TEvent2>)
public 
procedure Handle(AEvent : TObject); overload;
procedure Handle(AEvent : TEvent2); overload;
end;

TEventPublisher = class(TObject)
public
  fSubscribers : IList<TValue>;
  procedure Subscribe(aSubscriber : TValue);  // Simply adds the subscriber to the list of subscribers
  procedure Publish(aEvent : TObject); // Publishes an event to the subscribers
end;

procedure TEventPublisher.Publish(const event: TObject; ownsObject: Boolean = True);
const
  IEventSubscriberName = 'IEventSubscriber<*>';
var
  consumerTypeName: string;
  consumerType    : TRttiType;
  intfType        : TRttiInterfaceType;
  subscriber      : TValue;
  subscribed      : IInterface;
  lEventSubscriber: IEventSubscriber;
  lIntfs          : IReadOnlyList<TRttiInterfaceType>;
begin

  consumerTypeName := StringReplace(IEventSubscriberName, '*', GetQualifiedClassName(event), []);
  consumerType     := TType.FindType(consumerTypeName);
  intfType         := consumerType as TRttiInterfaceType;

  for subscriber in fSubscribers do
  begin

    lIntfs := TType.GetType(subscriber.AsObject.ClassInfo).GetInterfaces();

    // lIntfs for TMyEventHandler2 containts IEventHandler<TEvent1> ???

    if Supports(subscriber.AsObject, intfType.GUID, subscribed) then
      if Supports(subscriber.AsObject, IEventSubscriber, lEventSubscriber) then
      begin
        intfType.GetMethod('Handle').Invoke(TValue.From(@subscribed, intfType.Handle), [event])
      end;
  end;

  if ownsObject then
    event.Free;
end;


lEventPublisher := TEventPublisher.Create;
lEventPublisher.Subscribe(TMyEventHandler1.Create);
lEventPublisher.Subscribe(TMyEventHandler2.Create);
lEventPublisher.Publish(TEvent1.Create); // Will both trigger TMyEventHandler1.Handle and TMyEventHandler2.Handle. Why ??

- Ludovic C

---

是的，这是预期的结果，也是单一 guid 的一个后果。 - David Heffernan

是的，正如@David所说，这是可以预料的，而且在这种情况下没有其他解决方法，除非不在这种情况下使用通用接口。 - Rudy Velthuis

Answer 1

这是因为如果在通用接口上放置guid，则该接口的每个特化都将具有相同的guid，而不考虑其通用类型参数。

我通常通过在接口中提供相关信息来解决这个问题（例如，Spring.Collections.IEnumerable具有ElementType属性，可获取IEnumerable的实际类型）。

因此，实现应如下所示：

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, 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, ' handled by ', 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是该类型，我们可以将event参数传递给其Handle方法，这恰好是正确的方法 - 这是因为我之前解释过的二进制兼容性，因为我们只是处理不同类作为T的类型 - 如果没有那个类约束，情况将完全不同。

- Stefan Glienke