void in C # generics?

Ho un metodo generico che accetta una richiesta e fornisce una risposta.

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

Ma non desidero sempre una risposta per la mia richiesta e non voglio sempre alimentare i dati della richiesta per ottenere una risposta. Inoltre, non voglio dover copiare e incollare i metodi nella loro interezza per apportare modifiche minori. Quello che voglio, è essere in grado di fare questo:

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

È fattibile in qualche modo? Sembra che l'uso specifico di void non funzioni, ma spero di trovare qualcosa di analogo.

Non puoi usare void, ma puoi usare object: è un piccolo inconveniente perché le tue aspiranti voidfunzioni devono tornare null, ma se unifica il tuo codice, dovrebbe essere un piccolo prezzo da pagare.

Questa incapacità di utilizzare voidcome tipo di ritorno è almeno in parte responsabile di una divisione tra le famiglie Func<...>e Action<...>dei delegati generici: se fosse stato possibile tornare void, tutto Action<X,Y,Z>sarebbe diventato semplice Func<X,Y,Z,void>. Sfortunatamente, questo non è possibile.

No, sfortunatamente no. Se voidfosse un tipo "reale" (come unitin F # , per esempio) la vita sarebbe molto più semplice in molti modi. In particolare, non avremmo bisogno di entrambe le famiglie Func<T>e Action<T>- ci sarebbero solo Func<void>invece di Action, Func<T, void>invece di Action<T>ecc.

Renderebbe anche l'asincronia più semplice - non ci sarebbe affatto bisogno del tipo non generico Task- avremmo semplicemente Task<void>.

Sfortunatamente, non è così che funzionano i sistemi di tipo C # o .NET ...

Ecco cosa puoi fare. Come ha detto @JohnSkeet non esiste un tipo di unità in C #, quindi crealo tu stesso!

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

Ora puoi sempre usare al Func<..., ThankYou>posto diAction<...>

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

Oppure utilizza qualcosa già creato dal team Rx: http://msdn.microsoft.com/en-us/library/system.reactive.unit%28v=VS.103%29.aspx

Potresti semplicemente usare Objectcome altri hanno suggerito. O Int32che ho visto un certo utilizzo. L'uso Int32introduce un numero "fittizio" (usa 0), ma almeno non puoi mettere nessun oggetto grande ed esotico in un Int32riferimento (le strutture sono sigillate).

Puoi anche scrivere il tuo tipo "void":

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

MyVoidi riferimenti sono consentiti (non è una classe statica) ma possono essere solo null. Il costruttore dell'istanza è privato (e se qualcuno cerca di chiamare questo costruttore privato tramite la riflessione, verrà lanciata un'eccezione).

Poiché sono state introdotte le tuple di valore (2017, .NET 4.7), è forse naturale utilizzare la strutturaValueTuple (la tupla 0, la variante non generica) invece di tale MyVoid. La sua istanza ha un ToString()che restituisce "()", quindi sembra una tupla zero. A partire dalla versione corrente di C #, non è possibile utilizzare i token ()nel codice per ottenere un'istanza. Puoi usare default(ValueTuple)o solo default(quando il tipo può essere dedotto dal contesto) invece.

Mi piace l'idea di Aleksey Bykov sopra, ma potrebbe essere semplificata un po '

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

Non vedo alcun motivo apparente per cui Nothing.AtAll non poteva semplicemente dare null

La stessa idea (o quella di Jeppe Stig Nielsen) è ottima anche per l'utilizzo con classi dattiloscritte.

Ad esempio, se il tipo viene utilizzato solo per descrivere gli argomenti di una procedura / funzione passata come argomento a un metodo, e esso stesso non accetta alcun argomento.

(Dovrai comunque creare un wrapper fittizio o consentire un "Niente" opzionale. Ma IMHO l'utilizzo della classe sembra carino con myClass <Niente>)

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

o

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

void, sebbene sia un tipo, è valido solo come tipo restituito di un metodo.

Non c'è modo di aggirare questa limitazione di void.

Quello che faccio attualmente è creare tipi sigillati personalizzati con un costruttore privato. Questo è meglio che lanciare eccezioni nel c-tor perché non devi andare fino al runtime per capire che la situazione non è corretta. È sottilmente meglio che restituire un'istanza statica perché non è necessario allocare nemmeno una volta. È sottilmente meglio che restituire null statico perché è meno dettagliato sul lato della chiamata. L'unica cosa che il chiamante può fare è dare null.

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

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