Howto bind TextBox control to a StringBuilder instance?

Question

I would like several textboxes to react to changes of an underlying string. So if I were to change the content of the string, all those textboxes would change their content too.

Now, I can't use the String type for that as it is immutable. So I went with StringBuilder. But the Text property of a TextBox object only takes String.

Is there an easy way to "bind" the StringBuilder object to the Text property of a TextBox?

Many thanks!

PS: The TextBox is currently WPF. But I might switch to Windows Forms because of Mono.

Answer 1

You could inherit the text box and override the Text property to retrieve and write to the string builder.

Answer 2

You could always expose a property that's getter returns the ToString() of the Stringbuilder. The form could then bind to this property.

private StringBuilder _myStringBuilder;

public string MyText
{
  get { return _myStringBuilder.ToString(); }
}

Answer 3

You can bind the Text property of a TextBox to a string property... The String object is immutable, but a variable of type String is perfectly mutable...

string mutable = "I can be changed";
mutable = "see?";

You would need to wrap it up in an object that implements INotifyPropertyChanged, however.

Answer 4

Simply put, no. Text property only takes a String. So whatever the source, you'll have to convert it to a String.

To enable you to easily set it once for many textboxes, you can have a class property that always sets all textbox values...

public string MyString
{
  get
  {
   ///... 
  }
  set 
  {
    textbox1.Text = value;
    textbox2.Text = value;
    //...
  }
}

Answer 5

I would wrap the StringBuilder in a custom class with an Add method, Text method, and an OnChanged event.

Wire up the Add method such that when it is called it adds the text to the StringBuilder instance and fires the event. Then when the even fires, use the Text method to do a ToString on the StringBuilder.

public class StringBuilderWrapper { private StringBuilder _builder = new StringBuilder(); private EventHandler TextChanged; public void Add(string text) { _builder.Append(text); if (TextChanged != null) TextChanged(this, null); } public string Text { get { return _builder.ToString(); } } }

Answer 6

It seems my previous answer wasn't worded very well, as many people misunderstood the point I was making, so I will try again taking into account people's comments.

Just because a String object is immutable does not mean that a variable of type String cannot be changed. If an object has a property of type String, then assigning a new String object to that property causes the property to change (in my original answer, I referred to this as the variable mutating, apparently some people do not agree with using the term "mutate" in this context).

The WPF databinding system can bind to this property. If it is notified that the property changes through INotifyPropertyChanged, then it will update the target of the binding, thus allowing many textboxes to bind to the same property and all change on an update of the property without requiring any additional code.

Therefore, there is no need to use StringBuilder as the backing store for the property. Instead, you can use a standard String property and implement INotifyPropertyChanged.

public class MyClass : INotifyPropertyChanged
{
    private string myString;

    public string MyString
    {
        get
        { return myString; }
        set
        {
            myString = value;
            OnPropertyChanged("MyString");
        }
    }

    protected void OnPropertyChanged(string propertyName)
    {
        var handler = PropertyChanged;
        if (handler != null)
        { handler(this, new PropertyChangedEventArgs(propertyName)); }
    }

    #region INotifyPropertyChanged Members

    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

WPF can bind to this and will automatically pick up and changes made in the value of the property. No, the String object has not mutated, but the String property has mutated (or changed, if you prefer).