void dans les génériques C #?

J'ai une méthode générique qui prend une demande et fournit une réponse.

public Tres DoSomething<Tres, Treq>(Tres response, Treq request)
{/*stuff*/}

Mais je ne veux pas toujours une réponse à ma demande et je ne veux pas toujours alimenter les données de la demande pour obtenir une réponse. Je ne veux pas non plus avoir à copier et coller les méthodes dans leur intégralité pour apporter des modifications mineures. Ce que je veux, c'est pouvoir faire ceci:

public Tre DoSomething<Tres>(Tres response)
{
    return DoSomething<Tres, void>(response, null);
}

Est-ce faisable d'une manière ou d'une autre? Il semble que l'utilisation spécifique de void ne fonctionne pas, mais j'espère trouver quelque chose d'analogue.

Vous ne pouvez pas utiliser void, mais vous pouvez utiliser object: c'est un petit inconvénient car vos futures voidfonctions doivent revenir null, mais si cela unifie votre code, cela devrait être un petit prix à payer.

Cette incapacité à utiliser voidcomme type de retour est au moins partiellement responsable d'une scission entre les Func<...>et les Action<...>familles de délégués génériques: s'il avait été possible de revenir void, tout Action<X,Y,Z>deviendrait simplement Func<X,Y,Z,void>. Malheureusement, ce n'est pas possible.

Non, malheureusement non. Si voidc'était un type "réel" (comme uniten F # , par exemple), la vie serait beaucoup plus simple à bien des égards. En particulier, nous n'aurions pas besoin à la fois des familles Func<T>et Action<T>- il y aurait juste à la Func<void>place de Action, Func<T, void>au lieu de Action<T>etc.

Cela simplifierait également l'async - il n'y aurait aucun besoin du type non générique Task- nous l'aurions simplement fait Task<void>.

Malheureusement, ce n'est pas ainsi que fonctionnent les systèmes de type C # ou .NET ...

Voici ce que vous pouvez faire. Comme @JohnSkeet l'a dit, il n'y a pas de type d'unité en C #, alors faites-le vous-même!

public sealed class ThankYou {
   private ThankYou() { }
   private readonly static ThankYou bye = new ThankYou();
   public static ThankYou Bye { get { return bye; } }
}

Maintenant, vous pouvez toujours utiliser à la Func<..., ThankYou>place deAction<...>

public ThankYou MethodWithNoResult() {
   /* do things */
   return ThankYou.Bye;
}

Ou utilisez quelque chose déjà créé par l'équipe Rx: http://msdn.microsoft.com/en-us/library/system.reactive.unit%28v=VS.103%29.aspx

Vous pouvez simplement utiliser Objectcomme d'autres l'ont suggéré. Ou Int32dont j'ai vu une certaine utilité. Utiliser Int32introduit un nombre "factice" (utilisation 0), mais au moins vous ne pouvez pas mettre de gros objet exotique dans une Int32référence (les structures sont scellées).

Vous pouvez également écrire votre propre type "void":

public sealed class MyVoid
{
  MyVoid()
  {
    throw new InvalidOperationException("Don't instantiate MyVoid.");
  }
}

MyVoidles références sont autorisées (ce n'est pas une classe statique) mais ne peuvent l'être que null. Le constructeur d'instance est privé (et si quelqu'un essaie d'appeler ce constructeur privé par réflexion, une exception lui sera renvoyée).

Depuis l'introduction de tuples de valeur (2017, .NET 4.7), il est peut-être naturel d'utiliser la structure structValueTuple (le 0-tuple, la variante non générique) au lieu d'un tel MyVoid. Son instance a un ToString()qui renvoie "()", donc elle ressemble à un zéro-tuple. À partir de la version actuelle de C #, vous ne pouvez pas utiliser les jetons ()dans le code pour obtenir une instance. Vous pouvez utiliser default(ValueTuple)ou juste default(lorsque le type peut être déduit du contexte) à la place.

J'aime l'idée d'Aleksey Bykov ci-dessus, mais elle pourrait être un peu simplifiée

public sealed class Nothing {
    public static Nothing AtAll { get { return null; } }
}

Comme je ne vois aucune raison apparente pour laquelle Nothing.AtAll ne pourrait pas simplement donner null

La même idée (ou celle de Jeppe Stig Nielsen) est également idéale pour une utilisation avec des classes typées.

Par exemple, si le type n'est utilisé que pour décrire les arguments d'une procédure / fonction passée comme argument à une méthode, et qu'il ne prend lui-même aucun argument.

(Vous aurez toujours besoin de créer un emballage factice ou d'autoriser un "Nothing" facultatif. Mais à mon humble avis, l'utilisation de la classe semble bien avec myClass <Nothing>)

void myProcWithNoArguments(Nothing Dummy){
     myProcWithNoArguments(){
}

ou

void myProcWithNoArguments(Nothing Dummy=null){
    ...
}

void, bien qu'un type, n'est valide que comme type de retour d'une méthode.

Il n'y a aucun moyen de contourner cette limitation de void.

Ce que je fais actuellement, c'est créer des types scellés personnalisés avec un constructeur privé. C'est mieux que de lancer des exceptions dans le c-tor parce que vous n'avez pas besoin d'obtenir jusqu'à l'exécution pour comprendre que la situation est incorrecte. C'est subtilement mieux que de renvoyer une instance statique car vous n'avez pas à allouer une seule fois. C'est subtilement mieux que de renvoyer un null statique car il est moins détaillé du côté de l'appel. La seule chose que l'appelant peut faire est de donner null.

public sealed class Void {
    private Void() { }
}

public sealed class None {
    private None() { }
}