La creazione di due istanze delegato per lo stesso metodo anonimo non sono uguali

Question

Si consideri il seguente codice di esempio:

static void Main(string[] args) 
{ 
    bool same = CreateDelegate(1) == CreateDelegate(1); 
} 

private static Action CreateDelegate(int x) 
{ 
    return delegate { int z = x; }; 
} 

Si potrebbe immaginare che le due istanze delegato paragonerei ad essere uguali, proprio come avrebbero quando si usa il buon vecchio metodo metodo denominato (nuova azione (MyMethod)). Non vengono confrontati per essere uguali perché .NET Framework fornisce un'istanza di chiusura nascosta per istanza delegata. Poiché queste due istanze delegate hanno ciascuna le loro proprietà di destinazione impostate sulla loro singola istanza nascosta, esse non vengono confrontate. Una possibile soluzione è che l'IL generato per un metodo anonimo memorizzi l'istanza corrente (questo puntatore) nella destinazione del delegato. Ciò consentirà ai delegati di confrontare correttamente e anche di aiutare da un punto di vista del debugger poiché vedrai la tua classe come target, invece di una classe nascosta.

È possibile leggere ulteriori informazioni su questo problema nel bug che ho inviato a Microsoft. Il bug report fornisce anche un esempio del perché stiamo usando questa funzionalità, e perché riteniamo che dovrebbe essere cambiato. Se ritieni che questo sia un problema, ti preghiamo di supportarlo fornendo rating e convalida.

https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=489518

Potete vedere ogni possibile ragione per cui la funzionalità non dovrebbe essere cambiato? Pensi che questa sia stata la migliore linea di condotta per risolvere il problema, o ti consiglio di prendere una strada diversa?

Answer 1

Non sono così propenso a pensare che questo sia un "bug". Sembra inoltre che stai assumendo alcuni comportamenti nel CLR che semplicemente non esiste.

