The easiest way to debounce function calls in C# & VB.NET is by simply using the „Subject“ class from the „System.Reactive.Subjects“ namespace. Create an instance of this class, register a „callback“ and provide the values by calling the „OnNext“ method. This way you don’t need to install external or third-party libraries.

Without debouncing methods in C# or VB.NET – a visual example

Do you know these typical situations where your impatient application user is like bombing your controls with inputs – therefore triggering functions? I think every .NET developer will encounter this kind of situation at some point in time. Let’s see in today’s blogpost how we can actually handle these situations without external / third-party tools.

In a hurry? Go to the quick examples section, if you just need some code. Look at the detailed explanation, if you need more in-depth information. However make sure, that you understand the stuff behind the scenes :)!

Maybe one of these situations look like the following image, keep an eye on the output window of Visual Studio as well. Please don’t get confused, as this is an image from my custom CRM software being translated to german. I added some english test projects for this image though:

As you can see, each time you’re typing a letter into the textbox, you will trigger the corresponding function. With the average typing speed of a user, being between 190 and 200 characters per minute (CPM), this is very very bad! A more experienced or like professional writer could even achieve up to twice the amount of words / characters.

Usually we would wish for something like the image below – being the result of this blogpost:

I mean, the example in the image is very typical and actually no „wrong use“ of the application’s user himself. This is exactly where we – being developers – should come into play. It’s our job to react to the users input speed and adjust „behind the scenes stuff“ – accordingly!

An on-board resource to debounce function calls

Being a developer, it’s pretty nice to just let your creativity flow and develop things from start, but not always, right? I mean, there are circumstances, where you will be thinking: „God, this is such a common task, isn’t there already some stuff for that!? I don’t want to reinvent the wheel!“. This is exactly where the „Subject“ class from the „System.Reactive.Subjects„-namespace will help!

The easiest way to explain the usage of the subject in our case, is like you being a dad (or of course a mom…). Imagine, that your child is asking you about eating candy over and over again. No matter how often your child will be asking (of course depending on your parenting style), your answer will probably – still – be „No, not yet!“. I mean your mini-me shouldn’t probably be allowed to eat candy, everytime he / she asks. Only if your son behaved nice and didn’t ask for a specific amount of time.

Now swap yourself – being the dad in the previous example – with some sort of thing, some subject! That subject will now „filter“ the requests for you instead and only let „valid“ ones pass through. The requests are now coming from some sort of user input, instead of being your child requesting candy.

Take a look at this image representing the situation explained from above:

As you can see, there’s so much input happening (mouseclicks in this case), but the „debouncer“ will only allow 1 function call. In the next section, we will take a look at actually implementing the mentioned „subject“ class. Especially that „time passed after last input“ is pretty important.

Installing System.Reactive

I know, I know, you’re thinking: „But Robert, you said no external libraries“, but hear me out… I mean, this stuff is coming from microsoft itself residing inside of the „System.Reactive“ namespace, so – for me this isn’t „third-party“, etc. If you write the correct class name, it will even suggest you to install the package within 3 seconds – so you don’t even need like the NuGet paket manager, etc. (Of course you can use it though).

We will be using the easiest method to install the small package, just declare some variable or a field of the type and open the suggestions by hovering over the error and clicking „show potential fixes“. Or you can just use the hotkey „Ctrl+.“. We will be using / declaring the class in the section below, as well, so we will need it anyways!

Take a look at the following screenshot to install System.Reactive or go into the NuGet paket manager as usual and install it manually.

Using the Subject class for debouncing

After we’ve discussed the basic problem and some theoretical approaches, we will now take a look at an actual usage example. When talking about debouncing, we should first take a look at some „well-known values“ like: „What is a commonly used delay for debouncing?“. Searching further, you will find some values being between like 150 and 400 milliseconds.

As always, I would encourage you to adjust these times to your specific usecase, as these can differ from project to project and so on. In the end, we will be using 400 milliseconds for our example, as this was used by a big „library“ consuming inputs, I’ve commonly used in the past. Sadly, I don’t remember the name, lol.

