Überprüfen Sie das innere Methode, ob ein optionales argument übergeben wurde

Wie kann ich überprüfen, ob ein optionales argument an eine Methode übergeben?

public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint = 10)
{

    if (optionalint was passed)
       return;
}

Ein weiterer Ansatz ist die Verwendung Nullable<T>.HasValue (MSDN-Definitionen, MSDN-Beispiele):

int default_optionalint = 0;

public void ExampleMethod(int required, int? optionalint,
                            string optionalstr = "default string")
{
    int _optionalint = optionalint ?? default_optionalint;
}
  • Was ich meistens tun, ist geben Sie einen Standardwert (fi -1 in deinem Fall). Wenn es einen anderen Wert als -1 übergeben wurde. Man könnte auch machen das int nullable (int?) und geben Sie den Standardwert null
  • Warum würden Sie wollen, dies zu überprüfen? Der Punkt, der ein Standard ist, dass Sie brauchen nicht zu wissen
  • aus der MSDN-Website:"Für ein Beispiel, wenn möglicherweise verwenden Sie eine nullable-Typ, betrachten, wie ein gewöhnliches Boolean-Variablen können zwei Werte haben: true und false. Es gibt keinen Wert, der bedeutet "undefiniert"."
  • Nullable-Typen und optionalen Parameter werden mot der gleichen Sache.
  • Wenn Sie wollen einfach nur, um Doppelarbeit zu vermeiden-Konstanten im Vergleich (wenn ("default string" == "default string"), und nicht wirklich überprüfen, ob der parameter übergeben wurde, Sie könnte verwenden Sie reflektion, um Standard zu vergleichen und dann das. Wohl ein bisschen over the top, aber dann sollten Sie in der Lage, ändern der Standard-parameter in der Signatur, ohne änderungen am code. stackoverflow.com/a/29156478/586754
InformationsquelleAutor Yariv | 2014-01-02
  1. 15

    Gut, die Argumente sind immer übergeben. Die Standardwerte der parameter nur sicherzustellen, dass die Benutzer nicht haben, um explizit Sie angeben, wenn Sie die Funktion aufrufen.

    Wenn der compiler auf einen Aufruf wie dieser:

    ExampleMethod(1);

    Schweigend wandelt es zu:

    ExampleMethod(1, "default string", 10);

    Es ist also nicht techically möglich, zu bestimmen, wenn das argument übergeben wurde, zur Laufzeit. Die nächsten, die Sie bekommen konnte ist:

    if (optionalstr == "default string")
   return;

    Aber das würde sich gleich Verhalten, wenn der user nannte es explizit so:

    ExampleMethod(1, "default string");

    Die alternative, wenn Sie wirklich wollen, zu haben, die sich anders Verhalten, je nachdem, ob ein parameter angegeben wird, ist, um loszuwerden, der Standard-Parameter und verwenden Sie überlastungen statt, wie diese:

    public void ExampleMethod(int required)
{
    //optionalstr and optionalint not provided
}

public void ExampleMethod(int required, string optionalstr)
{
    //optionalint not provided
}

public void ExampleMethod(int required, string optionalstr, int optionalint)
{
    //all parameters provided
}
    • Ist es eine gute Lösung zu verwenden, eine null-argument Typ, wie in meiner Frage Bearbeiten?
    • Dass eigentlich nicht das problem lösen, es nur produziert eine andere Ebene der Dereferenzierung. Der Benutzer kann es immer noch mit einer expliziten parameter ExampleMethod(10, null), die nicht von ExampleMethod(10) zur Laufzeit. Obwohl, das könnte ausreichend sein, für Ihre Zwecke.
    InformationsquelleAutor p.s.w.g
  2. 6

    Kann man nicht, im Grunde. Die IL generiert für diese Gespräche ist genau das gleiche:

    ExampleMethod(10);
ExampleMethod(10, "default string");
ExampleMethod(10, "default string", 10);

    Den säumigen erfolgt auf den Ruf Website, die durch den compiler.

    Wenn Sie wirklich wollen, diese beiden Anrufe, um gültig zu sein, aber unterscheidbar sind, können Sie einfach überladen:

    //optionalint removed for simplicity - you'd need four overloads rather than two
public void ExampleMethod(int required)
{
    ExampleMethodImpl(required, "default string", false);
}

public void ExampleMethod(int required, string optionalstr)
{
    ExampleMethodImpl(required, optionalstr, true);
}

private void ExampleMethodImpl(int required, int optionalstr, bool optionalPassed)
{
    //Now optionalPassed will be true when it's been passed by the caller,
    //and false when we went via the "int-only" overload
}
    InformationsquelleAutor Jon Skeet
  3. 4

    Können Sie nicht tun dies in C#.

    Jedoch, Sie könnte überlast die Funktion zu nutzen, unterschiedliche Argumente. Das, übrigens, ist die nur Ansatz in Java, damit wären Sie in guter Gesellschaft, wenn Sie es annehmen.

    InformationsquelleAutor Bathsheba
  4. 3

    Können Sie nicht überprüfen, weil die Methode mit optionalen Parametern ist eine herkömmliche Methode mit allen Parametern, einschließlich derjenigen, die default-Werte. Also, deine Methode kompiliert, in:

    public void ExampleMethod(int required, string optionalstr, int optionalint)
{

}

    Default-Werte eingefügt werden durch compiler in den Aufruf zeigen. Wenn Sie schreiben

    ExampleMethod(42);

    Dann compiler generiert rufen

    ExampleMethod(42, "default string", 10);

    Können Sie vergleichen, wenn optionalstr oder optionalint hat Wert gleich dem default-Wert, aber Sie können nicht wirklich sagen, ob es vorgesehen war, durch den compiler oder durch den Entwickler.

    • Ist es eine gute Lösung zu verwenden, eine null-argument Typ, wie in meiner Frage Bearbeiten?
    • mit nullable Sie noch nicht in der Lage zu sagen, ob ein Wert nicht angegeben wurde, oder default_optionalint übergeben wurden, um Ihre Methode manuell. Default-Wert ist nur einer der möglichen Werte der parameter haben kann.
    InformationsquelleAutor Sergey Berezovskiy
  5. 3

    Können Sie nicht, Sie müssen also einen anderen Weg finden, um zu überprüfen für die "optionale" parameter. Sie können übergeben Sie eine null, wenn der parameter nicht verwendet wird, und überprüfen Sie dann 

    if (optionalstr != null)
{
    //do something
}

    Können Sie auch die überlastung der Methode, dass eine Einnahme der optionale Parameter und einen, der nicht nehmen Sie die optionalen Parameter. Auch, Sie können es so machen, dass die Methode ohne den optionalen Parameter übergibt, null-Werte, um eine der überladenen Methoden.

    public void ExampleMethod(int required)
{
    ExampleMethod(required, null, 0);
}

public void ExampleMethod(int required, string optionalstr = "default string",
int optionalint = 10)
{

}
    InformationsquelleAutor ScottK
  6. 1

    kann man nicht direkt schauen aber Sie können es überprüfen, indem Sie den Standardwert.
    zum Beispiel:

    public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint = 10)
{

    if (optionalint == 10)
       return;
}

    oder

    public void ExampleMethod(int required, string optionalstr = "default string",
    int? optionalint)
{

    if (required.HasValue==false)
       return;
}

    Ansatz 2:

    Außerdem können Sie überschreiben von Methoden:

    public void ExampleMethod(int required, string optionalstr = "default string")
{
     //When this method called, means optionalint was NOT passed
}

