Интерфейсы, наследование, неявные операторы и преобразования типов, почему так?

Вы в основном попросили компилятор сделать это:

1. У меня есть это: DbRecurPatt
2. Я хочу это: IRecurrencePattern
3. Пожалуйста, найдите способ добраться из пункта 1 в пункт 2.

Компилятор, даже если у него может быть только один выбор, не позволяет вам сделать это. Оператор приведения конкретно говорит, что DbRecurPatt можно преобразовать в RecurrencePattern, а не в IRecurrencePattern.

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

Поскольку не был определен оператор, позволяющий напрямую преобразовывать DbRecurPatt в IRecurrencePattern, компилятор скомпилирует это как жесткое приведение, переинтерпретировав ссылку как ссылку через интерфейс, что приведет к сбою во время выполнения.

Итак, следующий вопрос будет таким: как я могу это сделать? И ответ - вы не можете.

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

Если вы попытаетесь определить такой оператор:

public static implicit operator IRecurrencePattern(DbRecurPatt obj)
{
    return new RecurrencePattern() { Data = $"{obj.Name} - {obj.Description}" };
}

Компилятор скажет следующее:

CS0552
'DbRecurPatt.implicit operator IRecurrencePattern(DbRecurPatt)': определяемые пользователем преобразования в интерфейс или из интерфейса не допускаются.

Почему первый не работает?

Потому что вы запрашиваете у среды выполнения два неявных преобразования — одно в RecurrencePattern и одно в IRecurrencePattern. Среда выполнения будет искать только прямые неявные отношения — она не будет сканировать все возможные маршруты, чтобы вы попросили ее перейти. Предположим, что имело место множество неявных преобразований в классы разных типов, реализующие IRecurrencePattern. Какой из них выберет среда выполнения? Вместо этого он заставляет вас указывать отдельные приведения.

Это описано в разделе 6.4.3 спецификации языка C#:

Оценка определяемого пользователем преобразования никогда не включает более одного определяемого пользователем или поднятого оператора преобразования. Другими словами, преобразование из типа S в тип T никогда не будет сначала выполнять определяемое пользователем преобразование из S в X, а затем выполнять определяемое пользователем преобразование из X в T.

Как уже указывали другие, вы не можете сделать прямой переход от DbRecurPatt к IRecurrencePattern. Вот почему вы получаете этот очень уродливый двойной состав:

var sorted = unsorted.Select(t => (IRecurrencePattern)(RecurrencePattern)t);

Но, для полноты картины, следует упомянуть, что можно перейти от DbRecurPatt к IRecurrencePattern без каких-либо слепков с вашим текущим дизайном. Просто для этого вам нужно разбить выражение на несколько операторов, и при этом код становится значительно уродливее.

Тем не менее, приятно знать, что вы можете сделать это без приведения типов:

var sorted = unsorted.Select( t => {
    RecurrencePattern recurrencePattern = t; // no cast
    IRecurrencePattern recurrencePatternInterface = recurrencePattern; // no cast here either
    return recurrencePatternInterface;
});

ИЗМЕНИТЬ

Кредит на ответ Билла Надо за идею. Вы также можете извлечь выгоду из неявного преобразования и его гарантий времени компиляции, сохраняя при этом довольно элегантный код, написав его следующим образом:

var sorted = unsorted
    .Select<DbRecurPatt, RecurrencePattern>(t => t) // implicit conversion - no cast
    .Select<RecurrencePattern, IRecurrencePattern>(t => t); // implicit conversion - no cast

Есть еще один способ добиться желаемого. В частности, помечайте свои общие аргументы при вызовах методов вместо того, чтобы позволять компилятору делать выводы о ваших общих аргументах. Вы по-прежнему избегаете приведения типов, и это может быть немного менее подробным, чем некоторые другие варианты. Единственное предостережение: вы должны включить дополнительный оператор Linq, который разрешит ваш список, если это имеет значение.

var sorted = unsorted
   .Select<DbRecurPatt, RecurrencePattern>(t => t)
   .ToList<IRecurrencePattern>();

Вы также можете объединить этот ответ с ответом sstan, чтобы избежать дополнительного оператора Linq.

... и чтобы ответить на ваш последний вопрос о неявном операторе - нет, вы не можете определить неявный оператор в интерфейсе. Эта тема более подробно рассматривается в этом вопросе:

неявный оператор с использованием интерфейсов