Keep in mind, that your used technology (WPF or Winforms) isn’t pretty much important. You will be able to use the common „pattern“ of the Subject class for both of those. Your used language (C# or VB.NET) isn’t relevant, as well. You might need to adjust the code for like using MVVM, etc. – but in general, it’s the same.

Declaring and instantiating the subject class

With an emphasis on the above info-box, we will now declare and instantiate an example instance of the subject. At this point, you should know the data being used for the „Subject“, as it needs a generic type parameter. If you’re trying to debounce an input string from like a textbox, your generic type would therefore be a string.

Take a look at this example, preparing to debounce a string input from a textbox, being in a Windows Forms (Winforms) app – again, you can easily adjust to fit your normal or MVVM WPF app as well:

// import the namespace for the Subject
using System.Reactive.Subjects;

// a typical Winforms "Form"
public class Form1 : Form
{

  // declare the Subject
  Subject<string> _searchSubject;

  // things get typically instantiated
  // inside of the constructor
  public Form1()
  {
    _searchSubject = new Subject<string>();
    _searchSubject
      .Throttle(TimeSpan.FromMilliseconds(400));
  }

}

' import the namespace for the Subject
Imports System.Reactive.Subjects

' a typical Winforms "Form"
Public Class Form1

  ' declare the Subject
  Private _searchSubject As Subject(Of String)

  ' things get typically instantiated
  ' inside of the constructor
  Public Sub New()
    _searchSubject = New Subject(Of String)()
    _searchSubject _
      .Throttle(TimeSpan.FromMilliseconds(400))
  End Sub

End Class

After we have declared and instantiated a subject with the correct generic type being „string“ (for our usecase), we can proceed. So far, there’s like nothing happening! This is, because we are missing like two steps when using the subject class. Take a look at the next section, soon!

In the last part of this section, we will configure the „_searchSubject“ instance, to debounce the input by 400ms. Just call the „Throttle“ method with an appropriate parameter as in the example. We’re using the „TimeSpan.FromMilliseconds“ helper here!

Feeding the user input into our subject

Now that we have declared and created an actual instance of the subject class, we can start feeding the actual input of the user to the subject. Remember, this would be the child asking the dad in the above example. As the raw input will usually be coming from some sort of input controls like textboxes, we will use one of those for our typical example.

So the first step would be, to do something like this: „Everytime the text of the textbox changes, I will feed that information to our subject“. Basically, we need to therefore react to the user typing some input into the textbox and that’s pretty basic, right?

Take a look at this – you of course have to make sure, that you actually have a textbox on your form like „TextBox1“:

public class Form1 : Form
{

  public Form1()
  {
    // the other code from above!
    TextBox1.TextChanged += TextBox1_TextChanged;
  }

  private void TextBox1_TextChanged(object? sender, EventArgs e)
  {
    // each time the user types a letter, we will get here
    // now feed the information to our subject from
    // the code from above
    _searchSubject.OnNext(TextBox1.Text);
  }

}

Public Class Form1

  Public Sub New()
    ' the other code from above
    ' to stay the same with the C# example
    ' you could of course use the Handles keyword...
    AddHandler TextBox1.TextChanged, AddressOf TextBox1.TextChanged
  End Sub

  Private Sub TextBox1_TextChanged(sender As Object, e As EventArgs)
    ' each time the user types a letter, we will get here
    ' now feed the information to our subject from
    ' the code from above
    _searchSubject.OnNext(TextBox1.Text)
  End Sub

End Class

Registering a „callback“

Right now, we have already created the subject instance and configured it, to have some sort of throttling process going on. We’ve also created a handler function – listening to the TextBox TextChanged event – to feed information to our subject. To make the final step, we just need to tell the subject: „Hey, this is our function you should be calling, when everything’s alright!“.

So let’s now tell our subject to call the specific method we want to be called – after it took out all the noise:

public class Form1 : Form
{

  public Form1()
  {
    // the other code from above!
    // notice the additional "Subscribe" call
    _searchSubject
      .Throttle(TimeSpan.FromMilliseconds(400))
      .Subscribe(DebouncedSearchTextChanged);
  }

  private void DebouncedSearchTextChanged(string searchText)
  {
    // do you API stuff without the noise!
  }

}

Public Class Form1

  Public Sub New()
    ' the other code from above!
    ' notice the additional "Subscribe" call
    _searchSubject _
      .Throttle(TimeSpan.FromMilliseconds(400)) _
      .Subscribe(DebouncedSearchTextChanged)
  End Sub

  Private Sub DebouncedSearchTextChanged(searchText As String)
    ' do you API stuff without the noise!
  End Sub

End Class

How it looks now – being debounced!

Our calls now look like the following. I’m just typing a lot of stuff and only if I stop typing with an additional delay of like 400ms – our target function will be called, great!

Quick example

In this section, you will find pretty quick examples of the subject class usage. If you need more explanation / details, take a look at the previous section.

Keep in mind, that this example can be applied to WPF and Windows Forms, but as WPF possibly implies using MVVM (or not), I thought, the Winforms example would be more typical and easier.

// import the namespace for the Subject
using System.Reactive.Subjects;

public class Form1 : Form
{

  // declare the Subject
  Subject<string> _searchSubject;

  public Form1()
  {
    // create an instance
    _searchSubject = new Subject<string>();
    // configure
    _searchSubject
      .Throttle(TimeSpan.FromMilliseconds(400))
      .Subscribe(DebouncedSearchTextChanged);
    TextBox1.TextChanged += TextBox1_TextChanged;
  }

  private void TextBox1_TextChanged(object? sender, EventArgs e)
  {
    // each time the user types a letter, we will get here
    // now feed the information to our subject
    _searchSubject.OnNext(TextBox1.Text);
  }

  private void DebouncedSearchTextChanged(string searchText)
  {
    // do you API stuff without the noise!
    System.Diagnostics.Debug.WriteLine($"Debounced: {searchText}");
  }

}

' import the namespace for the Subject
Imports System.Reactive.Subjects

Public Class Form1
    Inherits Form

    ' declare the Subject
    Private _searchSubject As Subject(Of String)

    Public Sub New()
        ' create an instance
        _searchSubject = New Subject(Of String)()
        ' configure
        _searchSubject _
            .Throttle(TimeSpan.FromMilliseconds(400)) _
            .Subscribe(AddressOf DebouncedSearchTextChanged)
    End Sub

    Private Sub TextBox1_TextChanged(ByVal sender As Object?, ByVal e As EventArgs) Handles TextBox1.TextChanged
        ' each time the user types a letter, we will get here
        ' now feed the information to our subject
        _searchSubject.OnNext(TextBox1.Text)
    End Sub

    Private Sub DebouncedSearchTextChanged(ByVal searchText As String)
        ' do you API stuff without the noise!
        System.Diagnostics.Debug.WriteLine($"Debounced: {searchText}")
    End Sub

End Class

Wrapping up – debouncing method calls

In today’s blogpost, I’ve explained a common problem when working with user input. There are many situations where users will just bomb the UI by typing characters or like selecting values from a selection control. This will trigger many unwanted function calls, eventually resulting in too many API calls or performance problems.

We then used the „Subject“-class residing in the „System.Reactive.Subjects“-namespace to implement some sort of throttling / debouncing. Even if many inputs will be provided by the user, our „Subject“ instance will take care of only triggering the target function, if a specific amount of time has passed (since the last provided input).

Der Beitrag How to debounce function calls in .NET with on-board resources erschien zuerst auf Robert Skibbe.

VB.NET Formulare automatisch ausfüllen!

Ein VB NET Formular automatisch ausfüllen zu lassen wäre vermutlich für jeden „Windows Forms“ geprägten Entwickler eine Erleichterung. Man designt die Form seiner Wahl und möchte natürlich bei Aufruf die notwendigen Daten anzeigen. Besonders beim Flow aus diversen Suchmasken heraus ist es normal, dass man eine Detail-Ansicht mit entsprechenden Daten aufruft.

Wie es meistens ist..

Am besten wäre es natürlich, wenn man dem Formular direkt sagen könnte: „Hey, die Daten findest Du dort“. Mit modernen Mitteln wie in der WPF (Windows Presentation Foundation) ist dies durch Datenbindung eine gängige und vor allem einfache Praxis.

Dort findet man durch die saubere Trennung zwischen GUI und Daten eine simple und direkt in XAML implementierte Möglichkeit. In den guten alten Winforms findet man jedoch seltenst (jedenfalls aus meiner Erfahrung gesprochen) datengebundene Steuerelemente.

Monkey Work – ney, Automatisierung – yay!

Dort sieht es dann entgegengesetzt jeglicher Automatisierung eher so aus:

TextBox1.Text = "..."
TextBox2.Text = "..."
TextBox3.Text = "..."
TextBox4.Text = "..."
' ....

Eventuell entwickelt man wenigstens einigermaßen sauber und wählt passende Namen für die Textboxen:

tbFirstName.Text = "..."
tbLastName.Text = "..."
tbZip.Text = "..."
tbCity.Text = "..."
' ....

Schon besser, aber natürlich kann man sich schon vorstellen, dass dies nicht unbedingt das Gelbe vom Ei ist. Man wird auf diverse Probleme, bzw. Monkey-Work stoßen, Welche für Wartung und Co. nicht gerade vorteilhaft sind. Tonnenweise „duplicated Code“ und schon glatt eine Qual, wenn es bei einem Objekt mit 30 Properties heißt: „Hey, zeige die Daten mal an…“.

Nun ist man an einem Punkt, wo die bekannte Faulheit doch zum Vorteil sein und zu mehr Effizienz beitragen kann. Wie so häufig, haben wir als Entwickler die Möglichkeit uns gewisse (und vor allem wiederkehrende Aufgaben) zu vereinfachen. Not macht erfinderisch, richtig?

An die Zukunft denken

Je nachdem wie viel Planung und anschließenden Zeitaufwand man bereit ist zu investieren (nicht opfern!), wird die bevorstehende Arbeit beeinflussen. Man sollte meiner Meinung nach jedoch immer eins im Hinterkopf behalten: „Think twice, code once“! Leider arbeiten viele Entwickler auch gerne nach dem „Copy & Paste“-Prinzip, zur Not auch projektübergreifend.

Statt hier zukunftsorientiert zu denken, werden Aufgaben häufig nur akut und schnell gelöst. Auch wenn die Erledigung einiger Aufgaben ggf. am Anfang nervig und zeitaufwendig sind, können Sie einem später unfassbar viel Zeit ersparen. Dies gilt natürlich nicht nur für das aktuelle Projekt, sondern vermutlich auch noch für später anstehende Projekte und Problemstellungen.

Herangehensweise – VB NET Formular automatisch ausfüllen

Im nächsten Schritt machen wir uns einmal ein paar Gedanken bezüglich der Herangehensweise, die (Windows Forms)-Formulare automatisiert(er) auszufüllen. Auch wenn wir hier vermutlich noch keine volle Suite an Mini-Tools generieren werden, wird das meinerseits dargestellte Beispiel als Startschuss dienen können.

Jeder Entwickler im NET Bereich wird wohl immer wieder mal mit den guten alten Textboxen zu tun haben. Ich denke, dass dieses Steuerelement daher auch die erste zu bearbeitende Anlaufstelle sein sollte. Wenn man hingegen an Checkboxen, Listboxen und an die anderen Steuerelemente denkt, könnte es schon ein wenig komplexer werden.

Vielleicht werde ich dafür dann noch einmal einen getrennten Beitrag in Zukunft erstellen. Schauen wir einmal, wo mich die Beitrags-Reise, bzw. meine Schreib-Lust heute hinführt 😉.

Konkreter Ablauf

Wenn man sauber vorgeht, sollte man die Daten natürlich in irgendeiner sinnvollen Form vorliegen haben. Nach Möglichkeit gibt es hier also nicht z. B. 15 verschiedene Variablen, Welche dann im schlimmsten Fall noch „string1, string2, usw.“ heißen. Wir wollen ja im besten Fall mit relativ fest definierten Mustern arbeiten, um unsere Arbeit so einfach wie möglich zu gestalten.

Ich stelle mir einerseits eine bereits definierte Klasse als Daten-Container vor, andererseits könnte es sich auch um analog zugreifbare Daten wie bei einer DataRow handeln. Den konkreten Ablauf würde man kurz und knapp vielleicht so beschreiben: „Nimm dieses Ding hier und packe dessen Eigenschafts-Werte in die passenden Steuerelemente“.

Dabei könnte man entweder ausgehend vom Objekt, oder von der jeweiligen Form arbeiten, also Pseudocode mäßig so:

Für jede Eigenschaft im Objekt, finde die passende Textbox, trage den passenden Wert ein..

oder..

Für jede/s Textbox/Steuerelement auf dem Formular, finde im Ziel-Objekt die passende Eigenschaft und befülle Diese.

Eventuell könnte man hier auch noch für die Performance mit irgendeiner Art Cache arbeiten, oder je nach Situation die „Strategie“ (Anspielung Strategy-Pattern…) ändern. Ich werde es hier allerdings nicht weiter als nötig verkomplizieren, da dieses Beispiel nur als Inspiration dienen soll.

Code – VB NET Formular automatisch ausfüllen

Nachdem wir die Herangehensweise ein wenig durch Pseudocode dargestellt haben, starten wir auch direkt in den Code. Ich werde auf jeden Fall ein Modul verwenden, damit man den Code auch einfach für andere Projekte wiederverwenden kann. Alternativ könnte man natürlich auch eine getrennte Klassenbibliothek, ein NuGet-Paket, o. Ä. erstellen.

Mit gewissen neuen aus C# bekannten Features könnte man auch vielleicht in Visual Basic eine „Trait“ ähnelnde Verwendungsweise realisieren. Wie bekannt ist, ist Komposition ja zumeist besser, als Vererbung (Stichwort: „composition over inheritance“). „Traits“ kennt man zum Beispiel allzu gut aus der Web-Programmiersprache namens PHP, aber dazu vielleicht in einem anderen Beitrag mehr.

Das Modul

Erstelle nun im ersten Schritt ein neues Modul namens (z. B.) „modExtensions“ – auch hier verwende ich gerne eine kleine Konvention. Ich halte mich immer an ähnliche Bezeichnungen / Präfixe, wie z. B. „tb“ für eine Textbox, „cbb“ für eine Combobox, etc. Welchen Sinn das dann eventuell haben kann / wird, sehen wir unter anderem (und besonders) im heutigen Beitrag!

Da wir schon analog zum Modul geplant haben, eine Erweiterungsmethode zu verwenden, importieren wir direkt den „System.Runtime.CompilerServices“-Namespace.

Eine Fill-Methode – VB NET Formular automatisch ausfüllen

Durch den Import des zuvor genannten Namespaces, können wir dann das „Extension“-Attribut verwenden und unsere Methode namens z. B. „Fill“ damit bestücken.

Als nächstes definieren wir die beiden benötigten Parameter:

• Die Form, bzw. dessen Steuerelemente, Welche befüllt werden sollen
• Das Objekt, also eine jeweilige Instanz eines x-beliebigen Typs, Welches die Daten beinhaltet

Imports System.Runtime.CompilerServices

Module modExtensions

    <Extension()>
    Public Sub Fill(frm As Form, obj As Object)
        ' ...
    End Sub

End Module

Danach erfassen wir die Textboxen aus der „Controls“-Auflistung des Formulars, damit wir Diese anschließend verwenden können. Praktisch im gleichen Schritt, ziehen wir uns einfach auch direkt die Eigenschaften (Definitionen) des Daten-Objekts.

Das geht relativ einfach, also wie folgt:

Dim textBoxes = frm.Controls.OfType(Of TextBox)
Dim properties = obj.GetType().GetProperties()

Danach können wir die eben abgerufenen Textboxen einfach in einer „For Each“-Schleife durchlaufen und dann mit dem Befüllen der Eigenschaften beginnen. Im ersten Teil der Schleife prüfen wir, ob die jeweilige Textbox mit dem korrekten Prefix „tb“ betitelt wurde. Wir halten uns also an eine kleine, von uns festgelegte Konvention. Vielleicht sollte man dies auch durch ein eigenes Attribut konfigurierbar machen, jedoch verzichten wir der Einfachheit halber aktuell darauf. Falls die Textbox nicht mit „tb“ beginnt, ignorieren wir Sie aktuell einfach, sprich die Schleife springt in den nächsten Durchlauf.

Dim wrongPrefix = Not tb.Name.StartsWith("tb")
If wrongPrefix Then
    Continue For
End If

Der darauf folgende Teil prüft, ob wir eine Eigenschaft mit passendem Namen zur Textbox finden können. Ebenso checken wir, ob der Typ zur Textbox passt, es sich dabei also um einen String handelt.

Dim nameWithoutPrefix = tb.Name.Substring(2)
Dim matchingProperty = properties.SingleOrDefault(Function(x) x.Name = nameWithoutPrefix)
If matchingProperty Is Nothing OrElse matchingProperty.PropertyType IsNot GetType(String) Then
    Continue For
End If

Der letzte und wichtigste Part – also nach dem Motto „das Beste kommt zum Schluss“ – ist, die Text-Eigenschaft der Textbox zu setzen:

tb.Text = matchingProperty.GetValue(obj).ToString()

Dazu verwenden wir die „GetValue“-Funktion der „PropertyInfo“-Klasse, um an den hinterlegten Wert der Eigenschaft zu kommen.

Kompletter Code

Wie immer fasse ich hier am Ende des Beitrages den kompletten Code zusammen.

Imports System.Runtime.CompilerServices

Module modExtensions

    <Extension()>
    Public Sub Fill(frm As Form, obj As Object)
        Dim textBoxes = frm.Controls.OfType(Of TextBox)
        Dim properties = obj.GetType().GetProperties()

        For Each tb In textBoxes

            Dim wrongPrefix = Not tb.Name.StartsWith("tb")
            If wrongPrefix Then
                Continue For
            End If

            Dim nameWithoutPrefix = tb.Name.Substring(2)
            Dim matchingProperty = properties.SingleOrDefault(Function(x) x.Name = nameWithoutPrefix)
            If matchingProperty Is Nothing OrElse matchingProperty.PropertyType IsNot GetType(String) Then
                Continue For
            End If

            tb.Text = matchingProperty.GetValue(obj).ToString()
        Next
    End Sub

End Module

using System;
using System.Windows.Forms;

namespace AutoFillFormCS
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnAutoFill_Click(object sender, EventArgs e)
        {
            var customer = new Customer()
            {
                Company = "Nice ltd.",
                FirstName = "Max",
                LastName = "Random",
                Street = "The street",
                HouseNo = "11a"
            };
            this.Fill(customer);
        }
    }
}

