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

Question

I have the following interface

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

And the following class

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

The following class which extends Listener<T> and implements IHandleSuccess<T>

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

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

Lastly, another listener that extends Listener<T> but does not implement IHandleSuccess<T>

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

My SendConfirmationEmail gets class is registered into my IoC container when the application starts up.

I want to check if the resolved instance implements a contract. And if it does, I want to call the Finished method.

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

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

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

However, the line IHandleSuccess<> is giving me an error

Unexpected use of an unbound generic name

Since the generic argument will always extend the Event class, I also tried changing the code to the following

listener.Handle(_event);

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

But _listener.Finished(_event, listener) gives me the following error

The second argument cannot convert from Listener<T> to Listener<Event>

How can I correctly fix this error?

Answer 1

You already know what the generic type of IHandleSuccess<> will be, it will be T because you declared that you would be receiving Listener<T> 's from the request.

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

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

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

Here is a example if Announce was not generic

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

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

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

Answer 2

This code doesn't work

var cls = new SendConfirmationEmail();

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

Because cls is of type SendConfirmationEmail() which implements Listener<UserWasUpdated> whereas _cls is casted as IHandleSuccess<Event> . The function _cls.Finished() expect a parameter listener of type Listener<Event> , not Listener<UserWasUpdated>

What is the use of your function Finished(UserWasUpdated _event, Listener<UserWasUpdated> listener) ? Looking at the way you are using it, you could remove the parameterc listener and reference the current listener using this :

So the interface would look like this:

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

And the implementation like this:

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

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

To answer you first question, this doesn't work because each use of the generic is a different type:

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);
}

If you want to be able to do this, you need to make you interface non generic. If the _event object is known by your object cls beforehand, you can store it and use it in the Finished() call, like this:

Interface:

public interface IHandleSuccess
{
    void Finished();
}

And the implementation like this:

public class SendConfirmationEmail : Listener<UserWasUpdated>, 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();
    }
}

You can then do:

var cls = new SendConfirmationEmail();

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