如何使用c#检查类是否实现并与泛型接口？

我有以下界面

public interface IHandleSuccess where T : Event
{
    void Finished(T _event, Listener listener);
}

以下课程

public abstract class Listener where T : Event
{
    public abstract void Handle(T _event);
}

以下类扩展Listener和实现IHandleSuccess

public class SendConfirmationEmail : Listener, IHandleSuccess
{
    public override void Handle(UserWasUpdated _event)
    {
        // ...
    }

    public void Finished(UserWasUpdated _event, Listener listener)
    {
        // ...
    }
}

最后,另一个扩展Listener但未实现的侦听器IHandleSuccess

public class ScheduleOriantation: Listener
{
    public override void Handle(UserWasUpdated _event)
    {
        // ...
    }
}

应用程序启动时,我的SendConfirmationEmail获取类已注册到我的IoC容器中.

我想检查已解析的实例是否实现了合同.如果确实如此,我想调用该Finished方法.

public void Announce(T _event) where T : Event
{
    IEnumerable> listeners = Container.ResolveAll>()

    foreach (var listener in listeners)
    {
        try
        {
            listener.Handle(_event);

            if (listener is IHandleSuccess<> _listener)
            {
                _listener.Finished(_event, listener);
            }
        }
        catch (Exception e)
        {
            // ...
        }
    }
}

但是,这条线IHandleSuccess<>给了我一个错误

意外使用未绑定的通用名称

由于泛型参数将始终扩展Event类,我还尝试将代码更改为以下内容

listener.Handle(_event);

if (listener is IHandleSuccess _listener)
{
    _listener.Finished(_event, listener);
}

但是_listener.Finished(_event, listener)给我以下错误

第二个参数无法转换Listener为Listener

我该如何正确修复此错误？

您已经知道通用类型是什么IHandleSuccess<>,这将是T因为您声明您将从Listener请求中接收.

public void Announce(T _event) where T : Event
{
    IEnumerable> listeners = Container.ResolveAll>()

    foreach (var listener in listeners)
    {
        try
        {
            listener.Handle(_event);

            if (listener is IHandleSuccess _listener)
            {
                _listener.Finished(_event, listener);
            }
        }
        catch (Exception e)
        {
            // ...
        }
    }
}

这是一个例子,如果Announce不是通用的

public void Announce(Foo _event)
{
    IEnumerable> listeners = Container.ResolveAll>()

    foreach (var listener in listeners)
    {
        try
        {
            listener.Handle(_event);

            if (listener is IHandleSuccess _listener)
            {
                _listener.Finished(_event, listener);
            }
        }
        catch (Exception e)
        {
            // ...
        }
    }
}

var cls = new SendConfirmationEmail();

if (cls is IHandleSuccess _cls)
{
    _cls.Finished(_event, cls);
}

public interface IHandleSuccess where T : Event
{
    void Finished(T _event);
}

public class SendConfirmationEmail : Listener, IHandleSuccess
{
    public override void Handle(UserWasUpdated _event)
    {
        // ...
    }

    public void Finished(UserWasUpdated _event)
    {
        // Call whatever function on your object
        this.Cleanup()
    }
}

var cls = new SendConfirmationEmail();

if (cls is IHandleSuccess<> _cls)
{
    // _event and cls types can't be resolved at compilation time here:
    _cls.Finished(_event, cls);
}

public interface IHandleSuccess
{
    void Finished();
}

public class SendConfirmationEmail : Listener, IHandleSuccess
{
    private _Event = null;

    public override void Handle(UserWasUpdated _event)
    {
        // Store _event
        _Event = _event;
    }

    public void Finished()
    {
        // Call whatever function on your object
        this.Cleanup()

        // Call whatever is needed on _event
        _Event?.Cleanup();
    }
}

var cls = new SendConfirmationEmail();

if (cls is IHandleSuccess _cls)
{
    _cls.Finished();
}