Weiterführende Links

• MVVM – Model View ViewModel (Wissen auch für VB geeignet)
• Mahapps Metro Projekt aufsetzen
• Asynchrone Programmierung

Downloads

Der Beitrag VB NET Formular automatisch ausfüllen (Winforms) erschien zuerst auf Robert Skibbe.

VB.NET data binding Tutorial

Lerne in diesem VB.NET data binding Tutorial, wie Du Steuerelemente und Daten sauber trennst, indem Du Daten an die Steuerelemente bindest.

Besonders seit der WPF (Windows Presentation Foundation) konnte sich ein geordnetes Verhältnis zwischen Daten und dessen Darstellung etablieren.

Eventuell hast Du noch später Interesse an diesen Beiträgen: WPF DataTemplate, WPF StackPanel, MahApps Metro.

Drum binde sich, wer nicht ewig prüfen will

Das sagte der deutsche Immunbiologe und Aphoristiker Gerhard Uhlenbruck.

Wie recht er auch in der Programmierung mit dieser Aussage haben sollte, war Ihm denke ich nicht bewusst.

Die Bindung von Daten an entsprechende Steuerelemente bringt verschiedene Vorteile mit sich, wovon ich Einige gleich erklären werden.

Damals war alles besser – WinForms-Zeiten

