C # 4.0 optionale out / ref-Argumente

Erlaubt C # 4.0 optional outoder refArgumente?

Wie bereits erwähnt, ist dies einfach nicht erlaubt und ich denke, es macht einen sehr guten Sinn. Um weitere Details hinzuzufügen, finden Sie hier ein Zitat aus der C # 4.0-Spezifikation , Abschnitt 21.1:

Formale Parameter von Konstruktoren, Methoden, Indexern und Delegattypen können als optional deklariert werden:

fester Parameter:
    Attribute _opt Parameter-Modifikator _opt Typ Bezeichner Standardargument _opt
Standardargument:
    = Ausdruck

• Ein fester Parameter mit einem Standardargument ist ein optionaler Parameter , während ein fester Parameter ohne Standardargument ein erforderlicher Parameter ist .
• Ein erforderlicher Parameter kann nicht nach einem optionalen Parameter in einer formalen Parameterliste erscheinen .
• Ein refoder outParameter kann kein Standardargument haben .

Nein.

Eine Problemumgehung besteht darin, mit einer anderen Methode zu überladen, die keine out / ref-Parameter hat und nur Ihre aktuelle Methode aufruft.

public bool SomeMethod(out string input)
{
    ...
}

// new overload
public bool SomeMethod()
{
    string temp;
    return SomeMethod(out temp);
}

Update: Wenn Sie C # 7.0 haben , können Sie Folgendes vereinfachen:

// new overload
public bool SomeMethod()
{
    return SomeMethod(out _);    // declare out as an inline discard variable
}

(Danke @Oskar / @Reiner für den Hinweis.)

Nein, aber eine weitere gute Alternative besteht darin, dass die Methode eine generische Vorlagenklasse für optionale Parameter wie folgt verwendet:

public class OptionalOut<Type>
{
    public Type Result { get; set; }
}

Dann können Sie es wie folgt verwenden:

public string foo(string value, OptionalOut<int> outResult = null)
{
    // .. do something

    if (outResult != null) {
        outResult.Result = 100;
    }

    return value;
}

public void bar ()
{
    string str = "bar";

    string result;
    OptionalOut<int> optional = new OptionalOut<int> ();

    // example: call without the optional out parameter
    result = foo (str);
    Console.WriteLine ("Output was {0} with no optional value used", result);

    // example: call it with optional parameter
    result = foo (str, optional);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional.Result);

    // example: call it with named optional parameter
    foo (str, outResult: optional);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional.Result);
}

Es gibt tatsächlich eine Möglichkeit, die von C # zugelassen wird. Dies kehrt zu C ++ zurück und verstößt eher gegen die schöne objektorientierte Struktur von C #.

VERWENDEN SIE DIESE METHODE MIT VORSICHT!

So deklarieren und schreiben Sie Ihre Funktion mit einem optionalen Parameter:

unsafe public void OptionalOutParameter(int* pOutParam = null)
{
    int lInteger = 5;
    // If the parameter is NULL, the caller doesn't care about this value.
    if (pOutParam != null) 
    { 
        // If it isn't null, the caller has provided the address of an integer.
        *pOutParam = lInteger; // Dereference the pointer and assign the return value.
    }
}

Rufen Sie dann die Funktion folgendermaßen auf:

unsafe { OptionalOutParameter(); } // does nothing
int MyInteger = 0;
unsafe { OptionalOutParameter(&MyInteger); } // pass in the address of MyInteger.

Damit dies kompiliert werden kann, müssen Sie unsicheren Code in den Projektoptionen aktivieren. Dies ist eine wirklich hackige Lösung, die normalerweise nicht verwendet werden sollte. Wenn Sie jedoch für eine seltsame, arkane, mysteriöse, vom Management inspirierte Entscheidung WIRKLICH einen optionalen out-Parameter in C # benötigen, können Sie genau das tun.

ICYMI: In den hier aufgezählten neuen Funktionen für C # 7.0 ist "Verwerfen" jetzt als Out-Parameter in Form eines _ zulässig, damit Sie Parameter ignorieren können, die Sie nicht interessieren:

p.GetCoordinates(out var x, out _); // I only care about x

PS: Wenn Sie auch mit dem Teil "out var x" verwechselt werden, lesen Sie auch die neue Funktion zu "Out Variables" auf dem Link.

Nein, aber Sie können Actionalternativ einen Delegaten (z. B. ) verwenden.

Teilweise inspiriert von Robin Rs Antwort in einer Situation, in der ich dachte, ich wolle einen optionalen out-Parameter, habe ich stattdessen einen ActionDelegaten verwendet. Ich habe seinen Beispielcode ausgeliehen, um ihn für die Verwendung zu ändern Action<int>, um die Unterschiede und Ähnlichkeiten aufzuzeigen:

public string foo(string value, Action<int> outResult = null)
{
    // .. do something

    outResult?.Invoke(100);

    return value;
}

public void bar ()
{
    string str = "bar";

    string result;
    int optional = 0;

    // example: call without the optional out parameter
    result = foo (str);
    Console.WriteLine ("Output was {0} with no optional value used", result);

    // example: call it with optional parameter
    result = foo (str, x => optional = x);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional);

    // example: call it with named optional parameter
    foo (str, outResult: x => optional = x);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional);
}

Dies hat den Vorteil, dass die optionale Variable in der Quelle als normales int angezeigt wird (der Compiler umschließt sie in einer Abschlussklasse, anstatt sie explizit in eine benutzerdefinierte Klasse einzuschließen).

Die Variable muss explizit initialisiert werden, da der Compiler nicht davon ausgehen kann, dass die Actionaufgerufen wird, bevor der Funktionsaufruf beendet wird.

Es ist nicht für alle Anwendungsfälle geeignet, hat aber für meinen tatsächlichen Anwendungsfall gut funktioniert (eine Funktion, die Daten für einen Komponententest bereitstellt und für die ein neuer Komponententest Zugriff auf einen internen Status benötigt, der im Rückgabewert nicht vorhanden ist).

Verwenden Sie eine überladene Methode ohne den Parameter out, um die Methode mit dem Parameter out für C # 6.0 und niedriger aufzurufen. Ich bin mir nicht sicher, warum ein C # 7.0 für .NET Core überhaupt die richtige Antwort für diesen Thread ist, als speziell gefragt wurde, ob C # 4.0 einen optionalen out-Parameter haben kann. Die Antwort ist nein!

Was ist damit?

public bool OptionalOutParamMethod([Optional] ref string pOutParam)
{
    return true;
}

Sie müssen noch einen Wert von C # an den Parameter übergeben, dies ist jedoch ein optionaler ref-Parameter.

void foo(ref int? n)
{
    return null;
}