Краткий ответ

Вам редко нужно беспокоиться о in и out ключевых слов в родовых определениях типов. Класс определяется in/out параметров общего типа, как правило, "просто работать", когда вы потребляющие его, и я бы держать пари, что большинство дэвов никогда не будут писать такое определение в своем собственном коде.

Более длинный ответ

Чтобы получить полное объяснение, вы должны прочитать Covariance и Contravariance and Variance in Delegates. Остальная часть моего ответа - просто пример иллюстративного кода.

Чтобы упростить объяснение, я собираюсь объяснить, in и out отдельно через Action<T> и Func<TResult> вместо Func<T,TResult>.

Все примеры используют следующие два класса:

class BaseClass {}
class DerivedClass : BaseClass {}

Ковариация: out

В этом примере я имитировал Func<out TResult>, но удалил модификатор out (ковариация), чтобы продемонстрировать его эффект. Covariance позволяет нам использовать функцию, которая возвращает DerivedType везде, где ожидается функция, которая возвращает BaseType.

class CovarianceExamples
{
    // This is similar to System.Func<out TResult>(), but with covariance removed
    delegate TResult InvariantFunc<TResult>(); 

    void InvariantFuncExample()
    {
        // Ignore the values of these variables; it the types that are important
        InvariantFunc<BaseClass> baseFunc = null;
        InvariantFunc<DerivedClass> derivedFunc = null;

        baseFunc = baseFunc; // Allowed
        baseFunc = derivedFunc; // Not allowed; compile error!
    }

    void CovariantFuncExample()
    {
        // Ignore the values of these variables; it the types that are important
        Func<BaseClass> baseFunc = null;
        Func<DerivedClass> derivedFunc = null;

        baseFunc = baseFunc; // Allowed
        baseFunc = derivedFunc; // Allowed
    }
}

Контравариантность: in

Для этого примера я имитировал Action<in T>, но удалил модификатор in (contravariance), чтобы продемонстрировать его эффект. Contravariance позволяет нам использовать действие, которое принимает BaseType везде, где ожидается действие, которое принимает DerivedType.

class ContravarianceExamples
{
    // This is similar to System.Action<in T>(T), but with contravariance removed
    delegate void InvariantAction<T>(); 

    void InvariantActionExample()
    {
        // Ignore the values of these variables; it the types that are important
        InvariantAction<BaseClass> baseAction = null;
        InvariantAction<DerivedClass> derivedAction = null;

        baseAction = baseAction; // Allowed
        derivedAction = baseAction; // Not allowed; compile error!
    }

    void ContravariantActionExample()
    {
        // Ignore the values of these variables; it the types that are important
        Action<BaseClass> baseAction = null;
        Action<DerivedClass> derivedAction = null;

        baseAction = baseAction; // Allowed
        derivedAction = baseAction; // Allowed
    }
}