class CollectionItem {}
class Collection<T> 
{
    protected virtual T CreateItem() {...}
}

                             // V - для своего lookupIndexedEnumValue() в ответ на жирный аналог в LengthUnit.Parse
public enum RoleType implements IIndexable<String>, IRoleAuthorizationContextFactory  {

    ADMINISTRATOR("admin") {
        @Override
        public IRoleAuthorizationContext createRoleAuthorizationContext(Request request) {
            return new AdministratorRoleAuthorizationContext();
        }
    },

    EDITOR("editor") {
        @Override
        public IRoleAuthorizationContext createRoleAuthorizationContext(Request request) {
            return new EditorRoleAuthorizationContext(request);
        }
    };

    private final String alias;

    RoleType(String alias) {
        this.alias = alias;
    }

    @Override
    public final String getIndexKey() {
        return alias;
    }

}

public interface IService {

    @Role(ADMINISTRATOR)
    void foo();

    @Role(EDITOR)
    void bar();

}

object x = 1 as int;

public enum RoleType
{
    ADMINISTRATOR,
    EDITOR;

    public IRoleAuthorizationContext ToContext(Request request)
    {
        switch (value)
        {
            case ADMINISTRATOR: return new AdministratorRoleAuthorizationContext(); break;
            case EDITOR:        return new EditorRoleAuthorizationContext(request); break;
            default:            throw new Exception("A new role was added with no converting code."); break;
        }
    }
}

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class RoleTypeAttribute : System.Attribute
{
    ...
}

public interface IService
{
    [RoleTypeAttribute(RoleType.ADMINISTRATOR)]
    void foo();

    [RoleTypeAttribute(RoleType.EDITOR)]
    void bar();
}

Well, I can't answer why it's not available, but I can confirm that it's not a CLI issue. The CLI spec doesn't mention it (as far as I can see) and if you use IL directly you can create a generic attribute. The part of the C# 3 spec that bans it — section 10.1.4 "Class base specification" doesn't give any justification.

The annotated ECMA C# 2 spec doesn't give any helpful information either, although it does provide an example of what's not allowed.

My copy of the annotated C# 3 spec should arrive tomorrow... I'll see if that gives any more information. Anyway, it's definitely a language decision rather than a runtime one.

EDIT: Answer from Eric Lippert (paraphrased): no particular reason, except to avoid complexity in both the language and compiler for a use case which doesn't add much value.

public enum RoleType
{
    ADMINISTRATOR,
    EDITOR;

    public IRoleAuthorizationContext ToContext(Request request)
    {
        switch (value)
        {
            case ADMINISTRATOR: return new AdministratorRoleAuthorizationContext(); break;
            case EDITOR:        return new EditorRoleAuthorizationContext(request); break;
            default:            throw new Exception("A new role was added with no converting code."); break;
        }
    }
}

public interface IService
{
    [System.EnumAttribute<RoleType>(RoleType.ADMINISTRATOR)]
    void foo();

    [System.EnumAttribute<RoleType>(RoleType.EDITOR)]
    void bar();
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Role { // аналог аттрибута; аналога AllowMultiple не существует

    RoleType value();    // RoleType - само перечесление, которое можно использовать в качестве значения анотации (value можно опускать)

}

public class Tester {

    /**
     * @param args
     */
    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        int m = 1024 * 1024;
        Test(100 * m);
        long end = System.currentTimeMillis();
        System.out.println("time" + (end - start));

    }

