Почему C # запрещает универсальные типы атрибутов?

Это вызывает исключение во время компиляции:

public sealed class ValidatesAttribute<T> : Attribute
{

}

[Validates<string>]
public static class StringValidation
{

}

Я понимаю, что C # не поддерживает общие атрибуты. Однако, после долгих поисков, я не могу найти причину.

Кто-нибудь знает, почему родовые типы не могут быть получены из Attribute? Есть теории?

Ну, я не могу ответить, почему это не доступно, но я могу подтвердить, что это не проблема CLI. Спецификация CLI не упоминает об этом (насколько я вижу), и если вы используете IL напрямую, вы можете создать общий атрибут. Часть спецификации C # 3, которая запрещает это - раздел 10.1.4 «Базовая спецификация класса» не дает никакого оправдания.

Аннотированная спецификация ECMA C # 2 также не дает никакой полезной информации, хотя она предоставляет пример того, что запрещено.

Моя копия аннотированной спецификации C # 3 должна прибыть завтра ... Я посмотрю, даст ли это больше информации. В любом случае, это определенно решение на языке, а не на этапе исполнения.

РЕДАКТИРОВАТЬ: Ответ от Эрика Липперта (перефразировано): нет особой причины, кроме как избежать сложности как в языке, так и в компиляторе для варианта использования, который не добавляет особой ценности.

Атрибут украшает класс во время компиляции, но универсальный класс не получает свою окончательную информацию о типе до времени выполнения. Поскольку атрибут может влиять на компиляцию, он должен быть «завершен» во время компиляции.

Посмотрите эту статью MSDN для получения дополнительной информации.

Я не знаю, почему это не разрешено, но это одно из возможных решений

[AttributeUsage(AttributeTargets.Class)]
public class ClassDescriptionAttribute : Attribute
{
    public ClassDescriptionAttribute(Type KeyDataType)
    {
        _KeyDataType = KeyDataType;
    }

    public Type KeyDataType
    {
        get { return _KeyDataType; }
    }
    private Type _KeyDataType;
}


[ClassDescriptionAttribute(typeof(string))]
class Program
{
    ....
}

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

//an interface which means it can't have its own implementation. 
//You might need to use extension methods on this interface for that.
public interface ValidatesAttribute<T>
{
    T Value { get; } //or whatever that is
    bool IsValid { get; } //etc
}

public class ValidatesStringAttribute : Attribute, ValidatesAttribute<string>
{
    //...
}
public class ValidatesIntAttribute : Attribute, ValidatesAttribute<int>
{
    //...
}

[ValidatesString]
public static class StringValidation
{

}
[ValidatesInt]
public static class IntValidation
{

}

Это очень хороший вопрос. По моему опыту , с атрибутами, я думаю , что ограничение на месте , потому что при отражении от атрибута было бы создать условия , в которых вы должны проверить все возможные перестановки типа: typeof(Validates<string>), typeof(Validates<SomeCustomType>), и т.д. ...

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

Возможно, класс валидации, который принимает SomeCustomValidationDelegateили ISomeCustomValidatorв качестве параметра, будет лучшим подходом.

В настоящее время это не особенность языка C #, однако существует много дискуссий по поводу официального репозитория языка C # .

Из некоторых заметок :

Несмотря на то, что это работает в принципе, в большинстве версий среды выполнения есть ошибки, так что это не будет работать правильно (это никогда не выполнялось).

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

Кандидат на основную версию C #, если мы можем заставить достаточное количество версий времени выполнения справиться с этим.

Мой обходной путь примерно такой:

public class DistinctType1IdValidation : ValidationAttribute
{
    private readonly DistinctValidator<Type1> validator;

    public DistinctIdValidation()
    {
        validator = new DistinctValidator<Type1>(x=>x.Id);
    }

    public override bool IsValid(object value)
    {
        return validator.IsValid(value);
    }
}

public class DistinctType2NameValidation : ValidationAttribute
{
    private readonly DistinctValidator<Type2> validator;

    public DistinctType2NameValidation()
    {
        validator = new DistinctValidator<Type2>(x=>x.Name);
    }

    public override bool IsValid(object value)
    {
        return validator.IsValid(value);
    }
}

...
[DataMember, DistinctType1IdValidation ]
public Type1[] Items { get; set; }

[DataMember, DistinctType2NameValidation ]
public Type2[] Items { get; set; }