La parola chiave Sealed influenza l'opinione del compilatore su un cast

Question

Ho una situazione in cui mi piacerebbe che il comportamento del compilatore fosse spiegato. Dato un po 'di codice:

interface IFoo<T> 
{ 
    T Get(); 
} 

class FooGetter : IFoo<int> 
{ 
    public int Get() 
    { 
     return 42; 
    } 
} 

I seguenti compilato ed eseguito:

static class FooGetterGetter 
{ 
    public static IFoo<T> Get<T>() 
    { 
     return (IFoo<T>)new FooGetter(); 
    } 
} 

Se facciamo una modifica alla firma della classe Foo e aggiungere la parola chiave sealed:

sealed class FooGetter : IFoo<int> // etc 

Quindi viene visualizzato un errore del compilatore nella seguente riga:

return (IFoo<T>)new FooGetter(); 

Di:

Impossibile convertire il tipo 'MyNamespace.FooGetter' a 'MyNamespace.IFoo <T>'

Qualcuno può spiegare che cosa sta accadendo qui per quanto riguarda la parola chiave sealed? Questo è il C# 4 contro un progetto .NET 4 in Visual Studio 2010.

Aggiornamento: abbastanza interessante mi sono imbattuto in quella parte del comportamento quando mi chiedevo perché il seguente codice corregge quando viene applicata sealed:

return (IFoo<T>)(IFoo<int>)new FooGetter(); 

Aggiornamento: solo per un chiarimento, tutto funziona bene quando il tipo di T richiesto è lo stesso come il tipo di T utilizzato dal tipo concreto. Se i tipi sono diversi, il cast non riesce a runtime con qualcosa di simile:

Impossibile eseguire il cast oggetto di tipo 'MyNamespace.StringFoo' di digitare 'MyNamespace.IFoo`1 [System.Int32]'

Nell'esempio sopra, StringFoo : IFoo<string> e il chiamante chiede di ottenere uno int.

Answer 1

Perché l'FooGetter è un'implementazione esplicita di IFoo<int> invece di implementare IFoo<T> genericamente. Dal momento che è sigillato, il compilatore sa che non c'è modo di lanciarlo su un generico IFoo<T> se T è qualcosa di diverso da un int. Se non fosse sigillato, il compilatore gli consentirebbe di compilare e generare un'eccezione in fase di runtime se T non fosse uno int.

Se si tenta di utilizzare con qualcosa di diverso da un int (ad es FooGetterGetter.Get<double>();) si ottiene un'eccezione:

Impossibile eseguire il cast oggetto di tipo 'MyNamespace.FooGetter' digitare 'MyNamespace.IFoo`1 [System.Double]'.

Quello che non sono sicuro del motivo il compilatore non non genera un errore per la versione non sigillata.Come potrebbe la tua sottoclasse in modo tale che new FooGetter() ti dia qualcosa che implementa IFoo<{something_other_than_int}>?

Aggiornamento:

Per Dan Bryant e Andras Zoltan ci sono metodi per restituire una classe derivata da un costruttore (o forse più precisamente per il compilatore per restituire un tipo diverso analizzando attributi). Quindi tecnicamente questo è fattibile se la classe non è sigillata.

Answer 2

Quando una classe sigillata qualsiasi classe derivata potrebbe implementare IFoo<T>:

class MyClass : FooGetter, IFoo<double> { } 

Quando FooGetter è contrassegnato come sigillato, il compilatore sa che non può essere possibile per eventuali ulteriori implementazioni di IFoo<T> diversi IFoo<int> potrebbero esistere per FooGetter.

Questo è un buon comportamento, consente di rilevare problemi con il codice in fase di compilazione anziché in fase di esecuzione.

Il motivo per cui lo (IFoo<T>)(IFoo<int>)new FooGetter(); funziona è perché ora si rappresenta la classe sigillata come IFoo<int> che potrebbe essere implementata da qualsiasi cosa. È anche un buon lavoro in giro perché non si è accidentalmente, ma sovrascrivendo di proposito il controllo del compilatore.

Answer 3

Giusto per aggiungere alle risposte esistenti: Questo in realtà non ha nulla a che fare con i generici usati.

Si consideri l'esempio più semplice:

interface ISomething 
{ 
} 

class OtherThing 
{ 
} 

poi dire (all'interno di un metodo):

OtherThing ot = XXX; 
ISomething st = (ISomething)ot; 

funziona bene. Il compilatore non sa se un OtherThing potrebbe essere un ISomething, quindi ci crede quando diciamo che avrà successo. Tuttavia, se si modifica OtherThing in un tipo sigillato (ovvero sealed class OtherThing { } o struct OtherThing { }), il cast non è più consentito. Il compilatore sa che non può andare bene (tranne se ot doveva essere null, ma le regole di C# non consentono ancora il cast da un tipo sealed a un'interfaccia non implementata da quel tipo sealed).

Riguardo all'aggiornamento della domanda: Scrivere (IFoo<T>)(IFoo<int>)new FooGetter() non è molto diverso da scrivere (IFoo<T>)(object)new FooGetter(). Puoi "rendere permesso" qualsiasi cast (con generici o senza) passando per un tipo intermedio che è certamente/possibilmente un antenato di entrambi i tipi che vuoi convertire. E 'molto simile a questo modello:

void MyMethod<T>(T t) // no "where" constraints on T 
{ 
    if (typeof(T) = typeof(GreatType)) 
    { 
    var tConverted = (GreatType)(object)t; 
    // ... use tConverted here 
    } 
    // ... other stuff 
}