Inferencia del tipo genérico Pregunta

Question

Supongo que esto es más una diatriba pública, pero ¿por qué no puedo obtener C# para inferir el tipo de mi Id?

public EntityT Get<EntityT>(IdT id) where EntityT : EntityObject<IdT> 

y una EntityObject definido con un GUID como un Id como sigue:

public Foo : EntityObject<Guid> 

hereda de la clase EntityObject abstracto definen como sigue:

public abstract class EntityObject<IdT> 
{ 
    public IdT id { get; set; } 
} 

Uso del método get haría ser de la siguiente manera:

IRepository repository = new Repository(); 
var hydratedFoo = repository.Get<Foo>(someGuidId); 

editado para proporcionar más aclaraciones.

Answer 1

Es difícil de decir dado que solo ha dado dos declaraciones, no cómo las está usando. ¿Es IdT otro parámetro de tipo en alguna parte? (Si fuera TId, eso sugeriría que es - pero el hecho de que está utilizando EntityT para otro tipo de parámetro, en contra de las convenciones, sugiere que tal vez IdT es así ...)

Ahora, suponiendo que es IdT De hecho, Guid en su caso, ¿cómo debería funcionar el compilador que quiere decir Foo? Puede haber otros tipos derivados de EntityObject<Guid>.

En resumen, no nos ha dado suficiente información para contar algo con certeza, pero parece que básicamente está haciendo demandas irracionales al compilador.

EDIT: Bueno, aquí está mi suposición de lo que tienes, usando convenciones de nombres normales:

public interface IRepository 
{ 
    TEntity Get<TEntity, TId>(TId id) where TEntity : EntityObject<TId> 
} 

public abstract class EntityObject<TId> 
{ 
    public IdT id { get; set; } 
} 

public class Foo : EntityObject<Guid> {} 

Se desea realizar:

IRepository repository = GetRepositoryFromSomewhere(); 
Foo foo = repository.Get<Foo>(someGuid); 

Mientras que actualmente hay que hacer:

Foo foo = repository.Get<Foo, Guid>(someGuid); 

Sí, el compilador lo está haciendo muy ligeramente más difícil para ti de lo necesario. Un total de 6 caracteres adicionales, con el objetivo de mantener el lenguaje más simple y las reglas de tipo de inferencia más fáciles de entender.

Básicamente, la inferencia de tipo es un asunto de todo o nada: todos los parámetros de tipo se deducen o ninguno de ellos. Eso lo mantiene simple ya que no necesita determinar cuáles se especifican y cuáles no. Eso es parte del problema, y ​​la otra parte es que sólo se puede expresar restricciones sobre los parámetros de tipo del método - no se puede tener:

class Repository<TEntity> 
{ 
    TEntity Get<TId>(TId id) where TEntity : EntityObject<TId> 
} 

porque eso limitando TEntity, no TId. De nuevo, este tipo de cosas hace que la inferencia de tipos sea más simple.

Ahora podría potencialmente escribir:

Foo foo = repository.Get(someGuid).For<Foo>(); 

con un método apropiado Get y una interfaz adicional. Creo que personalmente preferiría simplemente usar Get<Foo, Guid>.

Answer 2

Si su firma del método era la siguiente:

public TEntity Get<TEntity, TId>(TId id) where TEntity : EntityObject<TId> 

El compilador tendría algo con qué trabajar ...

A continuación, llama a conseguir con algo como:

EDIT (que estaba incorrecto): Producto p = Get (id);

Product p = Get<Product, Guid>(id); 

de Jon clavado esta respuesta con su puesto encima de la tapa por lo que callo y rastrear de nuevo en mi agujero.

Answer 3

Una declaración como

public EntityT Get<EntityT>(IdT id) where EntityT : EntityObject<IdT> 

exigencias que IdT es un tipo de hormigón. Si también desea parametrizar IdT, necesitará usar

public EntityT Get<EntityT, IdT>(IdT id) where EntityT : EntityObject<IdT> 

Pero eso probablemente no sea lo que usted desearía.

Answer 4

Es por eso que he renunciado a los tipos de claves genéricas con entidades genéricas. No pude encontrar la forma de que mis entidades tuvieran tipos de claves genéricas sin rociarlas por todos lados. Ahora me he decidido por las claves enteras (que es lo que tengo en todas partes) pero se siente mal.