Es gibt vermutlich immer wieder Verfechter der Aussage „damals war alles besser“, jedoch ist dem durchaus nicht immer so.

„Damals“ zu WinForms-Zeiten wurde leider wie ich es zu oft erlebt habe nicht „sauber“ mit Daten umgegangen.

Einerseits bei den Datentypen, aber wegen vermeintlicher „Einfachheit“ auch oft mit beabsichtigtem Verzicht auf Datenbindungen.

Eine kleine Wiederholung – VB.NET data binding Tutorial

Im Zuge einer kleinen Wiederholung aus meinem „ObservableCollection“ Beitrag, möchte ich hier noch einmal ein kleines Beispiel aufgreifen.

Bei diesem Beispiel handelt es sich um die Darstellung von simplen Strings innerhalb einer ListBox.

Stelle Dir eine simple Auflistung von Strings vor, wo Elemente eingefügt, bearbeitet und auch entfernt werden können.

Eigentlich nichts wirklich Komplexes, schaue Dir allerdings einmal kurz das folgende Bild an.

In diesem Beispiel ist die ListBox tatsächlich an eine Liste als Datenquelle gebunden, jedoch gibt es Probleme.

Darstellungsprobleme

Wie Du im Bild erkennen kannst, gibt es Probleme mit der Darstellung, obwohl die Liste im Hintergrund Elemente beinhaltet.