    static void Test(int limit_) {
        int limit = limit_;
        int sqr_lim;
        boolean[] is_prime = new boolean[limit + 1];
        int x2, y2;
        int i, j;
        int n;

        sqr_lim = (int) Math.sqrt(limit);
        for (i = 0; i <= limit; i++)
            is_prime[i] = false;
        is_prime[2] = true;
        is_prime[3] = true;

        x2 = 0;
        for (i = 1; i <= sqr_lim; i++) {
            x2 += 2 * i - 1;
            y2 = 0;
            for (j = 1; j <= sqr_lim; j++) {
                y2 += 2 * j - 1;

                n = 4 * x2 + y2;
                if ((n <= limit) && (n % 12 == 1 || n % 12 == 5))
                    is_prime[n] = !is_prime[n];

                // n = 3 * x2 + y2;
                n -= x2;
                if ((n <= limit) && (n % 12 == 7))
                    is_prime[n] = !is_prime[n];

                // n = 3 * x2 - y2;
                n -= 2 * y2; //
                if ((i > j) && (n <= limit) && (n % 12 == 11))
                    is_prime[n] = !is_prime[n];
            }
        }

        for (i = 5; i <= sqr_lim; i++) {
            if (is_prime[i]) {
                n = i * i;
                for (j = n; j <= limit; j += n) {
                    is_prime[j] = false;
                }
            }
        }

    }

}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;

namespace cappTestPrime
{
    public class Tester
    {


        public static void Main(String[] args)
        {

            var sw = Stopwatch.StartNew();

            int m = 1024 * 1024;

            Test(100 * m);

            var end = sw.ElapsedMilliseconds;
            Console.WriteLine("elapsed=" + end);


        }

        static void Test(int limit_)
        {
            int limit = limit_;
            int sqr_lim;
            bool[] is_prime = new bool[limit + 1];
            int x2, y2;
            int i, j;
            int n;

            sqr_lim = (int)Math.Sqrt(limit);

            for (i = 0; i <= limit; i++)
                is_prime[i] = false;
            is_prime[2] = true;
            is_prime[3] = true;

            x2 = 0;
            for (i = 1; i <= sqr_lim; i++)
            {
                x2 += 2 * i - 1;
                y2 = 0;
                for (j = 1; j <= sqr_lim; j++)
                {
                    y2 += 2 * j - 1;

                    n = 4 * x2 + y2;
                    if ((n <= limit) && (n % 12 == 1 || n % 12 == 5))
                        is_prime[n] = !is_prime[n];

                    // n = 3 * x2 + y2;
                    n -= x2;
                    if ((n <= limit) && (n % 12 == 7))
                        is_prime[n] = !is_prime[n];

                    // n = 3 * x2 - y2;
                    n -= 2 * y2; // 
                    if ((i > j) && (n <= limit) && (n % 12 == 11))
                        is_prime[n] = !is_prime[n];
                }
            }

            for (i = 5; i <= sqr_lim; i++)
            {
                if (is_prime[i])
                {
                    n = i * i;
                    for (j = n; j <= limit; j += n)
                    {
                        is_prime[j] = false;
                    }
                }
            }

        }

    }
}

void Test(object sender)
{
    if (sender is not Smth1)
    {
    }
}

void Test(object sender)
{
    if (!(sender is Smth1))
    {
    }
}

FE>void Test(object sender)
FE>{
FE>    if (sender is not Smth1)
FE>    {
FE>    }
FE>}
FE>

public static class ObjectExtensions
{
    public static bool IsNot<T>(this object obj)
    {
        return obj is T == false;
    }
}

match (RuleSymbol)
{
  | ExtensibleRuleSymbol => ()
  | ExtentionRuleSymbol(BaseRule = RuleRef.Some(baseRuleSymbol), ExtentionType = Prefix) =>
    defineExtentionRuleMethods(baseRuleSymbol)

  | ExtentionRuleSymbol(BaseRule = RuleRef.Some(baseRuleSymbol), ExtentionType = Postfix(bindingPower, _)) =>
    defineExtentionRuleMethods(baseRuleSymbol);
    _descriptorTb.DefineConditional(<[decl: public override BindingPower : int { get { $(bindingPower : int) } } ]>);

  | SimpleRuleSymbol  => defineNewParserMethod(<[ N2.Internal.SimpleRuleParser ]>);
  | RegularRuleSymbol => ()
  | _       => assert(false)
}

class C(int firstField, string secondField)
{
}
...
var c = C(42, "wow");
Console.WriteLine(c.firstField);