Perché un parametro out non è consentito all'interno di un metodo anonimo?

Question

Questa non è una vittima di Calling a method with ref or out parameters from an anonymous method

Mi chiedo il motivo per cui fuori parametri non sono ammessi all'interno dei metodi anonimi. Il fatto di non consentire i parametri ref mi sembra un po 'più sensato, ma i parametri out non sono tanto.

quali sono i tuoi pensieri su questo

Answer 1

In un certo senso questa è una vittima. I parametri Out sono i parametri ref. C'è semplicemente un attributo extra sul valore usato dal linguaggio C#. Il motivo per cui non sono consentiti è esattamente lo stesso dei parametri ref.

Il problema qui ha origine dall'uso di un valore dichiarato al di fuori del metodo anonimo all'interno del metodo anonimo. Fare ciò catturerà il valore all'interno della lambda e per necessità estenderà arbitrariamente la sua durata oltre quella della funzione corrente. Questo non è compatibile con i parametri out che hanno una durata prefissata.

Immaginate ad esempio che il parametro out si riferisca a una variabile locale nello stack. Il lambda può essere eseguito in qualsiasi punto arbitrario in futuro e quindi potrebbe essere eseguito quando quel frame dello stack non era più valido. Cosa significa il parametro out?

Answer 2

Questo è fondamentalmente a che fare con il fatto che i parametri di un anonimo delegato/espressioni lambda sono variabili catturati, e catturando ref/out variabili non ha alcun senso in C#/CLR, poiché richiederebbe ref/outcampi internamente. Inoltre, tieni presente che accoppi entrambe queste parole chiave perché sono effettivamente le stesse.

Se si desidera una spiegazione completa, Eric Lippert discussed this design point in detail sul proprio blog. (Vedere paragrafi vicino al fondo in particolare.)

Answer 3

L'unica differenza tra out e ref parametri è che un parametro out avrà un gettone [out] applicato ad esso. Sono la stessa cosa per quanto riguarda il CLR.

Per implementarlo, il compilatore dovrebbe generare refcampi, che non sono supportati.

Se ci pensi, ti renderai conto che non ha senso consentire ad un metodo anonimo di utilizzare un parametro out.

A cosa sarebbe il seguente codice?

static Func<object, object> Mess(out object param) { 
    param = "Original"; 
    return i => param = i; 
} 
static Func<object, object> MessCaller() { 
    object local; 
    return Mess(out local); 
} 
static vouid Main() { 
    Console.WriteLine(MessCaller()("New")); 
    //The local variable that the lambda expression writes to doesn't exist anymore. 
} 

Answer 4

Mi sono imbattuto in questo enigma mentre sviluppavo codice di gestione degli errori. Volevo passare un riferimento (out) a un messaggio di errore che verrebbe registrato. Ciò ha dato ai miei metodi anonimi la possibilità di eseguire controlli multipli, ognuno dei quali impostava il messaggio di errore secondo necessità.

Ho finito per scrivere un nuovo wrapper per il metodo anonimo che ha funzionato in modo diverso.Ma quello che pensavo potesse essere di qualche valore per qualcuno, è che avrei potuto semplicemente creare un metodo privato che aveva un parametro out, e definito un delegato, e ha fatto in modo che il mio codice lo usasse. Spero che questo aiuti/ispira qualcuno.

protected delegate void OutStringDelegate(int divider, out string errorText); 
    protected void codeWrapper(int divider, OutStringDelegate del) 
    { 
     string ErrorMessage = "An Error Occurred."; 

     try 
     { 
      del(divider, out ErrorMessage); 
     } 
     catch 
     { 
      LogError(ErrorMessage); 
     } 
    } 
    public void UseWrapper(int input) 
    { 
     codeWrapper(input, codeToCall); 
    } 
    private int somePrivateValue = 0; 
    private void codeToCall(int divider, out string errorMessage) 
    { 
     errorMessage = "Nice Error Message here!"; 
     somePrivateValue = 1/divider; // call me with zero to cause error. 
    } 
    private void LogError(string msg) 
    { 
     Console.WriteLine(msg); 
    }