C # 7: podkreślenie (_) i gwiazdka (*) w zmiennej Out

Czytałem o nowych funkcjach zmiennych wyjściowych w C # 7 tutaj . Mam dwa pytania:

1. To mówi

   Zezwalamy również na „discards” jako parametry out, w postaci a _, aby pozwolić Ci zignorować parametry, które Cię nie interesują:

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

   P: Wydaje mi się, że to tylko informacja, a nie nowa funkcja języka C # 7, ponieważ możemy to zrobić również w C # 7.0:

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

   czy coś mi tu brakuje?

2. Mój kod wyświetla błąd, gdy robię to, co wspomniano na tym samym blogu:

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

   *nie jest prawidłowym identyfikatorem. Myślę, że przeoczenie Madsa Torgersena?

Odrzucenia , w C # 7 mogą być używane wszędzie tam, gdzie deklarowana jest zmienna, aby - jak sama nazwa wskazuje - odrzucić wynik. Zatem odrzucenie może być użyte bez zmiennych:

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

i można go użyć do odrzucenia wyniku wyrażenia:

_ = 42;

W przykładzie

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

Nie ma żadnej zmiennej _, która jest wprowadzana. Istnieją tylko dwa przypadki użycia odrzutu.

Jeśli jednak _w zakresie istnieje identyfikator , nie można użyć odrzutów:

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

Wyjątkiem jest sytuacja, gdy _zmienna jest używana jako zmienna wyjściowa. W tym przypadku kompilator ignoruje typ lub vari traktuje go jako odrzucenie:

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

Zauważ, że dzieje się tak tylko wtedy, gdy w tym przypadku jest używane out var _lub out double _. Po prostu użyj, out _a następnie jest traktowany jako odniesienie do istniejącej zmiennej _, jeśli jest w zakresie, np:

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

Wreszcie *notacja została zaproponowana na wczesnym etapie dyskusji na temat odrzutów, ale została porzucona na rzecz _tego ostatniego, ponieważ jest to notacja częściej stosowana w innych językach .

Innym przykładem Discard Operator _w C # 7 jest dopasowanie wzorca zmiennej typu objectw switchinstrukcji, która została ostatnio dodana w C # 7:

Kod:

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
}

Ten kod będzie pasował do typu i odrzuci zmienną przekazaną do case ... _.

Dla bardziej zaciekawionych

Rozważmy następujący fragment

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)
{
    //...
}

Oto, co się dzieje:

...

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 

...

Jak widać za kulisami, te dwie rozmowy mają ten sam skutek.

Jak zauważył @ Servé Laurijssen, fajne jest to, że nie musisz wstępnie deklarować zmiennych, co jest przydatne, jeśli nie jesteś zainteresowany niektórymi wartościami.

Odnośnie pierwszego pytania

Myślę, że to tylko informacja, a nie nowa funkcja C # 7, ponieważ możemy to zrobić również w C # 7,0.

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

Nowością jest to, że nie musisz _już deklarować wewnątrz ani na zewnątrz wyrażenia i możesz po prostu wpisać

int.TryParse(s, out _);

Spróbuj zrobić to jedną linijką przed C # 7:

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

W C # 7.0 (Visual Studio 2017 około marca 2017) odrzucenia są obsługiwane w przydziałach w następujących kontekstach:

• Krotka i dekonstrukcja obiektów.
• Dopasowanie wzorców z is i przełącznikiem .
• Wywołania metod bez parametrów.
• Autonomiczny _, gdy nie _ jest w zakresie.

Inne przydatne uwagi

• odrzucenia mogą zmniejszyć alokacje pamięci. Ponieważ wyjaśniają intencję kodu, zwiększają jego czytelność i łatwość utrzymania
• Zauważ, że _ jest również prawidłowym identyfikatorem. Gdy jest używany poza obsługiwanym kontekstem

Prosty przykład: tutaj nie chcemy używać pierwszego i drugiego parametru i potrzebujemy tylko trzeciego parametru

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

Zaawansowany przykład w przypadku przełącznika, w którym zastosowano również nowoczesne dopasowanie wzorców obudowy przełącznika ( źródło )

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;

}

P: ... możemy to zrobić również w C # 7.0:

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

czy coś mi tu brakuje?

To nie to samo.
Twój kod dokonuje przypisania.

W C # 7.0 _ nie jest zmienną, informuje kompilator, aby odrzucił wartość
( chyba że zadeklarowałeś _ jako zmienną ... jeśli to zrobisz, zmienna jest używana zamiast symbolu odrzucenia)

Przykład: możesz użyć _ jako żądła i int w tej samej linii kodu :

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

//...

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