Jak wyraźnie odrzucić argument zewnętrzny?

Dzwonię:

myResult = MakeMyCall(inputParams, out messages);

ale tak naprawdę nie obchodzą mnie wiadomości. Gdyby to był parametr wejściowy, na którym mi nie zależało, po prostu podałbym wartość null. Gdyby to był powrót, na którym mi nie zależało, zostawiłbym to.

Czy istnieje sposób na zrobienie czegoś podobnego bez wyjścia, czy też muszę zadeklarować zmienną, którą następnie zignoruję?

Począwszy od języka C # 7.0, można uniknąć wcześniejszego deklarowania parametrów, a także ich ignorowania.

public void PrintCoordinates(Point p)
{
    p.GetCoordinates(out int x, out int y);
    WriteLine($"({x}, {y})");
}

public void PrintXCoordinate(Point p)
{
    p.GetCoordinates(out int x, out _); // I only care about x
    WriteLine($"{x}");
}

Źródło: https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/

Niestety musisz coś przekazać, ponieważ metoda jest wymagana, aby to ustawić. Więc nie możesz wysłać, nullponieważ metoda, która byłaby wymagana do jej ustawienia, wybuchłaby.

Jednym ze sposobów na ukrycie brzydoty byłoby zawinięcie metody w inną metodę, która wykonuje outparametr za Ciebie:

String Other_MakeMyCall(String inputParams)
{
    String messages;

    return MakeMyCall(inputParams, out messages);
}

Wtedy możesz zadzwonić Other_MakeMyCallbez konieczności manipulowaniaout parametrach, których nie potrzebujesz.

Musisz zadeklarować zmienną, którą następnie zignorujesz. Dzieje się tak najczęściej w przypadku wzorca TryParse (lub TryWhthing), gdy jest on używany do testowania poprawności danych wejściowych użytkownika (np. Czy można je przeanalizować jako liczbę?) Bez zwracania uwagi na rzeczywistą przeanalizowaną wartość.

W pytaniu użyłeś słowa „dispose”, co, jak podejrzewam, było po prostu niefortunne - ale jeśli parametr out jest typu, który implementuje IDisposable, z pewnością powinieneś wywołać Dispose, chyba że dokumentacja metody wyraźnie stwierdza, że ​​otrzymanie wartości nie nadaje własność. Nie pamiętam outjednak, żeby kiedykolwiek widziałem metodę z jednorazowym parametrem, więc mam nadzieję, że był to po prostu niefortunny dobór słów.

Jeśli oryginalna funkcja jest zadeklarowana w następujący sposób:

class C
{
    public Result MakeMyCall(Object arg, out List<String> messages);
}

Możesz zadeklarować taką metodę rozszerzenia:

static class CExtension
{
    public static Result MakeMyCall(this C obj, Object arg)
    {
        List<String> unused;
        return obj.MakeMyCall(arg, out unused);
    }
}

Metoda rozszerzenia będzie zachowywać się jak przeciążenie, które powoduje, że parametr out jest opcjonalny.

Kompilator Visual Basic robi to, tworząc zmienną fikcyjną. C # mógłby to zrobić, jeśli przekonasz Microsoft, że to dobry pomysł.

Jeśli chodzi o klasę messagesnarzędzi IDisposable, nie powinieneś jej ignorować. Rozważ coś takiego jak następujące podejście (może nie być poprawne składniowo, ponieważ od jakiegoś czasu nie pisałem C #):

using (FooClass messages) {
    myResult = MakeMyCall(inputParams, messages);
}

Po wyjściu z usingbloku messageszostanie usunięty automatycznie.

Musisz przekazać zmienną dla parametru out. Nie musisz inicjalizować zmiennej przed jej przekazaniem:

MyMessagesType messages;
myResult = MakeMyCall(inputParams, out messages); 

Zwykle możesz po prostu zignorować `` wiadomości '' po wywołaniu - chyba że `` wiadomości '' wymagają usunięcia z jakiegoś powodu, takiego jak użycie ograniczonych zasobów systemowych, w takim przypadku powinieneś wywołać Dispose ():

messages.Dispose();

Jeśli może zużywać znaczną ilość pamięci i przez jakiś czas pozostanie w zasięgu, prawdopodobnie powinien być ustawiony na wartość null, jeśli jest to typ referencyjny, lub na nową domyślną instancję, jeśli jest to typ wartości, tak aby śmieci kolekcjoner może odzyskać pamięć:

messages = null; // Allow GC to reclaim memory for reference type.

messages = new MyMessageType(); // Allow GC to reclaim memory for value type.

W tym przypadku stworzyłem ogólną metodę rozszerzenia dla ConcurrentDictionary, która nie ma metody Delete ani Remove.

//Remove item from list and ignore reference to removed item
public static void TryRemoveIgnore<K,T>(this ConcurrentDictionary<K,T> dictionary, K key)
{
    T CompletelyIgnored;
    dictionary.TryRemove(key, out CompletelyIgnored);
}

W przypadku wywołania z wystąpienia ConcurrentDictionary:

ClientList.TryRemoveIgnore(client.ClientId);