La cosa importante da capire qui è che si restituisce un nuovo metodo anonimo (e si inizializza una nuova classe di chiusura) ogni volta che si chiama il metodo CreateDelegate. Sembra che tu stia sperimentando la parola chiave delegate per utilizzare internamente qualche sorta di pool per metodi anonimi. Il CLR certamente non lo fa. Un delegato al metodo anonimo (come con un'espressione lambda) viene creato in memoria ogni volta che si chiama il metodo e poiché l'operatore di uguaglianza confronta ovviamente riferimenti in questa situazione, è il risultato previsto che restituisce false.

Sebbene il comportamento suggerito possa avere alcuni vantaggi in determinati contesti, sarebbe probabilmente piuttosto complicato da implementare e molto probabilmente porterebbe a scenari imprevedibili. Penso che l'attuale comportamento di generare un nuovo metodo anonimo e delegare ad ogni chiamata sia quello giusto, e sospetto che questo sia il feedback che otterrai anche su Microsoft Connect.

Se si è abbastanza insistenti nell'avere il comportamento descritto nella domanda, c'è sempre l'opzione memoizing la funzione CreateDelegate, che assicurerebbe che lo stesso delegato venga restituito ogni volta per gli stessi parametri. Infatti, poiché è così facile da implementare, è probabilmente uno dei tanti motivi per cui Microsoft non ha preso in considerazione l'implementazione nel CLR.

Answer 2

Non conosco i dettagli specifici di C# di questo problema, ma ho lavorato sulla funzione equivalente di VB.Net che ha lo stesso comportamento.

La linea di fondo è questo comportamento è "By Design" per i seguenti motivi

La prima è che in questo scenario una chiusura è inevitabile. Hai usato un pezzo di dati locali all'interno di un metodo anonimo e quindi è necessaria una chiusura per catturare lo stato. Ogni chiamata a questo metodo deve creare una nuova chiusura per una serie di motivi.Pertanto ciascun delegato indicherà un metodo di istanza su quella chiusura.

Sotto il cofano un metodo/espressione anonimo è rappresentato da un'istanza derivata System.MulticastDelegate nel codice. Se si guarda al metodo Equals di questa classe si noterà 2 importanti dettagli

• Si è sigillato in modo non v'è alcun modo per un delegato derivato per modificare il comportamento uguale
• parte del metodo Equals fa un riferimento confronto sugli oggetti

Ciò rende impossibile per 2 espressioni lambda collegate a chiusure diverse da confrontare come uguali.

Answer 3

Non riesco a pensare a una situazione in cui abbia mai avuto bisogno di farlo. Se ho bisogno di confrontare i delegati che uso sempre delegati nominati, altrimenti qualcosa di simile sarebbe possibile:

MyObject.MyEvent += delegate { return x + y; }; 

MyObject.MyEvent -= delegate { return x + y; }; 

Questo esempio non è grande per dimostrare il problema, ma mi immagino che ci potrebbe essere una situazione in cui permettendo questo potrebbe rompere il codice esistente che è stato progettato con l'aspettativa che questo non è permesso.

Sono sicuro che ci sono dettagli di implementazione interni che rendono anche questa una cattiva idea, ma non so esattamente come i metodi anonimi siano implementati internamente.

Answer 4

EDIT: Vecchio risposta lasciato per valore storico sotto la linea ...

Il CLR avrebbe dovuto lavorare i casi in cui le classi nascoste potrebbero essere considerati uguali, tenendo conto tutto ciò che potrebbe essere fatto con le variabili catturate.

In questo caso particolare, la variabile acquisita (x) non viene modificata all'interno del delegato o nel contesto di acquisizione, ma preferirei che il linguaggio non richiedesse questo tipo di complessità di analisi. Più il linguaggio è complicato, più difficile è capire. Dovrebbe distinguere tra questo caso e quello sotto, dove il valore della variabile catturata viene cambiato ad ogni invocazione - lì, fa una grande quantità di differenze che delegano la chiamata; non sono in alcun modo uguali.

Penso sia del tutto ragionevole che questa situazione già complessa (le chiusure sono spesso fraintese) non cerchi di essere troppo "intelligente" e di elaborare la potenziale uguaglianza.

IMO, si dovrebbe sicuramente prendere un altro percorso. Questi sono concettualmente istanze indipendenti di Action. Fingendolo costringendo gli obiettivi dei delegati è un orribile hack IMO.

---

Il problema è che si sta catturando il valore di x in una classe generata. Le due variabili x sono indipendenti, quindi sono delegati non uguali.Ecco un esempio che dimostra l'indipendenza:

using System; 

class Test 
{ 
    static void Main(string[] args) 
    { 
     Action first = CreateDelegate(1); 
     Action second = CreateDelegate(1); 
     first(); 
     first(); 
     first(); 
     first(); 
     second(); 
     second(); 
    } 

    private static Action CreateDelegate(int x) 
    { 
     return delegate 
     { 
      Console.WriteLine(x); 
      x++; 
     }; 
    } 
} 

uscita:

1 
2 
3 
4 
1 
2 

EDIT: Per vedere le cose in un altro modo, il programma originale era l'equivalente di:

using System; 

class Test 
{ 
    static void Main(string[] args) 
    { 
     bool same = CreateDelegate(1) == CreateDelegate(1); 
    } 

    private static Action CreateDelegate(int x) 
    { 
     return new NestedClass(x).ActionMethod; 
    } 

    private class Nested 
    { 
     private int x; 

     internal Nested(int x) 
     { 
      this.x = x; 
     } 

     internal ActionMethod() 
     { 
      int z = x; 
     } 
    } 
} 

come si può indicare che verranno create due istanze separate di Nested e che saranno gli obiettivi per i due delegati. Sono diseguali, quindi anche i delegati sono diseguali.

Answer 5

Questo comportamento è utile perché altrimenti i metodi anonimi verrebbero confusi (se avessero lo stesso nome, dato lo stesso corpo).

Si potrebbe modificare il codice per questo:

static void Main(){ 
    bool same = CreateDelegate(1) == CreateDelegate(1); 
} 

static Action<int> action = (x) => { int z = x; }; 

private static Action<int> CreateDelegate(int x){ 
    return action; 
} 

o, preferibilmente, dato che è un brutto modo di usarlo (più di comparare il risultato, e azione non hanno un valore di ritorno .. . utilizzare Func < ...> se si vuole restituire un valore):

static void Main(){ 
    var action1 = action; 
    var action2 = action; 
    bool same = action1 == action2; // TRUE, of course 
} 

static Action<int> action = (x) => { int z = x; };