Utiliser `où T: SOMETHING` construire en C#

Question

Je viens de trouver un peu de quelqu'un de code ici avait écrit pour accéder à certaines entités DB ...

public static OurCustomObject GetOurCustomObject(int primaryKey) 
{ 
    return GetOurCustomObject<int>(primaryKey, "usp_GetOurCustomObjectByID"); 
} 

public static OurCustomObject GetOurCustomObject(Guid uniqueIdent) 
{ 
    return GetOurCustomObject<Guid>(uniqueIdent, "usp_GetOurCustomObjectByGUID"); 
} 

private static OurCustomObject<T>(T identifier, string sproc) 
{ 

    if((T != typeof(int)) && (T == typeof(Guid))) 
    { 
     throw new ArgumentException("Identifier must be a string or an int"); 
    } 

    //ADO.NET Code to make DB Call with supplied sproc. 
} 

Theres juste quelque chose qui ne semble pas très generic. Le fait que les sprocs sont passés dans la méthode intérieure est moche. mais la seule façon que je peux voir autour de ce qui est d'avoir un if/else dans la méthode privée le long des lignes de

if(type == int) 
    sproc = "GetByID"; 
else if (type == Guid) 
    sproc = "GetByGUID"; 

également le lancement d'exception est moche et ... est là de toute façon d'utiliser un où T : clause

par exemple

private static OurCustomObject<T>(T identifier) where T : int OR Guid 

Toutes les suggestions sur la façon de nettoyer un peu.

Answer 1

Vous ne pouvez pas spécifier une contrainte qui dit "c'est l'un de ces deux", non.

Ce que vous pourrait faire est:

Dictionary<Type, string> StoredProcedureByType = new Dictionary<Type, string> 
{ 
    { typeof(Guid), "GetByGUID" }, 
    { typeof(int), "GetByID" } 
}; 

Ensuite, utilisez:

string sproc; 
if (!StoredProcedureByType.TryGetValue(typeof(T), out sproc)) 
{ 
    throw new ArgumentException("Invalid type: " + typeof(T).Name); 
} 

C'est probablement excessif pour seulement deux types, mais il échelles bien si vous avez beaucoup de types impliqués.

Étant donné que les deux types sont des types de valeur, vous pouvez faire un peu plus robuste avec une contrainte de:

where T : struct 

mais qui va tout de même byte etc.

Answer 2

Il n'y a pas de support pour une telle clause où limiter le paramètre de type de cette façon (malheureusement).

Dans ce cas, vous pourriez constater que le passage identifier comme un objet, et pas en utilisant des médicaments génériques est en fait plus propre (quand je avais besoin quelque chose de semblable, c'est-ce que je fini par faire: semblait être la moins pire approche) .

C'est une zone où C# est faible, n'étant ni un langage dynamique ni capable de spécialiser le template (comme C++, fournissant seulement des implémentations pour T = int et T = Guid). Adenda: Dans ce cas, je serais probablement coller avec la surcharge, mais changer le contrôle de type à un Assert comme c'est une méthode d'aide privée.

Answer 3

Le code que vous avez fourni me semble relativement correct, car private static OurCustomObject<T>(T identifier, string sproc) est privé. Je supprimerais même la vérification d'exception de cette méthode, car encore une fois - son privé, donc cette classe contrôle ce qui est passé à la méthode. La déclaration if serait plutôt horrible et sur-machinée.

Answer 4

La neatest chose à faire est probablement faire quelque chose comme ceci:

public interface IPrimaryKey 
{ 
} 

public class PrimaryGuidKey(Guid key) : IPrimaryKey 

public class PrimaryIntegerKey(int key) : IPrimaryKey 

private static OurCustomObject<T>(T identifier) where T : IPrimaryKey