通用抽象类

Question

I have the following code which is fine...

namespace GenericAbstract
{
    public interface INotifModel
    {
        string Data { get; set; }
    }

    public interface INotif<T> where T: INotifModel
    {
       T Model { get; set; }
    }

    public interface INotifProcessor<in T> where T : INotif<INotifModel>
    {
        void Yell(T notif);
    }

    public class HelloWorldModel : INotifModel
    {
        public string Data { get; set; }

        public HelloWorldModel()
        {
            Data = "Hello world!";
        }
    }

    public class HelloWorldNotif : INotif<HelloWorldModel>
    {
        public HelloWorldModel Model { get; set; }

        public HelloWorldNotif()
        {
            Model = new HelloWorldModel();
        }
    }

    public class HelloWorldProcessor<T> : INotifProcessor<T> where T : INotif<INotifModel>
    {
        public void Yell(T notif)
        {
            throw new NotImplementedException();
        }
    }
}

As you can see there are 3 interfaces and each of those is implemented.

However, I would like the processor to be implemented like this:

public class HelloWorldProcessor : INotifProcessor<HelloWorldNotif<HelloWorldModel>>
{
    public void Yell(HelloWorldNotif<HelloWorldModel> notif)
    {
        throw new NotImplementedException();
    }
}

But i get the following error:

The non-generic type 'HelloWorldNotif' cannot be used with type arguments

I want the HelloWorldProcessor to implement INotifProcessor only for HelloWorldNotif ...

Can't figure out what I am doing wrong..

Answer 1

As others have said and/or implied out you've already got HelloWorldNotif fully specified. So to translate this:

I want the HelloWorldProcessor to implement INotifProcessor only for HelloWorldNotif

To C#, I think you mean:

public class HelloWorldProcessor : INotifProcessor<HelloWorldNotif>
{
    public void Yell(HelloWorldNotif notif)
    {
        throw new NotImplementedException();
    }
}

Answer 2

For this to work you first have to make INotif<T> co-variant. That means that the Model property has to be read only for the interface (it can still have a public set in an implementation). Then to fix your immediate error you don't put the <HelloWorldModel> after HelloWorldNotif because it's already a INotif<HelloWorldModel>

public interface INotifModel
{
    string Data { get; set; }
}

public interface INotif<out T> where T : INotifModel
{
    T Model { get; }
}

public interface INotifProcessor<in T> where T : INotif<INotifModel>
{
    void Yell(T notif);
}

public class HelloWorldModel : INotifModel
{
    public string Data { get; set; }

    public HelloWorldModel()
    {
        Data = "Hello world!";
    }
}

public class HelloWorldNotif : INotif<HelloWorldModel>
{
    public HelloWorldModel Model { get; set; }

    public HelloWorldNotif()
    {
        Model = new HelloWorldModel();
    }
}

public class HelloWorldProcessor<T> : INotifProcessor<T> where T : INotif<INotifModel>
{
    public void Yell(T notif)
    {
        throw new NotImplementedException();
    }
}

public class HelloWorldProcessor : INotifProcessor<HelloWorldNotif>
{
    public void Yell(HelloWorldNotif notif)
    {
        throw new NotImplementedException();
    }
}

Then I guess your implementation would be something like

Console.WriteLine(notif.Model.Data);