public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint)
{
    //When this method called, means optionalint was passed
}
    • Nullable<T>.HasValue wie eine gute Lösung scheint.
    • if (required.HasValue==false) - Benötigt keine null-Werte zulässt.
    • Ansatz 2 nicht kompilieren, ohne einen default-Wert für optionalInt.
    • Sie sollten die Implementierung von zwei Methoden zusammen, wenn Sie implementieren die Methode Nummer 2 in Ansatz 2 offensichtlich, dass es nicht kompiliert werden.
    InformationsquelleAutor Hadi Sharifi
  7. 0

    Ein weiterer Ansatz ist die Verwendung Nullable<T>.HasValue (MSDN-Definitionen, MSDN-Beispiele):

    int default_optionalint = 0;

public void ExampleMethod(int required, int? optionalint,
                            string optionalstr = "default string")
{
    int _optionalint = optionalint ?? default_optionalint;
}
    InformationsquelleAutor Yariv
  8. 0

    Necromancing ein Alter thread, aber dachte, ich würde etwas hinzufügen.

    Können Sie default(int) oder new int()

    Für bestimmten Fällen die default-Werte können verwendet werden, um zu überprüfen, wo ein argument übergeben wurde. Dies funktioniert für mehrere Datentypen. https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/default-values-table

    public void ExampleMethod(int optionalInt = default(int))
{
    if (optionalInt == default(int)) //no parameter passed
       //do something
    else  //parameter was passed
       return;
}

    Besonders gut funktioniert dies bei der übergabe der Datenbank-ids, in denen Aufzeichnungen halten vorzeichenlosen Ganzzahlen größer als 0 ist. Sie wissen also 0 immer null sein, und keine ids kann negativ sein. In anderen Worten, alles andere als Standard(Datentyp) akzeptiert als parameter übergeben.

    Würde ich persönlich gehe mit dem überladen von Methoden, aber ein anderer Ansatz (vielleicht ist das außerhalb des Geltungsbereichs dieser Frage) ist es, die input-Parameter in einem Modell. Verwenden Sie dann das Modell, Kraft, Grenzen (wie 10 Standard-parameter), können die Modell-Angebot, mit dem parameter, statt der Methode.

    public class Example
{
    //...other properties

