Che cos'è esattamente una "classe speciale"?

Dopo aver fallito nel ottenere qualcosa di simile al seguente da compilare:

public class Gen<T> where T : System.Array
{
}

con l'errore

Un vincolo non può essere la classe speciale `System.Array '

Ho iniziato a chiedermi, che cosa esattamente è una "classe speciale"?

Le persone spesso sembrano ricevere lo stesso tipo di errore quando specificano System.Enumin un vincolo generico. Ho ottenuto gli stessi risultati con System.Object, System.Delegate, System.MulticastDelegatee System.ValueTypetroppo.

Ce ne sono di più? Non riesco a trovare alcuna informazione su "classi speciali" in C #.

Inoltre, cosa c'è di così speciale in quelle classi da non poterle usare come vincolo di tipo generico?

Dal codice sorgente di Roslyn, sembra un elenco di tipi hardcoded:

switch (type.SpecialType)
{
    case SpecialType.System_Object:
    case SpecialType.System_ValueType:
    case SpecialType.System_Enum:
    case SpecialType.System_Delegate:
    case SpecialType.System_MulticastDelegate:
    case SpecialType.System_Array:
        // "Constraint cannot be special class '{0}'"
        Error(diagnostics, ErrorCode.ERR_SpecialTypeAsBound, syntax, type);
        return false;
}

Fonte: Binder_Constraints.cs IsValidConstraintType
L'ho trovato utilizzando una ricerca GitHub: "Un vincolo non può essere una classe speciale"

Ho trovato un commento di Jon Skeet del 2008 su una domanda simile: perché il System.Enumvincolo non è supportato.

So che questo è un po 'fuori tema , ma ha chiesto a Eric Lippert (il team di C #) e hanno fornito questa risposta:

Prima di tutto, la tua congettura è corretta; le restrizioni sui vincoli sono in gran parte artefatti del linguaggio, non tanto il CLR. (Se dovessimo eseguire queste funzionalità, ci sarebbero alcune piccole cose che vorremmo cambiare nel CLR riguardo a come vengono specificati i tipi enumerabili, ma principalmente questo sarebbe un lavoro linguistico.)

In secondo luogo, personalmente mi piacerebbe avere vincoli delegati, vincoli enum e la possibilità di specificare vincoli che oggi sono illegali perché il compilatore sta cercando di salvarti da te stesso. (Cioè, rendere i tipi sigillati legali come vincoli e così via.)

Tuttavia, a causa delle limitazioni di pianificazione, probabilmente non saremo in grado di inserire queste funzionalità nella prossima versione della lingua.

Secondo MSDN è un elenco statico di classi:

Errore del compilatore CS0702

Il vincolo non può essere un 'identificatore' di classe speciale I seguenti tipi non possono essere utilizzati come vincoli:

• System.Object
• System.Array
• System.Delegate
• System.Enum
• System.ValueType.

Secondo C # 4.0 Language Specification (Coded: [10.1.5] Type parameter constraints) dice due cose:

1] Il tipo non deve essere oggetto. Poiché tutti i tipi derivano da object, tale vincolo non avrebbe alcun effetto se fosse consentito.

2] Se T non ha vincoli primari o vincoli di parametro di tipo, la sua classe base effettiva è oggetto.

Quando si definisce una classe generica, è possibile applicare restrizioni ai tipi di tipi che il codice client può utilizzare per gli argomenti di tipo quando crea un'istanza della classe. Se il codice client tenta di creare un'istanza della classe utilizzando un tipo non consentito da un vincolo, il risultato è un errore in fase di compilazione. Queste restrizioni sono chiamate vincoli. I vincoli vengono specificati utilizzando la parola chiave contestuale where. Se vuoi vincolare un tipo generico come tipo di riferimento, usa: class.

public class Gen<T> where T : class
{
}

Ciò impedirà al tipo generico di essere un tipo di valore, come int o uno struct ecc.

Inoltre, il vincolo non può essere un 'identificatore' di classe speciale I seguenti tipi non possono essere utilizzati come vincoli:

• System.Object
• System.Array
• System.Delegate
• System.Enum
• System.ValueType.

Ci sono alcune classi nel Framework che trasmettono effettivamente caratteristiche speciali a tutti i tipi da esse derivati ma non possiedono tali caratteristiche stesse . Lo stesso CLR non impone alcun divieto contro l'utilizzo di tali classi come vincoli, ma i tipi generici ad esse vincolati non acquisiscono le caratteristiche non ereditate come farebbero i tipi concreti. I creatori di C # hanno deciso che poiché tale comportamento potrebbe confondere alcune persone e non sono riusciti a vederne l'utilità, dovrebbero vietare tali vincoli piuttosto che consentire loro di comportarsi come fanno nel CLR.

Se, ad esempio, fosse consentito scrivere void CopyArray<T>(T dest, T source, int start, int count):; si sarebbe in grado di passare deste sourcea metodi che prevedono un argomento di tipo System.Array; inoltre, si otterrebbe una convalida in fase di compilazione che deste sourcefossero i tipi di array compatibili, ma non si sarebbe in grado di accedere agli elementi dell'array utilizzando l' []operatore.

L'incapacità di utilizzare Arraycome vincolo è per lo più abbastanza facile da aggirare, poiché void CopyArray<T>(T[] dest, T[] source, int start, int count)funzionerà in quasi tutte le situazioni in cui funzionerebbe il primo metodo. Tuttavia, ha un punto debole: il primo metodo funzionerebbe nello scenario in cui uno o entrambi gli argomenti erano di tipo System.Arrayrifiutando i casi in cui gli argomenti sono tipi di array incompatibili; l'aggiunta di un sovraccarico in cui entrambi gli argomenti erano di tipo System.Arrayfarebbe sì che il codice accetti i casi aggiuntivi che dovrebbe accettare, ma lo farebbe anche accettare erroneamente casi che non dovrebbe.

Trovo fastidiosa la decisione di mettere fuori legge la maggior parte dei vincoli speciali. L'unico che avrebbe significato semantico zero sarebbe System.Object[poiché se fosse legale come vincolo, qualsiasi cosa lo soddisferebbe]. System.ValueTypeprobabilmente non sarebbe molto utile, poiché i riferimenti di tipo ValueTypenon hanno molto in comune con i tipi di valore, ma potrebbe plausibilmente avere qualche valore nei casi che coinvolgono la riflessione. Entrambi System.Enume System.Delegateavrebbero alcuni usi reali, ma dal momento che i creatori di C # non ci hanno pensato, sono fuorilegge senza una buona ragione.

È possibile trovare quanto segue in CLR tramite C # 4th Edition:

Vincoli primari

Un parametro di tipo può specificare zero vincoli primari o un vincolo primario. Un vincolo primario può essere un tipo di riferimento che identifica una classe che non è sigillata. Non è possibile specificare uno dei seguenti tipi di riferimento speciale: System.Object , System.Array , System.Delegate , System.MulticastDelegate , System.ValueType , System.Enum o System.Void . Quando si specifica un vincolo di tipo di riferimento, si promette al compilatore che un argomento di tipo specificato sarà dello stesso tipo o di un tipo derivato dal tipo di vincolo.

Non credo che esista una definizione ufficiale di "classi speciali" / "tipi speciali".

Potresti pensare a loro come tipi aa, che non possono essere usati con la semantica dei tipi "regolari":

• non puoi istanziarli direttamente;
• non puoi ereditare direttamente il tipo personalizzato da loro;
• c'è qualche magia del compilatore per lavorare con loro (opzionalmente);
• l'uso diretto delle loro istanze almeno inutile (opzionalmente; immagina, che hai creato generico sopra, quale codice generico stai per scrivere?)

PS Aggiungerei System.Voidalla lista.