Come posso evitare la ricorsione infinita quando si usano eventi per collegare elementi dell'interfaccia utente ai campi?

Question

Quanto segue sembra essere un modello relativamente comune (per me, non per la comunità in generale) per associare una variabile stringa al contenuto di un controllo TextBox.

class MyBackEndClass 
{ 
    public event EventHandler DataChanged; 
    string _Data; 
    public string Data 
    { 
     get { return _Data; } 
     set 
     { 
      _Data = value; 
      //Fire the DataChanged event 
     } 
    } 
} 

class SomeForm : // Form stuff 
{ 
    MyBackEndClass mbe; 
    TextBox someTextBox; 
    SomeForm() 
    { 
     someTextBox.TextChanged += HandleTextBox(); 
     mbe.DataChanged += HandleData(); 
    } 

    void HandleTextBox(Object sender, EventArgs e) 
    { 
     mbe.Data = ((TextBox)sender).Text; 
    } 

    void HandleData(Object sender, EventArgs e) 
    { 
     someTextBox.Text = ((MyBackEndClass) sender).Data; 
    } 
} 

Il problema è che il cambiamento di TextBox spara cambia il valore dei dati nel backend, che fa sì che la casella di testo per cambiare, ecc che corre sempre.

Esiste un modello di progettazione migliore (diverso dal ricorso a una brutta bandiera booleana) che gestisce correttamente questa custodia?

MODIFICA: Per essere chiari, nel progetto reale la classe di backend viene utilizzata per sincronizzare le modifiche tra più moduli. Pertanto non posso semplicemente usare direttamente la proprietà SomeTextBox.Text.

Billy3

Answer 1

Ok Ho scritto un codice, ma si potrebbe non piace :)

public class DataChangedEventArgs : EventArgs 
{ 
    public string Data { get; set; } 

    public DataChangedEventArgs(string data) 
    { 
     Data = data; 
    } 
} 
public delegate void DataChangedEventHander(DataChangedEventArgs e); 
public class BackEnd 
{ 
    public event DataChangedEventHander OnDataChanged; 
    private string _data; 
    public string Data 
    { 
     get { return _data; } 
     set 
     { 
      _data = value; 
      RaiseOnDataChanged(); 
     } 
    } 

    private static readonly object _sync = new object(); 
    private static BackEnd _instance; 
    public static BackEnd Current 
    { 
     get 
     { 
      lock (_sync) 
      { 
       if (_instance == null) 
        _instance = new BackEnd(); 
       return _instance; 
      } 
     } 
    } 
    private void RaiseOnDataChanged() 
    { 
     if(OnDataChanged != null) 
      OnDataChanged(new DataChangedEventArgs(Data)); 
    } 
} 
public class ConsumerControl 
{ 
    public event EventHandler OnTextChanged; 
    private string _text; 
    public string Text 
    { 
     get 
     { 
      return _text; 
     } 
     set 
     { 
      _text = value; 
      if (OnTextChanged != null) 
       OnTextChanged(this, EventArgs.Empty); 
     } 
    } 
} 
public class Consumer 
{ 
    public ConsumerControl Control { get; set; } 

    public Consumer() 
    { 
     Control = new ConsumerControl(); 
     BackEnd.Current.OnDataChanged += NotifyConsumer; 
     Control.OnTextChanged += OnTextBoxDataChanged; 
    } 

    private void OnTextBoxDataChanged(object sender, EventArgs e) 
    { 
     NotifyBackEnd(); 
    } 

    private void NotifyConsumer(DataChangedEventArgs e) 
    { 
     Control.Text = e.Data; 
    } 
    private void NotifyBackEnd() 
    { 
     // unsubscribe 
     BackEnd.Current.OnDataChanged -= NotifyConsumer; 
     BackEnd.Current.Data = Control.Text; 
     // subscribe again 
     BackEnd.Current.OnDataChanged += NotifyConsumer; 
    } 
} 
public class BackEndTest 
{ 
    public void Run() 
    { 
     var c1 = new Consumer(); 
     var c2 = new Consumer(); 
     c1.Control.Text = "1"; 
     BackEnd.Current.Data = "2"; 
    } 
} 

L'idia principale è qui:

// unsubscribe 
BackEnd.Current.OnDataChanged -= NotifyConsumer; 
BackEnd.Current.Data = Control.Text; 
// subscribe again 
BackEnd.Current.OnDataChanged += NotifyConsumer; 

Answer 2

potreste controllare il mittente all'interno di accesso set di proprietà di classe dati di MyBackEndClass Se la sua SomeForm - non solo alzare evento.

Answer 3

Utilizzare attacchi.

someTestBox.BindingContext.Add(new Binding("Text", mbe, "Data")); 

Edit: I miei scusato, è BindingContext e dovrebbe funzionare se si associa tutti i moduli per l'oggetto di back-end, quando si aggiorna il BEO, sarà aggiornare tutti i moduli allegati ad esso (e si suol esplodere in modo ricorsivo.)

Answer 4

Penso che si resterà bloccati con un flag booleano, o meglio ancora una sorta di valore enum, che si passa al metodo HandleTextBox.

È possibile confrontare i valori di stringa vecchi e nuovi per verificare se il valore è effettivamente cambiato e garantisce di modificare il valore visualizzato nella casella di testo.

Answer 5

Anche se non posso replicare questo problema, Ho un'idea su come risolverlo.

Attualmente si dispone di uno DataSetEvent e non di uno DataChangedEvent.

class MyBackEndClass 
{ 
    public event EventHandler DataChanged; 

    private string data = string.Empty; 

    public string Data 
    { 
     get { return this.data; } 
     set 
     { 
      // Check if data has actually changed   
      if (this.data != value) 
      { 
       this.data = value; 
       //Fire the DataChanged event 
      } 
     } 
    } 
} 

Questo dovrebbe fermare la ricorsione, perché ora si ottiene TextBoxTextChanged-> DataChanged-> TextBoxChanged -> I dati non è cambiata eventi si fermano qui.

EDIT: Forse spostare questo codice nel TextBox per rimuovere il tremolio:
sostituire il vostro System.Windows.Forms.TextBox 's con questo:

class CleverTextBox : TextBox 
{ 
    private string previousText = string.Empty; 

    public CleverTextBox() : base() 
    { 
     // Maybe set the value here, not sure if this is necessary..? 
     this.previousText = base.Text; 
    } 

    public override OnTextChanged(EventArgs e) 
    { 
     // Only raise the event if the text actually changed 
     if (this.previousText != base.Text) 
     {     
      this.previousText = this.Text; 
      base.OnTextChanged(e); 
     } 
    } 
} 

Answer 6

E' un po 'sporca ... ma si potrebbe provare l'analisi del Proprietà Environment.StackTrace per una precedente chiamata a TextChanged. Penso che sia un po 'meno sporco di quello booleano, che per me grida per la sicurezza dei thread.