    private int _optionalInt;
    public int OptionalInt {
        get => _optionalInt;
        set {
            if (value <= default(int))
                throw new ArgumentOutOfRangeException("Value cannot be 0 or less");
            else if (value == 10)
                throw new ArgumentOutOfRangeException("Value cannot be 10");
            else
                _initValue = value;
        } 
    }

    public Example(int optionalInt)
    {
        OptionalInt = optionalInt; //validation check in constructor
    }
}

    Diese Kräfte Verhalten, bevor es erreicht Ihre Methode.

    Hoffe, das jemand hilft.

    • Beachten Sie, dass die Verwendung default(int) oder new int() ist genau das gleiche wie mit 0... und es trotzdem nicht verhindern, dass der Anrufer von der Weitergabe in 0 explizit.
    • Richtig, aber es verbessert die Lesbarkeit als 0 bedeuten könnte mehrere Dinge, wo Standard-Werte, die definitiv bedeutet, was geschrieben ist, eine nicht zugewiesene default-Wert. Übergeben Sie 0 in diesem Fall, würde noch immer bedeuten soll obwohl. Vielen Dank für die Klarheit!
    • "default-Werte, die definitiv bedeutet, was geschrieben ist, eine nicht zugewiesene default-Wert" - Nein, tun Sie nicht. Sie bedeutet "den default-Wert des Typs" - also in diesem Fall 0. Übergeben Sie 0 würde Ihren code zu behaupten, es sei nicht verabschiedet worden, über die der aufrufende code, auch wenn es hatte. Sie nicht erkennen, ob der aufrufende code bestanden hat, ein argument explizit oder nicht.
    • Daher die bold bestimmten Fällen in meiner Antwort. Standard-und 0 behandelt, als gleich in der ersten Zeile der Methode. Der code wird nicht verhindern, dass Sie vorbei 0 oder auch default(int) als parameter (wie z.B. überlastung), aber indem Sinn, dass parameter = default(int) = new int() = 0 ist nicht initialisiert die Methode weiß, dass der parameter ist irrelevant, in diesem Fall überspringen zurück; es ist nicht ein Ende all-Lösung und hat definitiv seine Löcher, aber einen anderen Weg, es zu tun, die ich dachte, dass es hier dokumentieren. Auch ich denke, dass == default(long) ist mehr lesbar als == 0 haha.
    • Ich schlage vor, Sie Bearbeiten, die um einiges klarer, was meinen Sie mit "bestimmten Fällen". Ich interpretierte, dass "bestimmte Situationen, wie wenn Sie über einen Wert, Typ und erwarte nicht 0 übergeben werden explizit". Wenn Sie meinte, "Sie können erkennen, ob der übergebene Wert war der gleiche wie der Standard-Wert, aber Sie nicht sagen kann, ob das geschehen war, explizit oder implizit", dann ist das eine ganz andere Sache. In Bezug auf die Terminologie, der parameter nie nicht initialisiert - ich bin mir nicht sicher, was Sie beabsichtigen, die bedeuten.
    • Ich bin mir nicht sicher, was Sie nicht verstehen. Durch die Verwendung von default-Werten und die Prüfung auf default-Werte in der Methode der impliziten, dass ein anderer Wert als 0 oder default bedeutet, dass der parameter übergeben wurde, unabhängig davon, passing 0 (da im Rahmen der Methode - es trägt keine Bedeutung, also Standard). Ich erklärte Sie in meinem Beispiel mit "unsigned Integer" - Teil als gut. Sorry Tippfehler, ich meinte Standard. Sie sind willkommen zu Bearbeiten, die Antwort zu verbessern. Danke!
    • Ich fürchte, ich verstehe nicht, was Sie versuchen zu sagen, gut genug, um zu Bearbeiten, die Antwort. Aber grundsätzlich lautet die Antwort "Nein, man kann nicht sagen, ob das argument übergeben wurde, explizit oder nicht." Die Nutzung der default Betreiber ist orthogonal zu "hast du einen Wert, den Sie glauben wird nie übergeben werden, der ausdrücklich ist, können Sie diese als Standard-parameter". Das ist eine gültige Technik, aber ich denke, Sie haben es mehr verwirrend durch die Einführung der Standard-operator in die Dinge. -1 genauso wahrscheinlich, um ein "nie bestanden bewusst" Wert (vermutlich more wahrscheinlich als 0 ist eigentlich).
    • Ich denke, dass könnte sein, wo die Verwirrung kommt, sicher könnte man mit -1 oder je nachdem, welcher Wert, den Sie bevorzugen, aber es ist nicht eine c# vordefinierten Bezeichner für den Wert mit Ausnahme der default-Wert Ausdruck. Einige der anderen answes bereits abgedeckt, jene Punkte also, ich wollte nur etwas hinzufügen, das ist die alternative zu dem ihrigen. Vielen Dank für kratzen in meinem Gehirn, sehr aufschlussreiche Gespräch. Ich werde sehen, ob ich kann word es ein bisschen besser.

    InformationsquelleAutor Nick De Beer
  9. 0

    Verwendung von nullable ist eine gute Lösung.. siehe Beispiel unten

    public static void ExampleMethod(bool? optionalBool = null)
{
    Console.WriteLine(optionalBool == null ? "Value not passed" : "Value passed");
}


