Argomenti opzionali out / ref di C # 4.0

C # 4.0 consente facoltativi outo refargomenti?

Come già accennato, semplicemente non è permesso e penso che abbia un buon senso. Tuttavia, per aggiungere ulteriori dettagli, ecco un preventivo dalle specifiche C # 4.0 , sezione 21.1:

I parametri formali di costruttori, metodi, indicizzatori e tipi di delegati possono essere dichiarati facoltativi:

-parametro fisso:
    attributi _opt parametro-modificatore di _opt tipo identificativo default-argomento _opt
default-argomento:
    = espressione

• Un parametro fisso con un argomento predefinito è un parametro facoltativo , mentre un parametro fisso senza un argomento predefinito è un parametro obbligatorio .
• Un parametro richiesto non può apparire dopo un parametro facoltativo in un elenco di parametri formale .
• Un parametro refo outnon può avere un argomento predefinito .

No.

Una soluzione alternativa consiste nel sovraccaricare con un altro metodo che non ha parametri out / ref e che chiama semplicemente il metodo corrente.

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

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

Aggiornamento: se si dispone di C # 7.0 , è possibile semplificare:

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

(Grazie @Oskar / @Reiner per averlo segnalato.)

No, ma un'altra grande alternativa è che il metodo usi una classe modello generica per i parametri opzionali come segue:

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

Quindi puoi usarlo come segue:

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);
}

In realtà c'è un modo per farlo che è consentito da C #. Questo torna a C ++ e viola piuttosto la bella struttura orientata agli oggetti di C #.

UTILIZZARE QUESTO METODO CON ATTENZIONE!

Ecco il modo in cui dichiari e scrivi la tua funzione con un parametro opzionale:

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.
    }
}

Quindi chiama la funzione in questo modo:

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

Per ottenere questo da compilare, dovrai abilitare il codice non sicuro nelle opzioni del progetto. Questa è una soluzione davvero confusa che di solito non dovrebbe essere usata, ma se per qualche decisione strana, arcana, misteriosa, ispirata alla gestione, REALMENTE hai bisogno di un parametro di uscita opzionale in C #, allora questo ti permetterà di farlo.

ICYMI: Incluso nelle nuove funzionalità per C # 7.0 elencate qui , "discards" è ora consentito come parametri out sotto forma di _, per farti ignorare i parametri che non ti interessano:

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

PS se sei anche confuso con la parte "out var x", leggi anche la nuova funzione su "Out Variables" sul link.

No, ma puoi usare un delegato (ad es. Action) Come alternativa.

Ispirato in parte dalla risposta di Robin R di fronte a una situazione in cui pensavo di volere un parametro di uscita opzionale, ho invece utilizzato un Actiondelegato. Ho preso in prestito il suo codice di esempio da modificare per l'uso Action<int>al fine di mostrare le differenze e le somiglianze:

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);
}

Questo ha il vantaggio che la variabile opzionale appare nel sorgente come un normale int (il compilatore lo avvolge in una classe di chiusura, piuttosto che noi lo avvolge esplicitamente in una classe definita dall'utente).

La variabile necessita di un'inizializzazione esplicita perché il compilatore non può presumere che Actionverrà chiamato prima della chiusura della chiamata di funzione.

Non è adatto a tutti i casi d'uso, ma ha funzionato bene per il mio caso d'uso reale (una funzione che fornisce dati per un test unitario e in cui un nuovo test unitario necessitava di accesso a uno stato interno non presente nel valore restituito).

Utilizzare un metodo sovraccarico senza il parametro out per chiamare quello con il parametro out per C # 6.0 e versioni precedenti. Non sono sicuro del motivo per cui un C # 7.0 per .NET Core è anche la risposta corretta per questo thread quando è stato specificamente chiesto se C # 4.0 può avere un parametro di uscita opzionale. La risposta è no!

Che ne dici di questo?

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

Devi ancora passare un valore al parametro da C # ma è un parametro di riferimento opzionale.

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