C # 7: Unterstrich (_) & Stern (*) in Out-Variable

Ich lese über neue aus variablen Funktionen in C # 7 hier . Ich habe zwei Fragen:

1. Es sagt

   Wir erlauben auch "Verwerfen" als Out-Parameter in Form von a _, damit Sie Parameter ignorieren können, die Sie nicht interessieren:

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

   F: Ich denke, dies ist nur eine Information und keine neue Funktion von C # 7, da wir dies auch in Pre C # 7.0 tun können:

   var _;
   if (Int.TryParse(str, out _))
   ...
   

   oder fehlt mir hier etwas

2. Mein Code gibt einen Fehler aus, wenn ich wie im selben Blog erwähnt vorgehe:

   ~Person() => names.TryRemove(id, out *);
   

   *ist keine gültige Kennung. Ein Versehen von Mads Torgersen, denke ich?

Discards in C # 7 können überall dort verwendet werden, wo eine Variable deklariert ist, um - wie der Name schon sagt - das Ergebnis zu verwerfen. Ein Discard kann also ohne Variablen verwendet werden:

p.GetCoordinates(out var x, out _);

und es kann verwendet werden, um ein Ausdrucksergebnis zu verwerfen:

_ = 42;

Im Beispiel

p.GetCoordinates(out var x, out _);
_ = 42;

Es wird keine Variable _eingeführt. Es gibt nur zwei Fälle, in denen ein Abwurf verwendet wird.

Wenn jedoch ein Bezeichner _im Bereich vorhanden ist, können Rückwürfe nicht verwendet werden:

var _ = 42;
_ = "hello"; // error - a string cannot explicitly convert from string to int

Die Ausnahme ist, wenn eine _Variable als Out-Variable verwendet wird. In diesem Fall ignoriert der Compiler den Typ oder varund behandelt ihn als Verwerfen:

if (p.GetCoordinates(out double x, out double _))
{
    _ = "hello"; // works fine.
    Console.WriteLine(_); // error: _ doesn't exist in this context.
}

Beachten Sie, dass dies nur auftritt, wenn in diesem Fall out var _oder out double _verwendet wird. Verwenden out _Sie einfach und dann wird es als Referenz auf eine vorhandene Variable behandelt _, wenn es im Geltungsbereich liegt, z.

string _;
int.TryParse("1", out _); // complains _ is of the wrong type

Schließlich wurde die *Notation zu Beginn der Diskussionen um Rückwürfe vorgeschlagen, jedoch zugunsten der _Notation aufgegeben , da letztere in anderen Sprachen häufiger verwendet wird .

Ein weiteres Beispiel des Discard Operators _in C # 7 ist auf Mustererkennung eine Variable vom Typ objectin einer switchErklärung, die vor kurzem in C # 7 hinzugefügt wurde:

Code:

static void Main(string[] args)
{
    object x = 6.4; 
    switch (x)
    {
        case string _:
            Console.WriteLine("it is string");
            break;
        case double _:
            Console.WriteLine("it is double");
            break;
        case int _:
            Console.WriteLine("it is int");
            break;
        default:
            Console.WriteLine("it is Unknown type");
            break;
    }

    // end of main method
}

Dieser Code entspricht dem Typ und verwirft die an die übergebene Variable case ... _.

Für neugierigere

Betrachten Sie das folgende Snippet

static void Main(string[] args)
{
    //....
    int a;
    int b;

    Test(out a, out b);
    Test(out _, out _);    
    //....
}

private static void Test(out int a, out int b)
{
    //...
}

Folgendes passiert:

...

13:             int  a;
14:             int  b;
15: 
16:             Test(out a, out b);
02340473  lea         ecx,[ebp-40h]  
02340476  lea         edx,[ebp-44h]  
02340479  call        02340040  
0234047E  nop  
    17:             Test(out _, out _);
0234047F  lea         ecx,[ebp-48h]  
02340482  lea         edx,[ebp-4Ch]  
02340485  call        02340040  
0234048A  nop 

...

Wie Sie hinter den Kulissen sehen können, machen die beiden Anrufe dasselbe.

Als @ Servé Laurijssen die kühle Sache wies darauf hin, dass Sie müssen nicht im Voraus declare Variablen , die praktisch ist , wenn Sie nicht in einigen Werten interessiert sind.

Zur ersten Frage

Ich denke, dies ist nur eine Information und keine neue Funktion von C # 7, da wir dies auch in Pre C # 7.0 tun können.

var _;
if (Int.TryParse(str, out _))
    // ...

Das Neue ist, dass Sie nicht _mehr innerhalb oder außerhalb des Ausdrucks deklarieren müssen und einfach tippen können

int.TryParse(s, out _);

Versuchen Sie, diesen einen Liner vor C # 7 zu machen:

private void btnDialogOk_Click_1(object sender, RoutedEventArgs e)
{
     DialogResult = int.TryParse(Answer, out _);
}

In C # 7.0 (Visual Studio 2017 um März 2017) werden Verwerfungen in Zuweisungen in den folgenden Kontexten unterstützt:

• Tupel- und Objektdekonstruktion.
• Musterabgleich mit is und switch .
• Ruft Methoden ohne Parameter auf.
• Ein eigenständiges _, wenn kein _ im Geltungsbereich ist.

Andere nützliche Hinweise

• Durch Verwerfen können die Speicherzuordnungen verringert werden. Da sie die Absicht Ihres Codes klar machen, verbessern sie dessen Lesbarkeit und Wartbarkeit
• Beachten Sie, dass _ auch ein gültiger Bezeichner ist. Bei Verwendung außerhalb eines unterstützten Kontexts

Einfaches Beispiel: Hier wollen wir nicht den 1. und 2. Parameter verwenden und brauchen nur den 3. Parameter

(_, _, area) = city.GetCityInformation(cityName);

Erweitertes Beispiel im Switch-Fall, bei dem auch der moderne Switch-Case-Pattern-Matching ( Quelle ) verwendet wurde.

switch (exception)                {
case ExceptionCustom exceptionCustom:       
        //do something unique
        //...
    break;
case OperationCanceledException _:
    //do something else here and we can also cast it 
    //...
    break;
default:
    logger?.Error(exception.Message, exception);
    //..
    break;

}}

F: ... wir können dies auch in Pre C # 7.0 tun:

var _;
if (Int.TryParse(str, out _))

oder fehlt mir hier etwas

Das ist nicht dasselbe.
Ihr Code nimmt eine Zuordnung vor.

In C # 7.0 ist _ keine Variable, sondern weist den Compiler an, den Wert zu verwerfen
(es sei denn, Sie haben _ als Variable deklariert ... wenn Sie dies tun, wird die Variable anstelle des Verwerfungssymbols verwendet).

Beispiel: Sie können _ als Sting und Int in derselben Codezeile verwenden :

string a; 
int b;
Test(out a, out b);
Test(out _, out _);

//...

void Test(out string a, out int b)
{
   //...
}