public static void Main()
{
    ExampleMethod();
    ExampleMethod(true);
    ExampleMethod(false);
}
    InformationsquelleAutor alhpe
  10. -1

    , Um zu bestimmen, ob ein argument übergeben wurde, um einen optionalen parameter

    1. Definieren einen extrem unwahrscheinlichen Wert als Standardwert für den parameter.
    2. Wenn der optionale parameter ist eine Referenz geben, wie ein String, die Sie verwenden können, null als der Standardwert, sofern diese nicht den erwarteten Wert für das argument.
    3. In der Prozedur-code, vergleichen Sie die parameter vor dem default-Wert und die geeigneten Maßnahmen ergreifen.

    https://msdn.microsoft.com/en-us/library/849zff9h(v=vs. 100).aspx

    • Das kann man nicht bestimmen, wenn der Aufrufer einen Wert, weil die Anrufer können wählen Sie immer explizit angeben, was Standard-Wert, den Sie verwenden, wie bereits in mehreren anderen Antworten.
    • nicht Lesen die Antwort richtig..kann Sie gehen durch eine mehr Zeit. Außerdem ist es nicht meine Antwort, es aus der Microsoft-Dokumentation finden Sie den link.
    • Scheinbar hat man nicht wirklich Lesen Sie die Frage richtig. Die Frage, die fragt, wie man unterscheiden zwischen einem Anrufer nicht, die einen Wert für einen parameter mit einem Standardwert, und der Anrufer Bereitstellung der default-Wert. Deine Antwort keine Lösung. Der link weist ausdrücklich darauf hin, dass es nicht eine Lösung, so dass es nicht wirklich helfen, Ihren Fall.
    • Es gibt keine richtige Antwort auf diese Frage und wird auch nie einer werden. Das ist der Grund, Microsoft-Dokumentation betont, dass seine Lösung nicht. Zu Ihrer information, dieses feature eingeführt wurde Weise lange so weit zurück, wie visual Basic 5.0.
    • Natürlich gibt es eine richtige Antwort. Die richtige Antwort ist, dass es unmöglich ist, wie die anderen Antworten gesagt haben, und wie die Dokumentation, die du verlinkt hast zu Staaten. Ihre Behauptung, dass es tatsächlich möglich ist eine falsche Antwort. Ich sehe nicht, wie die Zeit, die das feature wurde Hinzugefügt, hat nichts damit zu tun. Auch die Frage über C#, nicht VB.
    InformationsquelleAutor OrganicCoder
Schreibe einen Kommentar