Das sich Elemente in der Auflistung befinden, zeigt die beabsichtigt eingefügte MessageBox nach kurzer Verzögerung an.

Die nicht angezeigten, jedoch im Hintergrund befindlichen Elemente werden nicht dargestellt, weil die „ListBox“ nichts von dem Hinzufügen mitbekommt.

Sie merkt also nicht, dass die sich dahinter befindliche Auflistung tatsächlich ändert, also Elemente hinzugefügt, oder auch gelöscht werden.

Datenbindung mit Benachrichtigungsmechanismus – VB.NET data binding Tutorial

Das beschriebene Problem können wir mit einer Art Benachrichtigungsmechanismus lösen.

Dabei wird die Veränderung der Datenquelle durch z. B. Ereignisse an die Abonnenten dieser Ereignisse kommuniziert.

Diesen Mechanismus können wir durch die Implementierung der „IRaiseItemChangedEvents„-Schnittstelle erreichen.

Vorhandene Bordmittel nutzen

Statt diese Schnittstelle selbst zu implementieren und somit eine eigene Klasse zu erstellen, können wir auch auf die bestehenden Klassen zurückgreifen.

Zum Glück gibt uns das .NET-Framework für WinForms-Anwendungen z. B. die „BindingList“-Klasse an die Hand.

