La palabra clave sellada afecta la opinión del compilador sobre un molde

Question

Tengo una situación en la que me gustaría explicar el comportamiento del compilador. Teniendo en cuenta un poco de código:

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

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

Los siguientes compila y ejecuta:

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

Si hacemos un cambio a la firma de la clase Foo y añadir la sealed palabra clave:

sealed class FooGetter : IFoo<int> // etc 

Entonces obtengo un error de compilación en la siguiente línea:

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

de:

No se puede convertir tipo 'MyNamespace.FooGetter' a 'MyNamespace.IFoo <T>'

Puede alguien explicar lo que está sucediendo aquí con respecto a la palabra clave sealed? Esto es C# 4 en contra de un proyecto .NET 4 en Visual Studio 2010.

Actualización: curiosamente me encontré con esa parte del comportamiento cuando me preguntaba por qué el código siguiente corrige cuando se aplica sealed:

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

actualización: sólo para aclarar, todo funciona muy bien cuando el tipo de T solicitado es el mismo que el tipo de T utilizado por el tipo de hormigón. Si los tipos son diferentes, la conversión falla en tiempo de ejecución con algo como:

No se puede convertir objeto de tipo 'MyNamespace.StringFoo' para escribir 'MyNamespace.IFoo`1 [System.Int32]'

En el ejemplo anterior, StringFoo : IFoo<string> y la persona que llama solicita obtener un int.

Answer 1

Porque FooGetter es una implementación explícita de IFoo<int> en lugar de implementar IFoo<T> genéricamente. Como está sellado, el compilador sabe que no hay manera de convertirlo a un IFoo<T> genérico si T es algo distinto de int. Si no estuviera sellado, el compilador le permitiría compilar y lanzar una excepción en tiempo de ejecución si T no era un int.

Si intenta usarlo con otra cosa que no sea un int (por ejemplo FooGetterGetter.Get<double>();) se obtiene una excepción:

No se puede convertir objeto de tipo 'MyNamespace.FooGetter' al tipo 'MyNamespace.IFoo`1 [System.Double] '.

Lo que no estoy seguro de qué es el compilador hace no generará un error de la versión no sellada.¿Cómo podría su subclase FooGetter que new FooGetter() le brinde algo que implemente IFoo<{something_other_than_int}>?

Actualización:

por Dan Bryant y Andras Zoltan existen métodos para devolver una clase derivada de un constructor (o, posiblemente, más precisamente por el compilador volver a un tipo diferente mediante el análisis de atributos). Entonces, técnicamente esto es factible si la clase no está sellada.

Answer 2

Cuando una clase de sellar cualquier clase derivada podría implementar IFoo<T>:

class MyClass : FooGetter, IFoo<double> { } 

Cuando FooGetter se marca como sellado, el compilador sabe que no puede ser posible para cualquier implementaciones adicionales de IFoo<T> distintos IFoo<int> pudieran existir para FooGetter.

Esto es un buen comportamiento, le permite detectar problemas con su código en tiempo de compilación en lugar de en tiempo de ejecución.

La razón por la cual (IFoo<T>)(IFoo<int>)new FooGetter(); funciona es porque ahora está representando su clase sellada como IFoo<int> que podría ser implementada por cualquier cosa. También es un buen trabajo, ya que no es accidental, sino que descarta a propósito la comprobación del compilador.

Answer 3

Solo para agregar a las respuestas existentes: Esto realmente no tiene nada que ver con los genéricos utilizados.

Considere este ejemplo sencillo:

interface ISomething 
{ 
} 

class OtherThing 
{ 
} 

Luego diciendo (dentro de un método):

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

funciona bien. El compilador no sabe si un OtherThing podría ser un ISomething, por lo que nos cree cuando decimos que tendrá éxito. Sin embargo, si cambiamos OtherThing a tipo sellado (es decir, sealed class OtherThing { } o struct OtherThing { }), entonces el molde ya no está permitido. El compilador sabe que no puede ir bien (excepto si ot fuera null, pero las reglas de C# aún no permiten el reparto de un tipo sellado a una interfaz no implementada por ese tipo sellado).

En cuanto a la actualización de la pregunta: Escribir (IFoo<T>)(IFoo<int>)new FooGetter() no es muy diferente de escribir (IFoo<T>)(object)new FooGetter(). Puedes "hacer permitido" cualquier lanzamiento (con genéricos o sin) pasando por algún tipo intermedio que sea ciertamente/posiblemente un antepasado de los dos tipos que quieres convertir. Es muy similar a este patrón:

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 
}