Utilise pour la statique des classes génériques?

Rendre une classe static ne pas ajouter de fonctionnalité, il est juste un moyen pratique de vérifier si vous avez l'intention d'utiliser une classe sans instanciation. Et il y a plusieurs utilisations pour ça...

Vous pouvez utiliser des classes génériques pour contourner une limitation: C# n'a pas permis partielle de la spécialisation. Cela signifie que vous devez spécifier tous les paramètres de type ou aucun. Cependant, qui peut être inutilement verbeux.

Par exemple:

static class Converter {
    public TOut Convert<TIn, TOut>(TIn x) {...}
}

la classe précédente n'a pas permis de l'inférence de type depuis l'inférence ne fonctionne pas sur les valeurs de retour. Cependant, vous ne pouvez pas indiquer la valeur de retour de type sans préciser le type d'entrée puisque vous ne pouvez pas partiellement se spécialiser. À l'aide d'un (peut-être statique) classe générique, vous pouvez spécifier qu'un seul des deux types:

static class ConvertTo<TOut> {
    public TOut Convert<TIn>(TIn x) {...}
}

De cette façon, vous pouvez laisser l'inférence de type travail sur le type de paramètre et ne spécifier que le type de retour.

(Bien que le cas ci-dessus est concevable, il ne nécessite pas la classe générique à être statique, bien sûr).

Deuxièmement, (comme Steven tout d'abord souligné) séparé champs statiques existe pour chaque type construit, et qui rend les classes statiques d'excellents endroits pour stocker des informations supplémentaires sur les types ou combinaisons de type de. En essence, c'est un semi-statique de la table de hachage que les touches sur les types.

Un semi-statique de la table de masquage sur les types de sons un peu arcance, mais il est en fait très, très utile la structure, car il vous permet de stocker cher de réflexion et de génération de code où ils sont presque gratuites à regarder en haut (moins cher qu'un dictionnaire, parce que ça devient JIT-ed et de vous éviter un appel à .GetType()). Si vous êtes en train de faire la métaprogrammation, c'est génial!

Par exemple, je l'utilise dans ValueUtils pour stocker généré fonctions de hachage:

//Hash any object:
FieldwiseHasher.Hash(myCustomStructOrClass);

//implementation:
public static class FieldwiseHasher {
    public static int Hash<T>(T val) { return FieldwiseHasher<T>.Instance(val); }
}

public static class FieldwiseHasher<T> {
    public static readonly Func<T, int> Instance = CreateLambda().Compile();
    //...
}

Statique méthodes génériques permettent l'inférence de type pour que l'utilisation vraiment facile; les champs statiques sur les classes génériques permettant à presque frais-gratuit de stockage de (méta)données. Il ne m'étonne pas du tout si l'ORM est comme Dapper et PetaPoco utiliser des techniques comme cela; mais il est également grand pour (de)sérialiseurs. Une limitation est que vous obtenez le faible temps parce que vous êtes la liaison à la au moment de la compilation type; si l'objet qui est passé est en fait une instance d'une sous-classe, vous êtes probablement de liaison pour le mauvais type et l'ajout de vérifications pour éviter ce genre de sape de l'avantage d'une faible surcharge.

Une utilisation de la statique des classes génériques que j'ai récemment appris a été possible de définir une contrainte sur le niveau de la classe pour le type, la contrainte s'applique à tous les membres statiques de la classe, ce que j'ai également appris, c'est que ce n'est pas autorisé pour la statique des classes génériques qui définissent l'extension des méthodes.

Par exemple, si vous allez créer un statique de la classe générique et vous savez tous les types génériques devraient être IComparable (juste un exemple), alors vous pouvez effectuer les opérations suivantes.

static class MyClass<T> where T : IComparable
{
  public static void DoSomething(T a, T b)
  {
  }

  public static void DoSomethingElse(T a, T b)
  {
  }
}

Avis que je n'ai pas besoin d'appliquer la contrainte à tous les membres, mais juste au niveau de la classe.

Quelles sont les principales utilisations de la Statique
Classe générique en C#? Quand doivent-ils
être utilisé? Quels exemples illustrent le mieux
leur utilisation?

Je pense en général, vous devriez éviter de créer des paramètres de type statique, classes, sinon vous pouvez dépend pas de l'inférence de type pour faire de votre client code plus concis.

Pour donner un exemple concret, imaginons que vous êtes en train de rédiger un statique de la classe utilitaire pour gérer les opérations sur les Listes. Vous pouvez écrire la classe de deux façons:

//static class with generics
public static class ListOps<T>
{
    public static List<T> Filter(List<T> list, Func<T, bool> predicate) { ... }
    public static List<U> Map<U>(List<T> list, Func<T, U> convertor) { ... }
    public static U Fold<U>(List<T> list, U seed, Func<T, U> aggregator) { ... }
}

//vanilla static class
public static class ListOps
{
    public static List<T> Filter<T>(List<T> list, Func<T, bool> predicate) { ... }
    public static List<U> Map<T, U>(List<T> list, Func<T, U> convertor) { ... }
    public static U Fold<T, U>(List<T> list, U seed, Func<T, U> aggregator) { ... }
}

Mais les classes sont équivalentes, mais qui est facile à utiliser? Comparer:

//generic static class
List<int> numbers = Enumerable.Range(0, 100).ToList();
List<int> evens = ListOps<int>.Filter(numbers, x => x % 2 = 0);
List<string> numberString = ListOps<int>.Map(numbers, x => x.ToString());
int sumOfSquares = ListOps<int>.Fold(numbers, 0, (acc, x) => acc + x*x);

//vanilla static class
List<int> numbers = Enumerable.Range(0, 100).ToList();
List<int> evens = ListOps.Filter(numbers, x => x % 2 = 0);
List<string> numberString = ListOps.Map(numbers, x => x.ToString());
int sumOfSquares = ListOps.Fold(numbers, 0, (acc, x) => acc + b * b);

À mon avis, ListOps<someType> est encombrant et maladroit. La définition de la vanille classe est légèrement plus grande, mais le code du client est plus facile à lire -- grâce à l'inférence de type.

Dans le pire des cas, C# ne pouvez pas déduire les types, et vous devez les spécifier à la main. Préférez-vous écrire ListOps<A>.Map<B>(...) ou ListOps.Map<A, B>(...)? Ma préférence va vers le dernier.

La stratégie ci-dessus fonctionne particulièrement bien lorsque votre classe statique détient pas mutable état, ou de ses mutable état est connu au moment de la compilation.

Si la classe statique détient mutable état dont le type n'est pas déterminé au moment de la compilation, alors vous avez probablement un cas d'utilisation pour une classe statique avec générique params. Espérons que ces occasions sont rares et loin entre, mais quand il arrive, vous serez heureux C# prend en charge la fonctionnalité.

Vous avez raison: ils ne sont pas beaucoup d'utilisation. Peut-être il y a quelques rares cas qui sont des exceptions, cependant. Par exemple, si la classe est un type de dépôt, comme pour Justin exemple, mais a gardé une statique de la collection comme un cache? En général, si elle contient de l'état, non seulement les méthodes, il y a peut-être un point à ce.