Wie kann ich eine unendliche Rekursion verhindern, wenn ich Ereignisse mit Elementen an Felder binden soll?

Question

Das folgende scheint ein relativ allgemeines Muster zu sein (für mich, nicht für die Gemeinschaft insgesamt), eine String-Variable an den Inhalt einer TextBox zu binden.

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

Das Problem ist, dass die TextBox Ändern der Änderungen der Datenwert im Backend ausgelöst, die das Textfeld verursacht, usw. zu ändern, die für immer läuft.

Gibt es ein besseres Design-Muster (außer der Rückgriff auf eine böse boolesche Flagge), die diesen Fall richtig behandelt?

EDIT: Um klar zu sein, in der realen Design wird die Backend-Klasse verwendet, um Änderungen zwischen mehreren Formularen zu synchronisieren. Daher kann ich die SomeTextBox.Text-Eigenschaft nicht direkt verwenden.

billy3

Answer 1

Ok habe ich schrieb einige Code, aber Sie könnten es nicht mögen :)

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

Der Haupt idia ist hier:

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

Answer 2

Sie könnten Absender überprüfen innen Set Accessor von MyBackEndClass Klasse Eigenschaft Data Wenn seine SomeForm - nur Ereignis nicht erhöhen.

Answer 3

Verwenden Sie Bindungen.

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

Edit: Meine Entschuldigungen, dann ist es BindingContext und es sollte funktionieren, wenn Sie alle Ihre Formulare an die Back-End-Objekt binden, wenn man die BEO aktualisiert, wird es alle Formen mit ihm verbunden aktualisieren (und es wird nicht rekursiv explodieren.)

Answer 4

Ich denke, dass Sie mit einem booleschen Flag, oder besser noch einer Art von Enum-Wert, stecken, die Sie in Ihre HandleTextBox-Methode übergeben.

Sie können alte und neue Zeichenfolgenwerte vergleichen, um zu sehen, ob sich der Wert tatsächlich geändert hat und eine Änderung des im Textfeld angezeigten Werts erfordert.

Answer 5

Auch wenn ich dieses Problem nicht replizieren kann, Ich habe eine Idee, wie ich es beheben kann.

Derzeit haben Sie tatsächlich eine DataSetEvent und nicht eine 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 
      } 
     } 
    } 
} 

Dies sollte die Rekursion stoppen, weil Sie jetzt TextBoxTextChanged-> DataChanged-> TextBoxChanged bekommen -> Daten nicht geändert Ereignisse hier stoppen hat.

EDIT: Vielleicht diesen Code in das Textfeld bewegen das Flimmern zu entfernen:
Ersetzen Sie Ihre System.Windows.Forms.TextBox ‚s mit diesem:

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

Es ist ein wenig schmutzig ... aber man könnte versuchen das Parsen Environment.StackTrace-Eigenschaft für einen vorherigen Aufruf von TextChanged. Ich denke, es ist ein bisschen weniger dreckig als der Boolean, der für die Threadsicherheit schreit.