C # 4.0: Kann ich einen TimeSpan als optionalen Parameter mit einem Standardwert verwenden?

Umgehen kannst du dies sehr leicht, indem Sie Ihre Unterschrift.

void Foo(TimeSpan? span = null) {

   if (span == null) { span = TimeSpan.FromSeconds(2); }

   ...

}

Sollte ich umständlich - der Grund, die Ausdrücke in deinem Beispiel sind keine compile-Zeit-Konstanten ist da beim kompilieren, kann der compiler nicht einfach ausführen Zeitspanne.FromSeconds(2.0) stick und die bytes des Ergebnisses in Ihrer kompilierten code.

Betrachten Sie beispielsweise, wenn Sie versucht, auf DateTime.Jetzt statt. Der Wert von DateTime.Jetzt ändert sich jedes mal, wenn es ausgeführt wird. Oder angenommen, TimeSpan.FromSeconds berücksichtigte die Schwerkraft. Es ist ein absurdes Beispiel, aber die Regeln des compile-Zeit-Konstanten nicht machen besonderen Fällen, nur weil wir zufällig wissen, dass TimeSpan.FromSeconds deterministisch ist.

InformationsquelleAutor der Antwort Josh

Dieser gut funktioniert:

void Foo(TimeSpan span = default(TimeSpan))

InformationsquelleAutor der Antwort Elena Lavrinenko

void Foo(TimeSpan span = default(TimeSpan))
{
    if (span == default(TimeSpan)) 
        span = TimeSpan.FromSeconds(2); 
}

zur Verfügung gestellt default(TimeSpan) ist kein Gültiger Wert für die Funktion.

Oder

//this works only for value types which TimeSpan is
void Foo(TimeSpan span = new TimeSpan())
{
    if (span == new TimeSpan()) 
        span = TimeSpan.FromSeconds(2); 
}

zur Verfügung gestellt new TimeSpan() ist kein Gültiger Wert.

Oder

void Foo(TimeSpan? span = null)
{
    if (span == null) 
        span = TimeSpan.FromSeconds(2); 
}

Diese sollten besser sein, in Anbetracht Chancen null Wert einen gültigen Wert für die Funktion sind selten.

InformationsquelleAutor der Antwort nawfal

Andere Antworten haben große Erklärungen, warum ein optionaler parameter, der nicht einen dynamischen Ausdruck. Aber, um zu erzählen, Standard-Parameter Verhalten sich wie die compile-Zeit-Konstanten. Das bedeutet, dass der compiler muß in der Lage sein, um Sie zu bewerten und kommen mit einer Antwort. Es gibt einige Leute, die wollen C# hinzufügen der Unterstützung für compiler-Evaluierung dynamischer Ausdrücke bei der Begegnung mit Konstanten Deklarationen—diese Art von feature wäre in Bezug auf Kennzeichnung, Methoden der "reinen", aber das ist nicht eine Realität, jetzt und vielleicht nie werden.

Eine alternative für die Verwendung einer C# - Standard-parameter für eine solche Methode wäre, um die Muster am Beispiel von XmlReaderSettings. In diesem Muster definieren Sie eine Klasse mit einer parameterlosen Konstruktor und öffentlich beschreibbaren Eigenschaften. Dann ersetzen Sie alle Optionen mit Standardwerten in Ihre Methode mit einem Objekt von diesem Typ. Auch machen Sie dieses Objekt, optional durch die Angabe eines default von null. Zum Beispiel:

public class FooSettings
{
    public TimeSpan Span { get; set; } = TimeSpan.FromSeconds(2);

    //I imagine that if you had a heavyweight default
    //thing you’d want to avoid instantiating it right away
    //because the caller might override that parameter. So, be
    //lazy! (Or just directly store a factory lambda with Func<IThing>).
    Lazy<IThing> thing = new Lazy<IThing>(() => new FatThing());
    public IThing Thing
    {
        get { return thing.Value; }
        set { thing = new Lazy<IThing>(() => value); }
    }

    //Another cool thing about this pattern is that you can
    //add additional optional parameters in the future without
    //even breaking ABI.
    //bool FutureThing { get; set; } = true;

    //You can even run very complicated code to populate properties
    //if you cannot use a property initialization expression.
    //public FooSettings() { }
}

public class Bar
{
    public void Foo(FooSettings settings = null)
    {
        //Allow the caller to use *all* the defaults easily.
        settings = settings ?? new FooSettings();

        Console.WriteLine(settings.Span);
    }
}

Aufrufen, verwenden Sie diesen seltsamen syntax für das instanzieren und zuweisen von Eigenschaften alle in einem Ausdruck:

bar.Foo(); //00:00:02
bar.Foo(new FooSettings { Span = TimeSpan.FromDays(1), }); //1.00:00:00
bar.Foo(new FooSettings { Thing = new MyCustomThing(), }); //00:00:02

Nachteile

Dies ist ein wirklich schwerwiegend Ansatz zur Lösung dieses Problems. Wenn Sie schreiben einen quick-and-dirty interne Schnittstelle und machen Sie die Zeit null-Werte zulässt und die Behandlung von null-wie Ihre gewünschte Standard-Wert würde funktionieren, nicht stattdessen.

Auch, wenn Sie eine große Anzahl von Parametern oder sind dem Aufruf der Methode in einer engen Schleife, wird dies den overhead der class-Instanzen. Natürlich, wenn der Aufruf einer solchen Methode in eine Endlosschleife geraten, könnte es natürlich sein und auch sehr einfach wiederverwenden eine Instanz der FooSettings Objekt.

Vorteile

Wie ich bereits im Kommentar im Beispiel, ich denke, dieses Muster ist für den öffentlichen APIs. Hinzufügen von Eigenschaften zu einer Klasse ist ein non-breaking ABI ändern, so können Sie neue optionale Parameter, ohne die änderung der Signatur der Methode, die dieses Muster verwenden—geben mehr kürzlich kompilierten code mehr Optionen während der weiteren Unterstützung der alten kompilierten code mit keine zusätzliche Arbeit.

Auch, weil C#'s gebaut in Standard-Parameter der Methode behandelt werden als compile-Zeit-Konstanten und gebacken in der callsite, Standard-Parameter wird nur verwendet, indem der code einmal kompiliert wird. Durch instanziieren eines einstellungsobjekts, die Anrufer lädt dynamisch die default-Werte, die beim Aufruf Ihrer Methode. Dies bedeutet, dass Sie aktualisieren können Standardeinstellungen ändern Sie einfach Ihre Einstellungen. Klasse. So, dieses Muster können Sie die Standardwerte ändern ohne neu kompilieren zu müssen Anrufer zu sehen, die neuen Werte, falls dies gewünscht wird.

InformationsquelleAutor der Antwort binki