上载到接口 <Foo> 当类实现通用接口时 <T> 类型约束为T = Foo？

Question

I've got an interface declaring a few methods (in C#):

internal interface ILetter<T> where T:IEntity
{
    List<T> GetRecords();
    DocumentParameters GetDocumentParameters(T record);
    void MarkRecordAsHandled(T record, bool letterSent);
}

I also have an abstract class implementing the above interface, adding a bunch of general functionality as well. It looks something like this:

abstract class AbstractLetter<T> : ILetter<T> where T:IEntity
{
    public abstract List<T> GetRecords();

    public abstract DocumentParameters GetDocumentParameters(T record);

    public abstract void MarkRecordAsHandled(T record, bool letterSent);

    protected readonly FamisContext FamisContext = new FamisContext();

    protected bool KnownEmail(string socialSecurityNumber){ doing stuff }
}

Finally I have different classes inheriting from the above base class (AbstractLetter). They, of course, include specific implementations of the methods declared in the interface.
I'd like to make a batch-job, creating the different kind of letters, based on the methods from the interface. I thought I could do this by making a list and then iterate through the list using the same methods on each element. But apparently I cannot do that - at least not without explicitly type casting them.
So, my question is: Can I do something like the below, but without the typecasting (and more letters, of course)?

var test = new List<ILetter<IEntity>> {new JobTrainingLetter() as ILetter<IEntity>};

Answer 1

Well, starters, new JobTrainingLetter() as ILetter<IEntity> is not really valid, unless you mark T explictly as an " out ", that is, covariant .

If you mark a type parameter out , you should also ensure that the T can be accessed only from the "output" positions.

It does not really make sense to treat your letter as ILetter<IEntity> , as that would mean that you have access to methods such as:

DocumentParameters GetDocumentParameters(IEntity record);

on an instance of ILetter<YourConcreteEntity> . What would happen if you try GetDocumentParameters(anotherConcreteEntity) ? Runtime exception.

I suggest you to think about your design a bit more.

Answer 2

I'm not fully sure I understand your question, but is this what you're after?

http://ideone.com/bE08rw

In LinqPad:

interface IEntity
{
    string Name { get; set; }
}

class FooEntity : IEntity
{
    public string Name { get; set; }

    public FooEntity()
    {
        Name = "foo";
    }
}

interface ILetter<T> where T:IEntity
{
    string EntityMetadata { get; set; }
    List<T> GetRecords();
}


abstract class AbstractLetter<T> : ILetter<T> where T:IEntity
{
    public abstract string EntityMetadata { get; set; }
    public abstract List<T> GetRecords();
}

class JobLetter : AbstractLetter<FooEntity>
{
    public override string EntityMetadata { get; set; }
    public override List<FooEntity> GetRecords() { return null; }

    public JobLetter()
    {
        var entity = new FooEntity();
        EntityMetadata = entity.Name;
    }
}

List<T> CreateLetterList<T, K>() where T : AbstractLetter<K>, new() where K : IEntity
{
    return new List<T> { new T(), };
}

void Main()
{
    var jobLetterList = CreateLetterList<JobLetter, FooEntity>();
    foreach (var letter in jobLetterList)
    {
        Console.WriteLine(letter.EntityMetadata);
    }
}

To cater for a List that stores multiple types of letters:

abstract class AbstractLetter: ILetter<IEntity>
{
    public abstract string EntityMetadata { get; set; }
    public abstract List<IEntity> GetRecords();
}

class JobLetter<T> : AbstractLetter where T : IEntity, new()
{
    public override string EntityMetadata { get; set; }
    public override List<IEntity> GetRecords() { return null; }

    public JobLetter()
    {
        var entity = new T();
        EntityMetadata = entity.Name;
    }
}

class SubsidyLetter<T> : AbstractLetter where T : IEntity, new()
{
    public override string EntityMetadata { get; set; }
    public override List<IEntity> GetRecords() { return null; }

    public SubsidyLetter()
    {
        var entity = new T();
        EntityMetadata = entity.Name;
    }
}
List<T> CreateLetterList<T>() where T : AbstractLetter, new()
{
    return new List<T> { new T(), };
}

void Main()
{
    var jobLetterList = CreateLetterList<JobLetter<FooEntity>>();
    var subsidyLetterList = CreateLetterList<SubsidyLetter<FooEntity2>>();

    var mergedList = new List<AbstractLetter>();
    mergedList.Add(jobLetterList[0]);
    mergedList.Add(subsidyLetterList[0]);

    foreach (var letter in mergedList)
    {
        Console.WriteLine(letter.EntityMetadata);
    }
}

As you can see you will lose some type information in the base class.

To support what you're trying to achieve (but not necessarily the required functionality) you need valid variance on your types:

interface ILetter<out T> where T:IEntity
{
    string EntityMetadata { get; set; }
    IEnumerable<T> GetRecords();
}


abstract class AbstractLetter<T> : ILetter<T> where T:IEntity
{
    public abstract string EntityMetadata { get; set; }
    public abstract IEnumerable<T> GetRecords();
}

class JobLetter : AbstractLetter<FooEntity>
{
    public override string EntityMetadata { get; set; }
    public override IEnumerable<FooEntity> GetRecords() { return null; }

    public JobLetter()
    {
        var entity = new FooEntity();
        EntityMetadata = entity.Name;
    }
}

class SubsidyLetter : AbstractLetter<FooEntity2>
{
    public override string EntityMetadata { get; set; }
    public override IEnumerable<FooEntity2> GetRecords() { return null; }

    public SubsidyLetter()
    {
        var entity = new FooEntity2();
        EntityMetadata = entity.Name;
    }
}

void Main()
{
    var jobLetterList = CreateLetterList<JobLetter, FooEntity>();
    var subsidyLetterList = CreateLetterList<SubsidyLetter, FooEntity2>();
    var mergedList = new List<ILetter<IEntity>>();

    mergedList.Add(jobLetterList[0]);
    mergedList.Add(subsidyLetterList[0]);

    foreach (var letter in mergedList)
    {
        Console.WriteLine(letter.EntityMetadata);
    }
}

IEnumerable will work in place of List as it doesn't allow you to put values into it.

Answer 3

Your base class is defined as:

abstract class AbstractLetter<T> : ILetter<T> where T:IEntity

The T is bound with a generic constraint, but the constraints are not part of the type signatures (and also co/contravariance is not supported for classes, it's just for interfaces, not that you have any here anyways). So, your class, for the compiler, from the inheritance point of view, really looks something like *):

abstract class AbstractLetter<T> : ILetter<T>

which does not tell the compiler that it implements ILetter<IEntity> .

Simply add that part explicitely:

abstract class AbstractLetter<T> : ILetter<IEntity>, ILetter<T> where T:IEntity

Of course it may force you to add some code to satisfy that extra interface (you can have VS generate them for you and fill with pass-forwards to the current code), but it will work.

EDIT: Oor, you can use variance settings on the interface like ChrisEelmaa wisely suggested (I'm suprised I didn't thought of it, even after mentioning variance, heh!). But that won't work directly with current method set. I also don't recommend creating two interfaces ILetter<int T> + ILetter2<out T> - this almost always leads to bloat and really weird and complicated code. Too complicated comparing to a few casts.

*) whole this paragraph is a really really loose description