Повышение приведения к интерфейсу «Foo», когда класс реализует общий интерфейс «T» с ограничением типа T = Foo?

Я не совсем уверен, что понимаю ваш вопрос, но это то, что вам нужно?

http://ideone.com/bE08rw

В Линкпаде:

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

Для обслуживания списка, в котором хранятся несколько типов писем:

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

Как видите, вы потеряете некоторую информацию о типе в базовом классе.

Чтобы поддерживать то, чего вы пытаетесь достичь (но не обязательно необходимую функциональность), вам нужна действительная дисперсия ваших типов:

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 будет работать вместо списка, поскольку он не позволяет вам вводить в него значения.

Ну, во-первых, new JobTrainingLetter() as ILetter<IEntity> на самом деле недопустимо, если только вы не пометите T явно как "out", то есть ковариантный.

Если вы пометите параметр типа out, вы также должны убедиться, что доступ к T возможен только из «выходных» позиций.

На самом деле не имеет смысла рассматривать ваше письмо как ILetter<IEntity>, так как это будет означать, что у вас есть доступ к таким методам, как:

DocumentParameters GetDocumentParameters(IEntity record);

на экземпляре ILetter<YourConcreteEntity>. Что произойдет, если вы попробуете GetDocumentParameters(anotherConcreteEntity)? Исключение во время выполнения.

Я предлагаю вам подумать над своим дизайном немного больше.

Ваш базовый класс определяется как:

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

T связан с общим ограничением, но ограничения не являются частью сигнатур типов (а также совместное/контравариантность не поддерживается для классов, это только для интерфейсов, а не то, что у вас есть здесь в любом случае). Итак, ваш класс для компилятора с точки зрения наследования действительно выглядит примерно так *):

abstract class AbstractLetter<T> : ILetter<T>

который не сообщает компилятору, что он реализует ILetter<IEntity>.

Просто добавьте эту часть явно:

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

Конечно, это может заставить вас добавить некоторый код, чтобы удовлетворить этот дополнительный интерфейс (вы можете сделать так, чтобы VS сгенерировал их для вас и заполнил проходами к текущему коду), но это будет работать.

РЕДАКТИРОВАТЬ: Или, вы можете использовать настройки дисперсии в интерфейсе, как мудро предложил ChrisEelmaa (я удивлен, что не подумал об этом, даже после упоминания дисперсии, хех!). Но это не будет работать напрямую с текущим набором методов. Я также не рекомендую создавать два интерфейса ILetter<int T> + ILetter2<out T> — это почти всегда приводит к раздуванию и очень странному и сложному коду. Слишком сложно по сравнению с несколькими слепками.

*) весь этот абзац является очень расплывчатым описанием