nichtig in C # Generika?

Ich habe eine generische Methode, die eine Anfrage entgegennimmt und eine Antwort liefert.

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

Ich möchte jedoch nicht immer eine Antwort auf meine Anfrage, und ich möchte nicht immer Anforderungsdaten eingeben, um eine Antwort zu erhalten. Ich möchte auch nicht, dass Methoden vollständig kopiert und eingefügt werden müssen, um geringfügige Änderungen vorzunehmen. Was ich will, ist, dies tun zu können:

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

Ist das irgendwie machbar? Es scheint, dass die spezifische Verwendung von void nicht funktioniert, aber ich hoffe, etwas Analoges zu finden.

Sie können nicht verwenden void, aber Sie können verwenden object: Es ist ein wenig unpraktisch, weil Ihre potenziellen voidFunktionen zurückgegeben werden müssen null, aber wenn es Ihren Code vereinheitlicht, sollte es ein kleiner Preis sein, den Sie zahlen müssen.

Diese Unfähigkeit, voidals Rückgabetyp zu verwenden, ist zumindest teilweise für eine Aufteilung zwischen den Func<...>und den Action<...>Familien der generischen Delegierten verantwortlich: Wäre eine Rückgabe möglich gewesen void, Action<X,Y,Z>würde alles einfach werden Func<X,Y,Z,void>. Das geht leider nicht.

Nein, leider nicht. Wennvoid ein "echter" Typ wäre (wie zum Beispiel unitin F # ), wäre das Leben in vielerlei Hinsicht viel einfacher. Insbesondere würden wir nicht sowohl die Func<T>als auch die Action<T>Familien brauchen - es würde nur Func<void>statt Action, Func<T, void>statt Action<T>usw. geben.

Es würde auch die Asynchronisation einfacher machen - der nicht generische TaskTyp wäre überhaupt nicht erforderlich - wir hätten es einfach getan Task<void>.

Leider funktionieren die Systeme vom Typ C # oder .NET nicht so ...

Hier ist was Sie tun können. Wie @JohnSkeet sagte, gibt es in C # keinen Einheitentyp, also machen Sie es selbst!

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

Jetzt können Sie immer Func<..., ThankYou>anstelle von verwendenAction<...>

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

Oder verwenden Sie etwas, das bereits vom Rx-Team erstellt wurde: http://msdn.microsoft.com/en-us/library/system.reactive.unit%28v=VS.103%29.aspx

Sie können einfach verwenden, Objectwie andere vorgeschlagen haben. Oder Int32was ich gesehen habe. Mit using wird Int32eine "Dummy" -Nummer eingeführt (Verwendung 0), aber zumindest können Sie kein großes und exotisches Objekt in eine Int32Referenz einfügen (Strukturen sind versiegelt).

Sie können auch Ihren eigenen "void" -Typ schreiben:

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

MyVoidReferenzen sind erlaubt (es ist keine statische Klasse), können aber nur sein null. Der Instanzkonstruktor ist privat (und wenn jemand versucht, diesen privaten Konstruktor durch Reflektion aufzurufen, wird eine Ausnahme ausgelöst).

Da Werttupel eingeführt wurden (2017, .NET 4.7), ist es möglicherweise natürlich, die StrukturValueTuple (das 0-Tupel, die nicht generische Variante) anstelle eines solchen zu verwenden MyVoid. Die Instanz hat eine ToString(), die zurückgibt "()", sodass sie wie ein Null-Tupel aussieht. Ab der aktuellen Version von C # können Sie die Token ()im Code nicht mehr verwenden , um eine Instanz abzurufen. Sie können stattdessen default(ValueTuple)oder nur default(wenn der Typ aus dem Kontext abgeleitet werden kann) verwenden.

Ich mag die Idee von Aleksey Bykov oben, aber sie könnte etwas vereinfacht werden

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

Da sehe ich keinen offensichtlichen Grund warum Nothing.AtAll nicht einfach null geben konnte

Die gleiche Idee (oder die von Jeppe Stig Nielsen) eignet sich auch hervorragend für typisierte Klassen.

Beispiel, wenn der Typ nur verwendet wird, um die Argumente für eine Prozedur / Funktion zu beschreiben, die als Argument an eine Methode übergeben wurde, und selbst keine Argumente akzeptiert.

(Sie müssen immer noch entweder einen Dummy-Wrapper erstellen oder ein optionales "Nothing" zulassen. Aber meiner Meinung nach sieht die Klassenverwendung mit myClass <Nothing> gut aus.)

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

oder

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

voidObwohl ein Typ, ist er nur als Rückgabetyp einer Methode gültig.

An dieser Einschränkung von führt kein Weg vorbei void.

Was ich derzeit mache, ist das Erstellen von benutzerdefinierten versiegelten Typen mit einem privaten Konstruktor. Dies ist besser, als Ausnahmen in den C-Tor zu werfen, da Sie erst zur Laufzeit abrufen müssen, um herauszufinden, ob die Situation falsch ist. Es ist subtil besser als die Rückgabe einer statischen Instanz, da Sie nicht einmal zuordnen müssen. Es ist subtil besser als die Rückgabe der statischen Null, da es auf der Aufrufseite weniger ausführlich ist. Der Anrufer kann nur null angeben.

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

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