Für modernere WPF–Anwendungen (Windows Presentation Foundation) können wir die vorhandene „ObservableCollection„-Klasse verwenden.

Nach diesem kleinen Rückblick werden wir unseren Blick nun in Richtung diverser Beispiele richten.

Voraussetzungen – VB.NET data binding Tutorial

Damit viele, bzw. gar alle der nächsten Beispiele funktionieren, musst Du bei der verwendeten Klasse die "INotifyPropertyChanged"-Schnittstelle implementieren.

Implementierung INotifyPropertyChanged-Schnittstelle

Eine beispielhafte Implementierung der “ INotifyPropertyChanged„-Schnittstelle kann wie gleich folgend aussehen.

Ausgehend davon, dass wir eine Eigenschaft namens „TextBoxText“ in der Form haben:

Private _textBoxtext As String

Public Property TextBoxText As String
    Get
        Return _textBoxtext
    End Get
    Set(value As String)
        If _textBoxtext = value Then
            Return
        End If
        _textBoxtext = value
        ' raise something like "hey, i changed my value!"
    End Set
End Property

private string _textBoxText;

public string TextBoxText
{
    get
    {
        return _textBoxText;
    }
    set
    {
        if (_textBoxText == value)
            return;
        _textBoxText = value;
        // raise something like "hey, i changed my value!"
    }
}

definieren wir zuerst einen privaten Member namens „_textBoxtext„, Welcher als Hintergrund–Feld für die Eigenschaft dient.

Eigenschaft definieren

Danach erstellen wir eine Eigenschaft, die dieses Feld verwendet, wobei der Setter hier das Interessante ist.

Der Setter überprüft zuerst, ob sich der aktuelle Wert des Feldes tatsächlich vom übergebenen Wert unterscheidet.

Wenn die Werte sowieso schon die „Gleichen“ sind, verlassen wir den Setter durch „Early-Return“.

Da die Werte sich unterscheiden, wenn wir nicht vorher schon per Return rausgesprungen sind, setzen wir dann den neuen Wert.

Helper-Methode – VB.NET data binding Tutorial

Nun kommen wir zum besonderen Part der Eigenschaft, denn jetzt kommunizieren wir die tatsächlichen Änderungen der Eigenschaft an eventuell Interessierte.

Um dazu jedoch nicht für jede einzelne Property zig Zeilen Code zu wiederholen, habe ich mir eine kleine Helper-Methode geschrieben:

Private Sub NotifyOfPropertyChange(<CallerMemberName> Optional propertyName As String = Nothing)
    If propertyName Is Nothing Then
        Return
    End If
    RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
End Sub

private void NotifyOfPropertyChange([CallerMemberName] string propertyName = null)
{
    if (propertyName == null)
        return;
    PropertyChanged(this, new PropertyChangedEventArgs(propertyName))
}

Änderungen der Eigenschaft kommunizieren

Ersetze den vorhin bereits angeführten Kommentar nun durch einen Aufruf der Helper-Methode.

Beachte dabei, dass Du durch die tolle Funktionalität des „CallerMemberName„-Attributs des Parameters keinen Namen angeben musst.

Der Name der Eigenschaft wird hier im Setter durch dieses Attribut automatisch befüllt, lasse Dir den Wert ggf. einmal in verschiedenen Fällen ausgeben.

Diese kleine Methode hat mir selbst schon sehr oft die Arbeit bei Datenbindungen wie in dem VB.NET data binding Tutorial erleichtert.

Private _textBoxtext As String

Public Property TextBoxText As String
    Get
        Return _textBoxtext
    End Get
    Set(value As String)
        If _textBoxtext = value Then
            Return
        End If
        _textBoxtext = value
        NotifyOfPropertyChange()
    End Set
End Property

private string _textBoxText;

public string TextBoxText
{
    get
    {
        return _textBoxText;
    }
    set
    {
        if (_textBoxText == value)
            return;
        _textBoxText = value;
        NotifyOfPropertyChange();
    }
}

Wann Änderungen kommuniziert werden

Beachte, dass die TextBox die Änderungen selbst erst an die Eigenschaft kommuniziert, wenn Du die TextBox verlässt! Dies kannst Du anderweitig konfigurieren, indem Du weitere Parameter der Add-Methode definierst.

Add("Text", Me, "TextBoxText", False, DataSourceUpdateMode.OnPropertyChanged)

Genauer genommen geht es hier um den letzten Parameter namens „updateMode„, Welche wir nun einmal auf den Wert 1 (DataSourceUpdateMode.OnPropertyChanged) stellen.

Weitere abhängige Eigenschaften

Vielleicht hast Du auch andere Eigenschaften, also zum Beispiel eine Eigenschaft wie „FullName„, Welche vom „First-„, sowie vom „LastName“ abhängig ist.

Dann kannst Du einen weiteren Aufruf der Helper-Methode mit der abhängigen Eigenschaft durchführen:

NotifyOfPropertyChange("<TheDependentProperty>")

WinForms Beispiele – VB.NET data binding Tutorial

In diesem Abschnitt versuche ich mit der Darstellung diverser Beispiele das Thema Datenbindung unter WinForms ein wenig näher zu bringen.

Keine Sorge, in diesem VB.NET data binding Tutorial werde ich auch noch auf Beispiele für WPF eingehen, falls Du eher daran interessiert bist.

Neben den bereits angeführten Auflistungen gibt es natürlich auch weitere Datenbindungen wie z. B. an einen Text.

Finde hier alle gängigen WinForms-Beispiele für das VB.NET data binding Tutorial.

TextBox Text an String binden

Im ersten Beispiel realisieren wir eine kleine Datenbindung, Welche den eingegebenen Text einer TextBox innerhalb eines Labels widerspiegelt.

Als Eigenschaft verwende ich dafür das oben angeführte Beispiel aus den Voraussetzungen.

Sage nun der TextBox durch folgenden Code, dass Sie Ihren Text, an die „TextBoxText“-Eigenschaft binden soll:

tbTextBoxBinding.DataBindings.Add("Text", Me, "TextBoxText")

tbTextBoxBinding.DataBindings.Add("Text", this, "TextBoxText");

Nun wird bereits die TextBox in der Lage sein, Änderungen an der Eigenschaft in ihrem Text widerzuspiegeln.

TextBoxText = "My New Text"

Was allerdings noch fehlt, ist das oben angesprochene Label, Welches die Zeichenfolge ebenfalls darstellen soll.

Dafür rufen wir auch einfach nur die „Add“-Methode der DataBindings-Eigenschaft des Labels auf:

lblTextBoxBinding.DataBindings.Add("Text", Me, "TextBoxText")

lblTextBoxBinding.DataBindings.Add("Text", this, "TextBoxText");

Und schon ist das Label bereit, die Änderungen der „TextBoxText“-Eigenschaft ebenfalls darzustellen.

CheckBox an Boolean binden

Als nächstes beschäftigen wir uns mit der Datenbindung eines Booleans an eine CheckBox.

Ziehe dafür auch hier ein Label und dieses mal eine CheckBox auf die Form, rufe danach folgende Anweisungen z. B. im Load-Ereignis der Form auf.

chbCheckBoxBinding.DataBindings.Add("Checked", Me, "CheckBoxBool", False, DataSourceUpdateMode.OnPropertyChanged)
lblCheckBoxBinding.DataBindings.Add("Text", Me, "CheckBoxBool", False, DataSourceUpdateMode.OnPropertyChanged)

chbCheckBoxBinding.DataBindings.Add("Checked", Me, "CheckBoxBool", False, DataSourceUpdateMode.OnPropertyChanged)
lblCheckBoxBinding.DataBindings.Add("Text", Me, "CheckBoxBool", False, DataSourceUpdateMode.OnPropertyChanged)

ListBox an simple Auflistung binden

Hier ein einfaches Beispiel, wie Du eine einfache Auflistung (Integer, String, ..) an eine ListBox binden kannst.

Erstelle z. B. eine Eigenschaft namens „StringList“ vom Typ BindingList, Welche gleich die einzelnen Items beinhalten wird.

Public Property StringList As BindingList(Of String)

public BindingList<string> StringList { get;set; }

Für das Download-Beispiel habe ich die folgende Methode definiert und im Load-Ereignishandler der Form aufgerufen:

Private Sub PrepareListBoxBinding()
    StringList = New BindingList(Of String)()
    For i = 1 To 3
        StringList.Add($"Item {i}")
    Next
    lbSimpleStringBinding.DataSource = StringList
End Sub

private void PrepareListBoxBinding()
{
    StringList = new BindingList<string>();
    for (var i = 0; i <= 3; i++)
    {
        StringList.Add($"Item {i}");
    }
    lbSimpleStringBinding.DataSource = StringList;
}

DataGridView Datenbindung mit Objekten

Ähnlich wie mit der ListBox kann man auch bei einem DataGridView verfahren, das heißt man legt die DataSource fest und konfiguriert noch ein wenig.

Standardmäßig generiert das DataGridView Spalten bei Datenbindungen automatisch, leider hat das dann auch ggf. ungewollte Spalten zur Folge.

Wir können dieses Verhalten deaktivieren, indem wir die „AutoGenerateColumns„-Eigenschaft auf False stellen und die Spalten z. B. im Designer selbst bestimmen.

Achtung! Die "AutoGenerateColumns"-Eigenschaft ist leider nicht in den Designer-Eigenschaften des DataGrids aufzufinden. Daher müssen wir Diese über den Code setzen.

Gehe dazu im Designer auf die 3 Punkte der „Columns“-Eigenschaft und klicke dann im erscheinenden Fenster links auf „Hinzufügen„.

Gebe der Spalte dann einen eindeutigen Namen und lege den Typ sowie den Header–Text fest.

Wenn Du dann auf Hinzufügen und danach auf schließen klickst, kannst Du weitere Einstellungen der Spalte festlegen.

Die wichtigste Einstellung ist wohl der „DataPropertyName“, Dieser bestimmt, welche der Eigenschaften der gebundenen Elemente in dieser Spalte dargestellt werden.

WPF Beispiele – VB.NET data binding Tutorial

Hier folgen nun einige WPF-Beispiele des VB.NET data binding Tutorial, einen Vorgeschmack siehst Du im animierten Bild hier drunter:

TextBox und TextBlock an String binden

Im ersten XAML Code, erstellen wir eine GroupBox mit einem StackPanel und den dann zu bindenden Controls.

Darunter eine TextBox, um den Text einzugeben und der TextBlock, der die Daten sofort bei Änderung anzeigt.

Wie auch im WinForms-Beispiel müssen wir den Zeitpunkt zum updaten der Daten konfigurieren.

Bei WPF machen wir das mit der „UpdateSourceTrigger„-Eigenschaft und dem Wert „PropertyChanged„.

Auch hier kannst Du die Eigenschaft von oben verwenden.

<GroupBox Header="TextBox">
    <StackPanel>
        <TextBox Text="{Binding TextBoxText, UpdateSourceTrigger=PropertyChanged}" />
        <TextBlock Text="{Binding TextBoxText}" />
    </StackPanel>
</GroupBox>

CheckBox an Boolean binden

Um eine CheckBox an einen Boolean zu binden, benötigst Du diesen hier drunter geschrieben XAML-Code.

Die „IsChecked„-Eigenschaft der CheckBox wird hier an die Boolean-Eigenschaft der Form namens „CheckBoxBool“ gebunden.

Um Feedback zu erhalten und zu sehen, wann die Änderungen an die Eigenschaft kommuniziert werden, stelle ich das Ganze noch in einem TextBlock dar.

<GroupBox Header="CheckBox">
    <StackPanel>
        <CheckBox IsChecked="{Binding CheckBoxBool}" />
        <TextBlock Text="{Binding CheckBoxBool}" />
    </StackPanel>
</GroupBox>

ObservableCollection an ListBox und DataGrid binden

Für die listen-basierten Beispiele wirst Du eine Auflistung wie Diese hier brauchen:

Public Property Customers As ObservableCollection(Of Customer)

public Customers As ObservableCollection<Customer> { get; set; }

Diese können wir dann wie folgt vorbereiten (am besten im Konstruktor aufrufen):

Private Sub PrepareCustomers()
    Customers = New ObservableCollection(Of Customer)
    Customers.Add(New Customer("John", "Doe"))
    Customers.Add(New Customer("Maximilian", "Doe"))
    Customers.Add(New Customer("Robert", "Doe"))
End Sub

private void PrepareCustomers()
    Customers = New ObservableCollection(Of Customer);
    Customers.Add(new Customer("John", "Doe"));
    Customers.Add(new Customer("Maximilian", "Doe"));
    Customers.Add(new Customer("Robert", "Doe"));
End Sub

<GroupBox Header="ListBox" Height="80">
    <ScrollViewer VerticalScrollBarVisibility="Auto">
        <ListBox ItemsSource="{Binding Customers }" />
    </ScrollViewer>
</GroupBox>

Hier siehst Du einen beispielhaften Code, um die Customers als Datenquelle für eine ListBox zu verwenden:

<GroupBox Header="DataGrid" Height="80">
    <DataGrid ItemsSource="{Binding Customers }" AutoGenerateColumns="False">
        <DataGrid.Columns>
            <DataGridTextColumn Binding="{Binding FirstName}" />
            <DataGridTextColumn Binding="{Binding LastName}" />
        </DataGrid.Columns>
    </DataGrid>
</GroupBox>

Und hier wäre der passende Code für das DataGrid:

<GroupBox Header="DataGrid" Height="80">
    <DataGrid ItemsSource="{Binding Customers }" AutoGenerateColumns="False">
        <DataGrid.Columns>
            <DataGridTextColumn Binding="{Binding FirstName}" />
            <DataGridTextColumn Binding="{Binding LastName}" />
        </DataGrid.Columns>
    </DataGrid>
</GroupBox>

Downloads – VB.NET data binding Tutorial

Hier findest Du alle Downloads zum VB.NET data binding Tutorial:

Der Beitrag VB.NET data binding Tutorial erschien zuerst auf Robert Skibbe.

Auf YouTube ansehen Code Download

Der Beitrag TextBox mit Wasserzeichen erschien zuerst auf Robert Skibbe.

Auf YouTube ansehen Code Download

Der Beitrag Text in TextBox auswählen erschien zuerst auf Robert Skibbe.