klick Archive - Robert Skibbe

Eigene WPF Commands in MVVM VB.NET & C# – der 2024 Guide

Robert Skibbe — Sat, 07 Jan 2023 11:32:01 +0000

Eigene Commands in VB.NET WPF MVVM mit PasswordBox, Tricks und Co. – Guide

Nutze WPF Commands, vermeide „Button1_Click“ & Co.

Im heutigen Beitrag schauen wir uns das Thema „eigene WPF Commands“, bzw. die passende Schnittstelle „ICommand“ an. Damit werden wir der besonders aus Winforms-Zeiten (Windows Forms) bekannten Vermischung von Design und Quellcode entfliehen. Dazu schauen wir uns erst die Basis der „ICommand“-Schnittstelle an und erstellen auch anschließend eine wiederverwendbare Klasse – wir haben schließlich keinen Bock, alles 10x zu schreiben! Um alles zu verstehen, geht es hier und da natürlich noch einmal Richtung Details, aber gut, so viel Zeit muss sein, wenn man nicht nur „Copy & Paste“-Master sein möchte :)!

In diesem Beitrag werden wir synchrone Commands besprechen, die asynchrone Variante werden wir im Detail, in einem der nächsten Beiträge angehen. Ebenso wird das Thema „Login“ nur als Beispiel thematisiert und nicht vollständig realisiert. Allgemein möchte ich erreichen, dass Du hier rausgehen und „Nice, ich habe Commands verstanden“ sagen kannst :)!

Kurzfassung – .NET WPF Commands in MVVM

Wenn Du es eilig hast, hier die Kurzfassung über .NET MVVM Commands in WPF:

Ersetze z. B. die typischen Click-Handler von Buttons durch passende Datenbindungen an sogenannte Commands. Beachte jedoch, dass Commands nicht nur von Buttons, sondern z. B. auch von Kontextmenüs unterstützt werden!
Dazu musst Du Deinem View in erster Linie einen Datenkontext geben, damit es weiß, woher es die „Dinge“ durch Datenbindung bekommen kann.
Sage in Deinem Button-XAML dann via Command-Eigenschafts-Bindung, dass Du das „LoginCommand“ verwenden möchtest – voilà!
Implementiere im nächsten Schritt die „ICommand„-Schnittstelle und erstelle danach in Deinem Datenkontext eine passende, bindbare Eigenschaft, z. B. „LoginCommand“ zur Verfügung.
Instanziiere die Command-basierte Eigenschaft nun z. B. in Deinem ViewModel–Konstruktor.
Übergib manuelle oder gebundene Parameter, indem Du an die CommandParameter–Eigenschaft des (z. B.) Buttons bindest.

Damit Du die Implementierung allerdings nicht hunderte Male und für z. B. jeden Knopf wiederholen musst, würde ich Dir eine Abstraktion durch eine Basisklasse vorschlagen. Eine derartige Klasse (für VB.NET & C#) findest Du natürlich auch hier im Beitrag. Scrolle dazu einfach zu „eine wiederverwendbare Command-Basisklasse„, oder direkt zu den Downloads.

Beitrag als Video ansehen

Wenn Du diesen Beitrag lieber im Videoformat genießen möchtest, kannst Du natürlich auch das folgende Video (vielleicht auch ergänzend) ansehen. Besonders die Hinweise bezüglich der „PasswordBox“ sind sehr wichtig!

Projekt- und Ordnerstruktur

Projekt- und Ordnerstruktur – VB.NET WPF Commands in MVVM

Bevor wir mit dem eigentlichen Thema „WPF Commands in MVVM“ loslegen können, legen wir uns als Erstes unsere Projektstruktur zurecht. Eine vernünftige Ordner- und Organisationsstruktur ist natürlich nicht nur nützlich, wenn man allein arbeitet, um z. B. immer in den gewohnten Ablauf hineinzukommen. Es hilft uns zusätzlich auch dabei, falls wir mal etwas outsourcen, bzw. jemanden um Hilfe bitten müssen – und das kommt häufig schneller vor, als man denkt! Wer will sich außerdem in seinem eigenen Code immer den Ast absuchen müssen, nur weil es jedes Mal anders aussieht? Keiner!

Natürlich könnte ich jetzt hier auch alles wieder von vorn erzählen, möchte es aber im Sinne des Entwicklers (Don’t repeat yourself – wiederhole dich nicht) vermeiden. Schaue Dir den Basis-Projektaufbau daher gerne in meinem Beitrag „Wie setzt man ein VB.NET, bzw. WPF MVVM-Projekt auf“ an.

Die Rollenverteilung in .NET WPF MVVM

Trennung von Rollen im MVVM-Entwurfsmuster

Da dieser Beitrag die Verwendung von Commands im Fokus hat, verstehe bitte, dass ich nicht zu tief in das „Model-View-ViewModel“-Entwurfsmuster selbst abtauchen kann. Allerdings ist für die Verwendung von WPF Commands natürlich ein gewisses Grundverständnis der MVVM-Architektur erforderlich. Besuche für eine erweiterte Erklärung gerne meinen Beitrag zum MVVM-Entwurfsmuster, auch wenn Dieser C#-geprägt ist, sind alle Erkenntnisse natürlich auch bei VB.NET analog.

Grundsätzlich geht es bei dieser Strukturierung von modernen .NET Applikationen (oder auch Applikationen im Allgemeinen) anhand des MVVM-Musters darum, eine saubere Rollentrennung zu erreichen. Insbesondere spricht man hier von der Trennung von Benutzeroberfläche und Geschäftslogik – woran meist verschiedene Personen wie Designer und Entwickler arbeiten. Dies bietet nicht nur die Möglichkeit, sich fast ganz auf seine Rolle konzentrieren zu können, sondern auch ganz andere praktische Vorteile. So erreicht man durch die einfachere Austauschbarkeit von „Views“ und „ViewModels“ etwa eine erhöhte Test- und Wartbarkeit seiner Software im Allgemeinen.

Das View – die Aufgabe des Designers

Je nach Herangehensweise (also View-, oder ViewModel-First) geht z. B. der Designer hin und entwirft nach etwaigen Wireframing-Prozessen die gewünschte Oberfläche mit Hilfe der XAML-Auszeichnungssprache. Mit dem Kunden wurden also ggf. vorherige Absprachen (mit Skizzen – Wireframes) getroffen, Welche das ungefähre Layout und Design zumindest grob bestimmen sollen. Dies kann dann z. B. ohne eine Zeile Code geschrieben zu haben wie gleich folgend aussehen und eine gemeinsame Basis / einen gemeinsamen Konsens bilden. Zugegebenermaßen ist das folgende Beispiel schon eher auf einem „Non-Plus-Ultra“-Level, da man – je nach Unternehmensgröße – eher ein „mach‘ Mal“ geliefert bekommt. Aber gut, träumen darf man als Entwickler noch, oder!?

MVVM WPF XAML Wireframing Prozess – Quelle: moqups.com Wireframing Tool

Wenn unsere Wünsche daher also wahr werden, haben die Designer die Möglichkeit, die skizzierten Wünsche des Kunden relativ unabhängig vom Entwickler (-Team) in XAML umsetzen zu können. Ganz im Stil von WPF und Co. verwendet man hier Datenbindungen, also XAML Binding-Anweisungen, wie z. B.:

Den Designern kann und soll es an dieser Stelle egal sein, wie genau die „WelcomeMessage“ erschaffen und verändert wird, solange Sie daran binden können – ergo sich an die WPF-Mechanismen gehalten wird. Viele verkaufen den utopischen Traum des „Solo-Separat-Entwickelns“ zu gern, allerdings muss natürlich trotzdem Austausch zwischen Entwicklern und Designern stattfinden. Ein „wir arbeiten vollkommen getrennt voneinander“ ist also nicht zu 100% möglich, ABER eben viel viel einfacher. Die Designer können ja schließlich z. B. auch nicht raten, ob unsere „IsSelected“-Eigenschaft nun eben sinnigerweise so, oder „Selected“ heißt. Je öfter man zusammenarbeitet, desto leichter erschließen sich solche Muster natürlich in Zukunft und man kann immer unabhängiger, gar blind zusammenarbeiten.

Der Entwickler, die ViewModels, Geschäftslogik und Co.

Nachdem wir als Entwickler – im Optimalfall – also nun unsere Wireframes bekommen haben, können nun auch wir ziemlich isoliert / separat tätig werden. Wir entwerfen die passenden ViewModel-Klassen zu den gezeigten Oberflächen, Welche „INotifyPropertyChanged“ und Co. verwenden, um durch die Datenbindungen zu kommunizieren. Schaue Dir hierzu gerne meinen Beitrag zum Thema „INotifyPropertyChanged“ an. Bei Bedarf erschaffen wir Test-ViewModels, Welche wir durch die neue Herangehensweise, ohne Probleme und Aufwand austauschen und testen können.

Wie erwähnt möchte ich den Exkurs in Richtung „Model-View-ViewModel-Entwurfsmuster“ nicht zu weit treiben, daher gehe ich hier nicht weiter auf z. B. Models ein. Ich denke sowieso, dass das nicht zielführend wäre, denn zu viel Input ist ja auch schlecht, oder? „Kleine“ Häppchen machen dann schon eher den Appetit :)!

Ein kleines Login-Fenster-Beispiel für WPF Commands

Ein erstes, eigenes WPF Command in MVVM

Nach dem kleinen Exkurs von oben, schauen wir uns nun die weitere Reise in Richtung Commands an. Dazu bauen wir uns im nächsten Schritt eine kleine Login-Oberfläche (Achtung, billig..), Welche wie gleich folgend aussehen könnte. Hier werden wir auch direkt aus einer Art Designer-Perspektive agieren, also wir arbeiten in erster Linie „nur“ am XAML-Code selbst.

Wir tun hier einfach mal so, als hätten wir ein passendes Wireframe vom Kunden vorliegen.. Was macht also ggf. in erster Linie eine Login-Oberfläche aus? Naja, wir brauchen:

Eine Textbox für die Eingabe des Nutzers / E-Mail-Adresse
Ein Label / Textblock für diese Textbox, sonst weiß der Nutzer nicht was das soll
Eine PasswordBox für die Eingabe des Passworts (beachte hier die Hinweise)
Auch hierfür einen Textblock
Einen Button, wie soll der Benutzer sonst „Login-Versuch durchführen“ triggern
ggf. weiteren Kram, wie „Passwort vergessen“ – lassen wir hier aber aus..

Bitte bedenke auch an dieser Stelle – wie oben angekündigt –, dass wir hier kein vollständiges Login-Beispiel realisieren können, da der Beitrag auch so schon lang genug wird 😉! Einen Login werde ich ggf. mal in einem anderen Beitrag separat behandeln und dort dann ausführen.

Datenbindungen des Login-Fensters

Nachdem wir im obigen Schritt die grundsätzlich benötigten Steuerelemente angemerkt haben, brauchen wir – für MVVM selbstverständlich – auch passende Datenbindungen. Ansonsten wüssten weder die Textboxen, woher Sie Ihren Text bekommen, oder gar „hinschicken“ sollen. Ebenso hätte der Anmelden-Knopf keine Ahnung, was beim Klick passieren soll (Spoiler: Ein Command ausführen).

Der Designer wird an dieser Stelle hier irgendwie vorher (mit Kunden und Entwicklern) besprochen haben, dass es im ViewModel so etwas namens „User“ geben muss. Dabei handelt es sich genauer genommen um eine String-Eigenschaft, welche den dementsprechenden Text für die Textbox – also den Benutzer – beinhalten muss. Ebenso muss diese Eigenschaft bei Code-technischen Änderungen nach außen kommunizieren, dass Sie sich geändert hat. Dies geht wie vermutlich bekannt über „INotifyPropertyChanged“, was hier allerdings nicht weiter Thema sein wird. Hier nochmal erneut der Hinweis auf meinen „INotifyPropertyChanged“-Beitrag mit „PropertyChanged“-Basisklasse.

Schaue Dir nun einmal den XAML-Code zum Fenster an, beachte, dass Du die obigen „Projekt- und Ordnerstruktur“-Schritte korrekt abgeschlossen hast. Ansonsten wirst Du hier vermutlich Probleme mit Namespace und Co. bekommen. Passe ebenfalls auf, dass Du den Projektnamen umbenennen musst, in meinem Beispiel hieß das Projekt „WpfCommandsVbTutorial“.

Datenkontext (DataContext) setzen

Im ersten Schritt ergänzen wir die folgenden zwei Punkte in den XAML-Code des MainWindows (MainViews).

1. Wir mappen via „xmlns:“ einen Namespace anhand eines Aliases:


xmlns:vm="clr-namespace:WpfCommandsVbTutorial.ViewModels"

2. Wir geben dem jeweiligen View einen Datenkontext (DataContext-Eigenschaft des Windows) über XAML. Wie Du vielleicht weißt, wäre dies auch via „Code behind“-Datei möglich, ich habe mich hier für die XAML Variante entschieden:

Du kannst an dieser Stelle übrigens die Styling-relevanten Dinge ignorieren, also praktisch alles, was in „StackPanel.Resources“ z. B. steht. Dies ist nur zur Anschauung erstellt worden und Du solltest Deinen Fokus größtenteils auf die oben aufgelisteten Steuerelemente legen.

Das ViewModel zur Oberfläche

Ein ViewModel zur Oberfläche

Bevor wir mit den WPF Commands im Detail fortfahren können, müssen wir noch etwas bauen, was Diese letztendlich beinhaltet. Hierbei rede ich natürlich von einer ViewModel-Klasse, Welche alles Notwendige für die Datenbindungen bereitstellt. Neben dem oben im XAML erwähnten „LoginCommand“, bezieht sich dies natürlich auch auf die Eigenschaften wie „User“ und „Password“.

Wenn wir dies auslassen würden, könnte die grafische Oberfläche Ihre dort empfangenen Änderungen nie via Datenbindungen an die dahinter liegenden ViewModel-Eigenschaften weitergeben. Somit hätten wir auch in unserer Geschäftslogik (innerhalb des ViewModels) nie die Chance, damit tatsächlich arbeiten zu können. Wie Du Dir also vorstellen kannst, wäre eine Anmeldung ohne z. B. typische Benutzer- und Passwort-Kombination ziemlich schwierig.

Fehlermeldungen bei fehlender / falscher Datenbindung

Falls Du an dieser Stelle also eine der typischen Binding-Fehlermeldungen bekommen solltest, kannst Du Dir nun vorstellen woran das liegt. Du hast vermutlich vergessen, den DataContext mit einer passenden ViewModel-Instanz zu befüllen – wie wir es im gleich folgenden Schritt tätigen werden. Typische Fehlermeldung sehen ungefähr so aus, also hier wurde z. B. die „User“-Eigenschaft nicht auf der „MainViewModel“-Instanz gefunden:

BindingExpression Fehler – User konnte nicht für die Datenbindung auf dem ViewModel gefunden werden

Falls Du also eine derartige Fehlermeldung bekommst, stelle sicher, dass die Eigenschaft „User“ in Deinem Viewmodel existiert. Es kann hier aber auch vorkommen, dass z. B. gar kein Fehler kommt und dennoch nichts passiert. Dies ist z. B. der Fall, wenn Du vergisst, den DataContext überhaupt zu setzen! Denke daran, dass wir das hier im View selbst, also via XAML-Code weiter oben getan haben!

Das (erste) MainViewModel erstellen

Erstelle für die weitere Vorgehensweise in Richtung WPF Commands nun einmal bitte eine Klasse namens „MainViewModel“ in Deinem „ViewModels“-Ordner. Unsere ViewModel-Klasse wird hierbei von der „PropertyChangedBase“-Basisklasse erben, damit wir die dort zurechtgeschriebene Funktionalität weiterverwenden können. Somit sparen wir es uns, die „INotifyPropertyChanged“-Schnittstelle immer und immer wieder manuell implementieren zu müssen. Kopiere Dir die Basisklasse ruhig von diesem Beitrag hier.

Nun das MainViewModel, wundere Dich bitte nicht, dass dort schon anderer Kram drin steht, aber ich möchte Dir diesen Batzen gleich nicht noch 3x um die Ohren hauen. Wir nehmen dies daher als Basis und arbeiten uns von dort aus weiter durch den Code. Es fehlen hier auch noch die ein odere andere Funktion, sowie eine Klasse für die Commands, Welche wir natürlich noch erstellen.

Imports WpfCommandsVbTutorial.Utils

Namespace ViewModels

    Public Class MainViewModel
        Inherits PropertyChangedBase

        Private _user As String

        Public Property User As String
            Get
                Return _user
            End Get
            Set(value As String)
                If _user = value Then
                    Return
                End If
                _user = value
                NotifyOfPropertyChange()
            End Set
        End Property

        Private _password As String

        Public Property Password As String
            Get
                Return _password
            End Get
            Set(value As String)
                If _password = value Then
                    Return
                End If
                _password = value
                NotifyOfPropertyChange()
            End Set
        End Property

        Public Property LoginCommand As LoginCommand

        Sub New()
            LoginCommand = New LoginCommand()
        End Sub

    End Class

End Namespace

using Utils;

namespace ViewModels;

public class MainViewModel : PropertyChangedBase
{
    private string _user;

    public string User
    {
        get => _user;
        set
        {
            if (_user == value)
                return;
            _user = value;
            NotifyOfPropertyChange();
        }
    }

    private string _password;

    public string Password
    {
        get => _password;
        set
        {
            if (_password == value)
                return;
            _password = value;
            NotifyOfPropertyChange();
        }
    }

    public LoginCommand LoginCommand { get; set; }

    public MainViewModel()
    {
        LoginCommand = new LoginCommand();
    }

}

Die üblichen Mechanismen

Zuerst einmal siehst Du im obigen MainViewModel-Code die 3 wichtigsten Eigenschaften für unser Login-Fenster:

Die User-Eigenschaft
Die Password-Eigenschaft
Die LoginCommand-Eigenschaft

Bis auf das „LoginCommand“ sind alle Eigenschaften sogenannte „voll implementierte“-Eigenschaften, Sie haben also einen von uns manuell implementierten Getter und Setter. Dies geschieht deshalb, weil wir im Setter sagen müssen: „Hey, es hat sich Code-seitig z. B. der User geändert“. Das passiert einerseits, wenn wir einen gespeicherten Zugang von der Festplatten laden, aber auch, wenn der Benutzer des Programms eine Eingabe in der Textbox macht – besonders hierzu aber gleich noch etwas! Andererseits können wir dem Command das dann auch noch explizit mitteilen, denn warum sollte man sich anmelden können, wenn, wenn z. B. gar kein Benutzername eingegeben wurde? Dazu kommen wir aber noch..

Etwas anders sieht es wie schon gesagt beim „LoginCommand“ aus, denn Dieses wird nach der Instanziierung nicht mehr geändert. Hier reicht also eine sogenannte automatisch implementierte Eigenschaft aus.

Der erste Command-Versuch

WPF Command nach 3 Klicks sperren

An dieser Stelle werden wir den ersten Versuch Richtung eigener WPF Commands starten. Wir werden dafür das sogenannte „ICommand“-Interface (manuell) implementieren – später vereinfacht, keine Sorge! Erstelle also nun bitte eine weitere Klasse (ohne Datei) namens „LoginCmd“, Diese kannst Du für den Anfang einfach innerhalb des Wurzelverzeichnisses Deines Projektes ablegen. Dies werden wir selbstverständlich später ändern, brauchen wir aber am Anfang zur reinen Demonstration.

Schreibe für VB.NET anschließend – wie für Schnittstellen-Implementierungen üblich – einfach „Implements INotifyPropertyChanged“ unter die beginnende Klassendefinition: „Public Class LoginCommand“. Für C# kannst Du ein „: INotifyPropertyChanged“ hinter den Klassennamen schreiben. In beiden Fällen kannst Du dann die Imports durch die Visual Studio-Hilfe durchführen. Alternativ kannst Du auch Strg+“.“ drücken und die dann erscheinenden Vorschläge durchführen.

Imports WpfCommandsVbTutorial.Utils

Namespace ViewModels

    Public Class MainViewModel
        Inherits PropertyChangedBase

        ' restlicher MainViewModel-Code

        Public Property LoginCommand As LoginCommand

        Sub New()
            LoginCommand = New LoginCommand()
        End Sub

        Public Class LoginCmd
            Implements ICommand

            Public Sub Execute(parameter As Object) Implements ICommand.Execute
                Throw New NotImplementedException()
            End Sub

            Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
                Throw New NotImplementedException()
            End Function

            Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

        End Class

    End Class

End Namespace

using System.Windows.Input;
using System;
using Utils;

namespace ViewModels;

public class MainViewModel : PropertyChangedBase
{

    // restlicher MainViewModel-Code

    public LoginCmd LoginCommand { get; set; }

    public MainViewModel()
    {
        LoginCommand = new LoginCmd();
    }

    public class LoginCmd : ICommand
    {

        public void Execute(object? parameter)
        {
            throw new NotImplementedException();
        }

        public bool CanExecute(object? parameter)
        {
            throw new NotImplementedException();
        }

        public event EventHandler? CanExecuteChanged;

    }
}

Was soll bei Ausführung des WPF Commands passieren?

Um dem Command sagen zu können: „Hey, wenn Du ausgeführt wirst, soll xy passieren“, müssen wir nun eine bestimmte Methode implementieren. Dabei handelt es sich um die „Execute“-Methode, der „ICommand“-Schnittstelle. Dort drin können wir beispielsweise einmal einen Anmeldevorgang simulieren, mehr wird denke ich zu kompliziert sein, also etwa mit Services zu kommunizieren, usw. Das werde ich aber mit Sicherheit noch in einem anderen Beitrag vertiefen!

Die „Execute“-Methode sieht dann grundsätzlich erstmal wie folgt aus:

Public Class LoginCommand
    Implements ICommand

    Public Sub Execute(parameter As Object) Implements ICommand.Execute
        ' hier kommt rein, was beim Klick passieren soll
        Debug.WriteLine("Melde mich an")
    End Sub

    ' restlicher Code..

End Class

public class LoginCommand : ICommand
{

    public void Execute(object? parameter)
    {
        // hier kommt rein, was beim Klick passieren soll
        Debug.WriteLine("Melde mich an");
    }

    // restlicher Code..

}

Kann das WPF Command überhaupt ausgeführt werden?

Nachdem wir die eine „Execute“-Methode implementiert und somit beschrieben haben, was beim Ausführen des Commands passieren soll, geht’s nun mit dem „kann ich das ausführen“ weiter. Es wäre ja z. B. blöd, wenn der Benutzer der Software den „Anmelden“-Knopf spammen könnte. Stattdessen sollte man den Button deaktivieren, während z. B. eine Art Sperre stattfindet. Dazu müssen wir eine Funktion namens „CanExecute“ implementieren, Welche – wie der Name schon sagt – bestimmt, ob das jeweilige Command gerade ausgeführt werden kann.

Der Code dazu könnte wie folgt aussehen, also, dass z. B. das Command nach 3 fehlerhaften Login-Versuchen gesperrt ist.

Public Class LoginCommand
    Implements ICommand

    Private _failedAttempts As Integer

    Public Sub Execute(parameter As Object) Implements ICommand.Execute
        ' simulate failed login attempt
        _failedAttempts += 1
    End Sub

    Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
        Return _failedAttempts < 3
    End Function

    Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

End Class

using System;
using System.Windows.Input;

public class LoginCommand : ICommand
{
    private int _failedAttempts;

    public void Execute(object? parameter)
    {
        // simulate failed login attempt
        _failedAttempts++;
    }

    public bool CanExecute(object? parameter)
    {
        return _failedAttempts < 3;
    }

    public event EventHandler? CanExecuteChanged;

}

Zum Schluss bleibt hier nun noch ein letztes Problem: Das Command wird so gesehen niemals „aktualisiert“. Es wird aktuell leider nicht nach außen bekanntgemacht: „Hey, grafische Oberfläche, evaluiere bitte einmal neu, ob ich ausgeführt werden kann, denn hier hat sich was geändert!“. Somit bleibt das Command aktuell immer ausführbar. Wenn Du stattdessen z. B. initial ein Kriterium hättest – wie z. B. eine Rolle an Nutzern– die den Button nicht drücken dürfen, dann könnte es auch sein, dass der Button permanent grau hinterlegt ist. Keine Sorge, darum kümmern wir uns nun im letzten Schritt!

Neu evaluieren, ob ausgeführt werden kann

Um der grafischen Oberfläche genau dieses Signal a la „Hey, re-evaluiere hier bitte einmal die CanExecute-Funktion“ zu geben, müssen wir nur eins tun: Das Ereignis auslösen, Welches bewusst von der „ICommand“-Schnittstelle dafür vorgegeben wurde, namens „CanExecuteChanged“. Aktuell ist dies noch relativ einfach, da wir alles was wir dafür benötigen, innerhalb der Command-Instanz selbst haben.

Was ich meine, ist die Anzahl an fehlgeschlagenen Anmelde-Versuchen, Welche wir in der Zeile 3 deklariert haben. Wir müssten also eigentlich immer das „CanExecuteChanged“-Ereignis auslösen, wenn sich diese Variable ändert. Gleich kommen wir auch noch dazu, wie wir unter Umständen agieren könnten, wenn wir z. B. auf eine „IsLoading“-Eigenschaft eines ViewModels keinen Zugriff haben.

Das könnte z. B. so aussehen:

Public Class LoginCommand
    Implements ICommand

    Private _failedAttempts As Integer

    Public Sub Execute(parameter As Object) Implements ICommand.Execute
        ' simulate failed login attempt
        _failedAttempts += 1
        RaiseEvent CanExecuteChanged(Me, EventArgs.Empty)
    End Sub

    Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
        Return _failedAttempts < 3
    End Function

    Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

End Class

using System.Windows.Input;
using System;

public class LoginCommand : ICommand
{
    private int _failedAttempts;

    public void Execute(object? parameter)
    {
        // simulate failed login attempt
        _failedAttempts++;
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }

    public bool CanExecute(object? parameter)
    {
        return _failedAttempts < 3;
    }

    public event EventHandler? CanExecuteChanged;

}

Der ganze Aufwand für ein einziges Command?

Ich gebe zu, dass dies alles, vor allem als Anfänger natürlich erstmal überwältigend klingen kann, besonders für bisher ein einziges Command, aber keine Sorge – „I got you“. Statt diesen Aufwand immer wieder von vorn zu betreiben, werden wir uns – als „faule“ Entwickler – selbstverständlich einige Hilfsmittel schreiben, Welche uns die Arbeit vereinfachen. Im ersten Schritt wird das die gleich folgende, wiederverwendbare Klasse Namens z. B. „DelegateCommand“ sein.

Eine wiederverwendbare DelegateCommand-Klasse

Das DelegateCommand – unsere Basisklasse für WPF Commands

Wie Du vermutlich im letzten Schritt festgestellt hast, ist das Ganze mit den WPF Commands nicht so „mal eben“ wie mit den Click-Handlern erledigt. Lasse Dich aber bitte hier dennoch nicht dazu verführen – typisch Mensch, typisch Gewohnheitstier – dennoch wieder die alten „Button1_Click“ und Co. Dinger zu verwenden. Wir können uns wie hier drüber erwähnt, auch viele Hilfsmittel erschaffen, mit Denen wir uns das Handling deutlich vereinfachen können.

Im Endeffekt ändert sich von der Konzeption des Commands selbst, nicht viel, wir brauchen immer noch folgende Aspekte:

Was soll bei Ausführung getan werden?
Kann es ausgeführt werden?
Wann ändert sich die Info, ob’s ausgeführt werden kann?

Allerdings möchten wir nun nicht jedes Mal dafür eine eigene Klasse erstellen, sondern alles ein wenig mehr zentralisieren. Das können wir ganz einfach, indem wir Obiges logisch betrachten: Punkt 1 ist einfach nur ein „Packen“ Arbeit, Welchen wir in die Zukunft delegieren (vielleicht rückt der Begriff „DelegateCommand“ nun etwas näher 😉), nämlich bei z. B. einem Klick. Punkt 2 ist praktisch das Gleiche in bunt, nur, dass wir eine „Ja/Nein“-Info zurückbekommen: Also einen Boolean. Punkt 3 kann je nach Fall komplizierter werden, aber auch das lässt sich regeln.

Methoden / Funktionalität dynamisch übergeben

Wenn man nun zu den obigen Erkenntnissen gekommen ist, fragt man sich im nächsten Schritt das Offensichtliche: „Okay, aber wie verlagere / gruppiere ich denn überhaupt Arbeit?“. Das Stichwort, bzw. die Stichworte Deiner Begierde nennen sich „Action„, bzw. „Func„. Diese übernehmen exakt das, was wir bruachen, Sie kapseln / gruppieren unsere Anweisungen und machen Diese praktisch ansprech- und ausführbar – auch später.

Der erste Versuch – delegierte Arbeit

Schreiben wir also nun unseren aus den Erkenntnissen resultierenden, ersten Versuch. Hierbei geht es erstmal nur darum, die „Was soll getan werden“-Anweisungen als Gruppe von Anweisungen zu verlagern / zu delegieren. Das geht auch im Endeffekt ganz einfach, schaue Dir dazu diese neue Variante unserer Command-Implementierung an.

Wir lassen hierbei der instaziierenden Partei die Möglichkeit, den gruppierten Stapel an Arbeit von außen mitzugeben. Beachte auch, dass wir sogar die Möglichkeit haben, einen Parameter mitzuliefern. Dadurch sind wir – indem wir z. B. eine weitere Klasse erstellen – auch nicht auf einen Übergabeparameter limitiert, könnten also praktisch eine ganze „Config“ mitliefern. Natürlich muss dies passend in der Execute-Methode gecastet werden..

Namespace Utils

    Public Class DelegateCommand
        Implements ICommand

        Private _action As Action(Of Object)

        Sub New(action As Action(Of Object))
            _action = action
        End Sub

        Public Sub Execute(parameter As Object) Implements ICommand.Execute
            ' führt unsere von außen mitgegebene Aktion aus und übergibt auch den Parameter
            _action(parameter)
        End Sub

        Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
            Return True
        End Function

        Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

    End Class

End Namespace

using System.Windows.Input;
using System;

namespace Utils;

public class DelegateCommand : ICommand
{
    private Action _action;

    public DelegateCommand(Action action)
    {
        _action = action;
    }

    public void Execute(object? parameter)
    {
        // führt unsere von außen mitgegebene Aktion aus und übergibt auch den Parameter
        _action?.Invoke(parameter);
    }

    public bool CanExecute(object? parameter)
    {
        return true;
    }

    public event EventHandler? CanExecuteChanged;

}

Delegierte Arbeit im MainViewModel verwenden

Zurück in unserem (komprimierten) MainViewModel, könnte die Erstellung des Commands nun wie gleich folgend und vollkommen dynamisch aussehen. Beachte auch, dass wir durch Polymorphie oben ein „ICommand“ deklarieren, aber ein diese Schnittstelle implementierendes Objekt zuweisen können (im Konstruktor).

Imports WpfCommandsVbTutorial.Utils

Namespace ViewModels

    Public Class MainViewModel
        Inherits PropertyChangedBase

        ' restliche Eigenschaften..

        Public Property LoginCommand As ICommand

        Sub New()
            LoginCommand = New DelegateCommand(AddressOf Login)
        End Sub

        ' unsere gruppierten Anweisungen - zusammengefasst
        Private Sub Login(parameter As Object)
            ' tu dies
            ' tu jenes
            ' tu das
        End Sub

    End Class

End Namespace

using System.Windows.Input;
using Utils;

namespace ViewModels;

public class MainViewModel : PropertyChangedBase
{

    // restliche Eigenschaften..

    public ICommand LoginCommand { get; set; }

    public MainViewModel()
    {
        LoginCommand = new DelegateCommand(Login);
    }

    // unsere gruppierten Anweisungen - zusammengefasst
    private void Login(object? parameter)
    {
        // tu dies
        // tu jenes
        // tu das
    }
}

Was fehlt ist, ob’s geht!

Was nun noch als vorletzter Punkt fehlt, ist eine dynamische Feststellung, ob das Command überhaupt ausgeführt werden kann, denn das haben wir aktuell völlig vernachlässigt. Zum Glück können wir uns auch hier ganz schnell helfen, denn dafür gab es neben der „Action“ auch etwas namens „Func“. Damit können wir eine Funktion dynamisch übergeben und dessen Rückgabewert nach unserem Belieben auswerten.

Hierzu habe ich einen neuen Konstruktor erstellt, Welcher uns dann die optionale Möglichkeit bietet, sagen zu können: „Hey, so stellst Du fest, ob das Command ausgeführt werden kann“. Wenn dies also nicht mitgegeben wird, könnte man praktisch davon ausgehen, dass das Command immer ausgeführt werden kann.

Die finale DelegateCommand-Basisklasse

Namespace Utils

    Public Class DelegateCommand
        Implements ICommand

        Private _action As Action(Of Object)

        Private _canExecute As Func(Of Object, Boolean)

        Sub New(action As Action(Of Object))
            _action = action
        End Sub

        Sub New(action As Action(Of Object), canExecute As Func(Of Object, Boolean))
            _action = action
            _canExecute = canExecute
        End Sub

        Public Sub Execute(parameter As Object) Implements ICommand.Execute
            ' führt unsere von außen mitgegebene Aktion aus und übergibt auch den Parameter
            _action(parameter)
        End Sub

        Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
            If _canExecute Is Nothing Then
                Return True
            End If
            Return _canExecute(parameter)
        End Function

        Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

    End Class

End Namespace

using System.Windows.Input;
using System;

namespace Utils
{
    public class DelegateCommand : ICommand
    {
        private Action _action;

        private Func? _canExecute;

        public DelegateCommand(Action action)
        {
            _action = action;
        }

        public DelegateCommand(Action action, Func canExecute)
        {
            _action = action;
            _canExecute = canExecute;
        }

        public void Execute(object? parameter)
        {
            _action(parameter);
        }

        public bool CanExecute(object? parameter)
        {
            if (_canExecute == null)
                return true;
            return _canExecute(parameter);
        }

        public void RaiseCanExecuteChanged()
        {
            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
        }

        public event EventHandler? CanExecuteChanged;
    }
}

Nun kann unser MainViewModel wie folgt ergänzt werden:

Imports WpfCommandsVbTutorial.Utils

Namespace ViewModels

    Public Class MainViewModel
        Inherits PropertyChangedBase

        ' other properties..

        Private Property LoginAttempts As Integer

        Public Property LoginCommand As ICommand

        Sub New()
            LoginCommand = New DelegateCommand(AddressOf Login, AddressOf CanLogin)
        End Sub

        ' our grouped instructions - summed up
        Private Sub Login(parameter As Object)
            ' do this
            ' do that
            ' do something else
            LoginAttempts += 1
        End Sub

        Private Function CanLogin(parameter As Object) As Boolean
            ' determine, if the login process should be executed and return it
            Return LoginAttempts < 3
        End Function

    End Class

End Namespace

using System.Windows.Input;
using Utils;

namespace ViewModels;

public class MainViewModel : PropertyChangedBase
{

    // restliche Eigenschaften..

    private int LoginAttempts { get; set; }

    public ICommand LoginCommand { get; set; }

    public MainViewModel()
    {
        LoginCommand = new DelegateCommand(Login, CanLogin);
    }
    
    // our grouped instructions - summed up
    private void Login(object? parameter)
    {
        // do this
        // do that
        // do something else
        LoginAttempts++;
    }

    private bool CanLogin(object? parameter)
    {
        // determine, if the login process should be executed and return it
        return LoginAttempts < 3;
    }
}

Und was, wenn es sich ändert?

Nun kommen wir (sorry, endlich) zum finalen Punkt: Wir müssen auch hier die Möglichkeit bieten, sagen zu können: „Hey Oberfläche, bitte neu evaluieren, ob das Command ausgeführt werden kann“. Dafür gibt es z. B. die „CommandManager.InvalidateRequerySuggested“-Methode, Welche ich aber nicht ganz toll finde. Alle Commands re-evaluieren, nur weil sich ggf. Eines geändert hat? Nee..

Wir werden stattdessen unser eigenes kleines Helferlein dafür einbauen, ich meine, dafür haben wir ja sowieso schon unsere Basisklasse. Wir ergänzen also eine Methode, Welche es uns von außen erlaubt, das „CanExecuteChanged“-Ereignis des Commands auszulösen. Für mich fühlt sich auch das nicht ganz super an, aber es deckt genau unsere Bedürfnisse:

Namespace Utils

    Public Class DelegateCommand
        Implements ICommand

        Private _action As Action(Of Object)

        Private _canExecute As Func(Of Object, Boolean)

        Sub New(action As Action(Of Object))
            _action = action
        End Sub

        Sub New(action As Action(Of Object), canExecute As Func(Of Object, Boolean))
            _action = action
            _canExecute = canExecute
        End Sub

        Public Sub Execute(parameter As Object) Implements ICommand.Execute
            _action(parameter)
        End Sub

        Public Function CanExecute(parameter As Object) As Boolean Implements ICommand.CanExecute
            If _canExecute Is Nothing Then
                Return True
            End If
            Return _canExecute(parameter)
        End Function

        Public Sub RaiseCanExecuteChanged()
            RaiseEvent CanExecuteChanged(Me, EventArgs.Empty)
        End Sub

        Public Event CanExecuteChanged As EventHandler Implements ICommand.CanExecuteChanged

    End Class

End Namespace

using System.Windows.Input;
using System;

namespace Utils;

public class DelegateCommand : ICommand
{
    private Action _action;

    private Func? _canExecute;

    public DelegateCommand(Action action)
    {
        _action = action;
    }

    public DelegateCommand(Action action, Func? canExecute)
    {
        _action = action;
        _canExecute = canExecute;
    }

    public void Execute(object? parameter)
    {
        _action(parameter);
    }

    public bool CanExecute(object? parameter)
    {
        if (_canExecute == null)
            return true;
        return _canExecute(parameter);
    }

    public void RaiseCanExecuteChanged()
    {
        CanExecuteChanged?.Invoke(this, EventArgs.Empty);
    }

    public event EventHandler? CanExecuteChanged;
}

Zum Schluss nun unsere letzte MainViewModel-Anpassung (bezogen auf die fehlgeschlagene Logins Geschichte):

Imports WpfCommandsVbTutorial.Utils

Namespace ViewModels

    Public Class MainViewModel
        Inherits PropertyChangedBase

        ' restliche Eigenschaften

        Public Property LoginCommand As CommandBase

        Private _loginAttempts As Integer

        Private Property LoginAttempts As Integer
            Get
                Return _loginAttempts
            End Get
            Set(value As Integer)
                _loginAttempts = value
                LoginCommand.RaiseCanExecuteChanged()
            End Set
        End Property

        Sub New()
            LoginCommand = New CommandBase(AddressOf Login, AddressOf CanLogin)
        End Sub

        Private Sub Login(parameter As Object)
            ' fehlgeschlagenen Login simulieren..
            LoginAttempts += 1
        End Sub

        Private Function CanLogin(parameter As Object) As Boolean
            Return _loginAttempts < 3
        End Function

    End Class

End Namespace

using Utils;

namespace ViewModels;

public class MainViewModel : PropertyChangedBase
{

    // restliche Eigenschaften

    public DelegateCommand LoginCommand { get; set; }

    private int _loginAttempts;

    private int LoginAttempts
    {
        get => _loginAttempts;
        set
        {
            _loginAttempts = value;
            LoginCommand.RaiseCanExecuteChanged();
        }
    }

    public MainViewModel()
    {
        LoginCommand = new DelegateCommand(Login, CanLogin);
    }

    private void Login(object? parameter)
    {
        // simulate failed login
        LoginAttempts++;
    }

    private bool CanLogin(object? parameter)
    {
        return _loginAttempts < 3;
    }
}

Wie übergibt man Command-Parameter?

WPF Command-Parameter übergeben

Bisher konnten wir schon viele Eindrücke in das WPF Command gewinnen, eine Sache ist jedoch noch ein wenig auf der Strecke geblieben, sorry. Es geht um das Übergeben von Parametern, da wir ja auch z. B. extra eine „Action“ / „Func“ mit generischem Typenparameter vom Typ „Object“ deklariert haben. Bisher verwenden wir diese Möglichkeit der Parameterübergabe noch nicht.

Jeder (und ich meine jeder) Entwickler muss hier selbst entscheiden, Welche Sicherheitsmaßnahmen für sich, Kunden und Co. angemessen sind! Dies soll die „Considerations“ selbstverständlich trotzdem nicht kleinreden und man sollte sich an „best practices“ halten..

Warum, bzw. wann übergibt man Command-Parameter?

Bevor man sich allerdings tiefer in diesen Dschungel wagt, macht diese kleine Überlegung ggf. auch Sinn: „Wann braucht man Command-Parameter überhaupt!?“. Grundsätzlich können wir ja auf die Eigenschaften unseres Viewmodels zugreifen, wenn wir lokale Methoden des ViewModels mit der DelegateCommand-Klasse von oben verwenden. Das stimmt soweit auch, aber wie wir schon im Absatz hier drüber gesehen haben, kann es Situationen geben, wo wir auf die Dinge ggf. keinen Zugriff haben, dann könnte so eine Übergabe helfen.

Parameter manuell via XAML übergeben

Lasse uns daher einmal im nächsten Schritt schauen, wie wir diese Möglichkeit der Parameter nun allgemein verwenden könnten. Ich denke hier zuerst an die einfachste Variante, also eine einfache „manuelle“ Übergabe. Dies können wir sehr einfach im XAML-Code erledigen, indem wir einfach einen passenden Wert, an die „CommandParameter“-Eigenschaft mitliefern:

WPF Command-Parameter via DataBinding übergeben

Auch ganz interessant ist die eigentlich offensichtlichste Sache, also die Übergabe via normalem Databinding. Hierzu kann ich einfach eine normale „Binding-Expression“, also einen Bindungs-Ausdruck schreiben. Dieser wird dann zu passender Zeit evaluiert und als CommandParameter übergeben:

Mehrere Parameter via Klasse oder MultiBinding übergeben

Hier kommt noch ein wichtiger Punkt, da viele Anfänger daran scheitern. Häufig stellt man folgende Überlegung an: „Okay, so übergebe ich einen einzigen Parameter an das WPF Command, aber wie kann ich Mehrere auf einmal übergeben?“.

Aber keine Sorge, die Antwort ist relativ einfach, die erste Variante wäre via eigener Klasse. Lege dazu einfach eine passende Klasse mit den Eigenschaften / Werten, die Du übertragen möchtest, an:

Public Class SpecialCmdParams

    Public Property SomePropToPassOne As String

    Public Property SomePropToPassTwo As Integer

    ' ...

End Class

public class SpecialCmdParams
{

    public string SomePropToPassOne { get; set; }

    public int SomePropToPassTwo { get; set; }

    // ...

}

Instanziiere diese Klasse nun an passender Stelle, z. B. im ViewModel-Konstruktor und befülle die Eigenschaften durch passende Bindungen an z. B. Textboxen, whatever. Im nächsten Schritt kannst Du die Instanz der Klasse natürlich einfach via Datebindung (wie hier drüber, siehe „SomeBoundPropertyToPassIn“) übergeben. Gleich schauen wir uns noch an, wie man dies dann abrufen kann.

Parameter via Multibinding übergeben

Wer keine Lust hat jedes Mal eine passende Klasse zu erstellen, kann sich die Übergabe mehrerer Command-Parameter auch durch ein sogenanntes „Multibinding“ vereinfachen. Wie der Name schon sagt, bindet man hier nicht an ein „Ding“, sondern kann gleich mehrere Datenbindungen quasi in Einer verwenden.

Das Blöde ist hier nur, dass man einen „Converter“ benötigt, wie soll sonst aus „mehrere Dinger“ -> „ein Ding“ werden? Man muss hier auch noch bedenken, dass man eventuell den Weg zurück braucht, also aus einem Ding wieder Mehrere zu machen. Ein derartiges, passendes Muster finden wir bei der „IMultiValueConverter“-Schnittstelle.

Implementieren wir dieses Interface also einmal beispielhaft, um mehrere Zahlen zu übergeben (auch wenn dies bei einem Login keinen Sinn macht), es geht wie gesagt um „Commands“ selbst :)! Wir übergeben hier einfach mal stumpf die Größe des Login-Fensters. Dies könnten wir natürlich auch durch eine normale Datenbindung realisieren, aber es geht wie gesagt um ein Beispiel!

Beachte, dass die Implementierung hier nur beispielhaft und z. B. nicht konfigurierbar ist. Zum Thema „ValueConverter“ im Allgemeinen werde ich ggf. noch einen separaten Beitrag schreiben. Erstelle also nun einmal folgende Klasse, im (z. B.) „Utils“-Ordner

Imports System.Globalization

Namespace Utils

    Public Class DoubleNumberConverter
        Implements IMultiValueConverter

        Public Function Convert(values() As Object, targetType As Type, parameter As Object, culture As CultureInfo) As Object Implements IMultiValueConverter.Convert
            Return String.Join("|", values)
        End Function

        Public Function ConvertBack(value As Object, targetTypes() As Type, parameter As Object, culture As CultureInfo) As Object() Implements IMultiValueConverter.ConvertBack
            Return value.ToString.Split("|")
        End Function

    End Class

End Namespace

using System.Globalization;

namespace Utils
{
    public class DoubleNumberConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            return string.Join("|", values);
        }

        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            return value.ToString().Split("|");
        }
    }
}

Damit können wir dann ein Multibinding realisieren, Welches dann über übliche Binding-Ausdrücke Daten mitliefert – aber eben Mehrere! Vergiss hier jedoch nicht, eine Instanz des „DoubleNumberConverters“ entweder in der App.xaml / Application.xaml, oder in Deinem jeweiligen Control (UserControl, Window, etc..) zu erstellen. Ansonsten kannst Du den Konverter nicht verwenden:

Übergebene Parameter abgreifen

Nachdem wir die Beispiele zum Übergeben der Parameter gesehen haben, schauen wir uns nun an, wie wir Diese auch wieder abgreifen können. Je nachdem Welches der obigen Beispiele Du verwendest, sieht die Vorgehensweise eigentlich immer gleich aus (auch bei CanExecute):

' rest of the ViewModel-Class (like MainViewModel)

' the "parameter" contains everything, but combined in one thing
Public Sub Login(parameter As Object)
    ' if it looked like this in the XAML:
    ' CommandParameter="D"
    Dim passedLetter = Convert.ToString(parameter)
    ' now there's the letter D inside passedLetter

    '' if it was a custom class
    Dim yourParam = CType(parameter, SpecialCmdParams)

    '' if it was the DoubleNumberConverter - you now have :
    Dim numbersAsStrings = Convert.ToString(parameter).Split("|")
    ' do conversion, whatever
End Sub

' rest of the ViewModel-Class

public void Login(object parameter)
{
    // if it looked like this in the XAML:
    // CommandParameter="D"
    var passedLetter = Convert.ToString(parameter);
    // now there's the letter D inside passedLetter

    // // if it was a custom class
    var yourParam = (SpecialCmdParams)parameter;

    // // if it was the DoubleNumberConverter - you now have :
    var numbersAsStrings = Convert.ToString(parameter).Split("|");
}

Downloads

Lade Dir hier gerne das Beispielprojekt (oder einzelne Bestandteile) in der Sprache Deiner Wahl herunter, da der Beitrag natürlich anhand des Themas ein wenig riesig ist. So kannst Du Dich spielerisch an die einzelnen Punkte wagen und begleitend mit dem Beitrag arbeiten. Die einzelnen Dinge beinhalten jeweils die Dateien für beide Sprachen.

WpfCommandsExampleVbTutorial.zip

WpfCommandsExampleCsTutorial.zip

DelegateCommand.zip

PropertyChangedBase.zip

Der Beitrag Eigene WPF Commands in MVVM VB.NET & C# – der 2024 Guide erschien zuerst auf Robert Skibbe.

VB NET MouseClick simulieren – mit AutoIt3

Robert Skibbe — Sat, 02 Oct 2021 18:14:30 +0000

VB.NET MouseClick simulieren

VB NET MouseClick simulieren

Einen VB NET MouseClick simulieren zu können wollte vermutlich jeder Entwickler schon einmal.

Ich würde sogar sagen, jeder Gamer sowieso, denn wer hat schon Lust auf die typische „Monkey-Work“.

Zig tausend mal die gleichen Dialoge in exakter Reihenfolge zu bestätigen und sich mühselig manuell durchzuklicken.

Also echt mal, da hat doch keiner Bock drauf, seufz, jedenfalls aller spätestens beim 2, 3, .. Mal.

Natürlich treffen wir ähnliche Bedürfnisse und Probleme auch im Büroalltag an, Excel, usw. lassen lieb grüßen.

Ein Glück, dass man (angehender) Entwickler ist, gell 😉!

Auf YouTube ansehen – VB NET MouseClick simulieren

Falls Du eher für eine visuelle Darstellung des Beitrages zu haben bist, kannst Du Dir natürlich auch das Video (vielleicht auch ergänzend zum Beitrag) anschauen.

Bei meinen Beiträgen bringe ich gerne auch immer diverse Detail-Infos, oder andere Dinge hinein.

Leider fehlt mir dazu oft in den Videos die Zeit, da ich denke, dass man einen Beitrag einfacher durchscrollen kann.

Vor allem den Beitrag sinnvoll zu gliedern ist denke ich einfacher, als durch ein Video zu zappen.

Immerhin hat YouTube seit geraumer Zeit eine Art Kapitelübersicht hinzugefügt, Welche ich auch gern verwende.

Die Idee zum Beitrag – VB NET MouseClick

VB NET MouseClick – Die Idee zum Beitrag

Man möchte sich im Optimalfall natürlich selbst helfen können und besonders auch zukunftsorientiert.

Gerne hätte man eine Art Hilfe in Form einer Person, der man dann einfach sagen könnte „Mach das mal..“.

Als Programmierer können wir uns kreativen Köpfen selbstverständlich selbst unter die Arme greifen, man weiß nur nicht immer wie.

Daher lass‚ mich Dir mit diesem kleinen Beitrag helfen und zeigen, wie Du einen VB NET MouseClick mit der Hilfe von AutoIt3 durchführen kannst.

Dadurch kannst Du dann verschiedene Tools wie diverse Klicker–Bots realisieren und Dir Deinen Alltag erleichtern.

Nicht ohne mein AutoIt

Mit Hilfe von AutoIt

Naja etwas witzig angelehnt die Headline hier, aber tatsächlich werden wir dieses kleine Geplänkel nicht ohne AutoIt3 realisieren.

Klar gibt es auch die Möglichkeit in VB NET einfach ich nenne es mal „manuell“ einen Mausklick zu simulieren, aber ich find’s hier mit AutoIt3 definitiv angenehmer.

Wie auch im „ImageSearch“-Beitrag schon angesprochen gehen viele Entwickler kritisch mit der Speichergröße der Projekte um.

Das kann ich natürlich nachvollziehen, da ich selbst ein Freund des Minimalismus bin, jedoch kann man die Kirche auch im Dorf lassen.

Ich würde mit Sicherheit in Festplatten–Generation „Terrabyte zum Preis von damaligen 80GB“ nicht anfangen für 1MB rumzunörgeln.

Letztendlich muss man ja immer den möglichen Mehrwert in Relation zur Eigenarbeit sehen.

Später kannst Du bei einem intelligent strukturierten Programm natürlich bedürftige Komponenten isoliert austauschen.

Projekt in Visual Studio vorbereiten

Neues Visual Studio Projekt anlegen und vorbereiten

Lade Dir jetzt die benötigten Bibliotheken direkt hier herunter, oder suche alternativ nach anderen Quellen im Netz.

Danach kannst Du wie üblich ein neues Windows Forms-, oder auch ein WPF-Projekt anlegen.

Lege die „AutoItX3.Assembly.dll„-Datei nun als Verweis an, damit dein Projekt damit arbeiten kann.

Ganz einfach geht das zum Beispiel rechts über den Projektmappen-Explorer in Visual Studio.

Führe dazu einfach einen rechten Mausklick auf „Verweise/Abhängigkeiten“ aus und wähle die Datei aus.

Neben dem Weg über den Projektmappen–Explorer gibt es auch noch andere Möglichkeiten.

Kopiere anschließend alle anderen Dateien (außer die ImageSearchDLL.dll) in den Debug-Ordner deines Projekts.

Die oben erwähnte Datei dürfte sich aufgrund des Imports schon im Ordner befinden.

Nun zum Code – VB NET MouseClick

Sehen wir uns im nächsten Schritt den benötigten Code im Detail an.

Wenn Du alle vorherigen Schritte abgeschlossen hast, kannst Du nun den korrekten Import durchführen:

Imports AutoIt

Damit wird im aktuellen Scope die „AutoItX“-Klasse verfügbar, womit wir im nächsten Part den Klick realisieren können.

Zuvor kannst Du Dir allerdings noch eine solche (oder ähnliche) GUI zurechtklicken – relativ simpel.

Füge einfach nur 2 Labels, 2 Textboxen und einen Button hinzu:

VB.NET MouseClick simulieren Beispiel-GUI

Die 2 Labels sollen einfach nur ein wenig fürs Auge klar machen, welche Inputs, wo hinein müssen.

Bei den Textboxen handelt es sich um Eingabefelder für die Koordinaten, allerdings verzichten wir hier im Code auf Prüfungen.

Wir werden also der Einfachheit halber nicht weiter überprüfen, ob es sich bei den Eingaben um Zahlen handelt, bzw. ob etwas eingegeben wurde.

Nun ziehen wir die Koordinaten aus den Textboxen und wandeln Diese dann in Ganzzahlen vom Typ Integer um:

Dim x = Integer.Parse(tbX.Text)
Dim y = Integer.Parse(tbY.Text)

Danach können wir dann die wichtige und essentielle AutoIt3-Funktion namens „MouseClick“ verwenden:

AutoItX.MouseClick("LEFT", x, y, 1, 50)

MouseClick-Parameter

Die möglichen Parameter möchte ich hier einmal näher erläutern:

Weitere Informationen findest Du in der offiziellen Dokumentation von AutoIt.

button As String

Hier können wir den gewünschten Button als String übergeben, mögliche Werte sind: „“ (leer), „LEFT“, „MIDDLE“, „RIGHT“, „PRIMARY“, „MAIN“, „SECONDARY“, „MENU“. Wenn ein leerer String übergeben wird, wird automatisch die linke Maustaste verwendet.

x As Integer

Gibt den Koordinaten-Punkt des Klicks auf der horizontalen (X) Achse an.

y As Integer

Setzt die Koordinate des auszuführenden Klicks auf der vertikalen (Y) Achse.

numClicks As Integer

Legt die Anzahl der durchzuführenden Klicks an den Koordinaten fest.

speed As Integer

Gibt die Geschwindigkeit der durchzuführenden Klicks an.

Der komplette Code – TL;DR

Es ist zwar nicht viel, oder gar komplexer Code, aber hier siehst Du Ihn in einem Stück – vielleicht für die „TL;DR“-guys haha.

Imports AutoIt

Public Class Form1

    Private Sub btnExecuteClick_Click(sender As Object, e As EventArgs) Handles btnExecuteClick.Click
        Dim x = Integer.Parse(tbX.Text)
        Dim y = Integer.Parse(tbY.Text)
        AutoItX.MouseClick("LEFT", x, y, 1, 50)
    End Sub

End Class

Weiterführende Links

Downloads

AutoItPackage.zip

MouseClickExample.zip

Der Beitrag VB NET MouseClick simulieren – mit AutoIt3 erschien zuerst auf Robert Skibbe.

VB.NET Button Beispiel

Robert Skibbe — Tue, 29 Jun 2021 19:12:57 +0000

VB.NET Button Beispiel

In meinem VB.NET Button Beispiel lernst Du alles Wichtige über das Button-Steuerelement.

Falls Du mit dem Button in VB.NET schon Deine ersten Erfahrung gemacht hast, könnte der Beitrag über die manuelle Auslösung des Click-Events für Dich von Interesse sein.

Der Button, wohl eines der wichtigsten Steuerelemente in der Welt der Programmierung – so auch in VB.NET.

Los geht’s

Ziehe um loszulegen ein Button-Steuerelement aus der Toolbox auf die Form.

Alternativ kannst Du den Button in der Toolbox auch doppelklicken.

VB.NET Button auf die Form ziehen

Sobald sich der Button auf der Form befindet, können wir mit dem Styling beginnen – falls gewünscht natürlich!

Eigenschaften – VB.NET Button Beispiel

Im folgenden Teil gehe ich näher auf die einzelnen Eigenschaften der Kategorie nach ein.

Essentiell

Name

Sicherlich eine der wichtigsten Eigenschaften aller Controls.

Sie bestimmt wie wir das jeweilige Control im Code ansprechen und kann natürlich einerseits als Orientierungshilfe und andererseits als prägnante Beschreibung dienen.

Nachdem Du ein Control auf die Form gezogen hast, sollte Dein erster Schritt immer sein, dem Control einen passenden Namen zu geben.

Enabled

Bestimmt, ob das Steuerelement aktiviert ist.

Styling

Schauen wir uns nun einmal die – wichtigsten – Styling bezogenen Eigenschaften des Buttons an.

Anchor

Wie bei jedem Steuerelement, Welches von der Basisklasse Control erbt, können wir auch hier die Ausrichtung des Buttons bestimmen.

AutoSize

Diese Eigenschaft hilft uns dabei, die Größe des Buttons automatisch bei Textänderung anzupassen.

Das kann natürlich besonders dann von Vorteil sein, wenn sich der Text des Buttons während der Laufzeit verändert.

BackColor

Mit dieser Eigenschaft können wir die Hintergrundfarbe des Buttons bestimmen.

BackgroundImage

Hier können wir ein Bild für den Hintergrund des Buttons festlegen.

FlatAppearance

In Kombination mit der FlatStyle-Eigenschaft auf Flat gesetzt, können wir hier weitere Design-Möglichkeiten erreichen.

FlatStyle

Bestimmt die Art der Darstellung des Buttons. Siehe auch die FlatAppearance.

ForeColor

Legt die Schriftfarbe innerhalb des Buttons fest.

Image

Damit können wir wie in vielen Programmen üblich ein Bild für den Button festlegen.

Size

Die Size-Eigenschaft bestimmt die Größe des Buttons.

Text

Hiermit können wir den Text innerhalb des Buttons festlegen.

Visible

Damit können wir bestimmen, ob der Button sichtbar ist.

Das Click-Ereignis – VB.NET Button Beispiel

Das Haupt-Ereignis worum sich beim Button so gut wie alles dreht.

Was passiert, wenn man auf den Button klickt, kann man mit einem passenden Ereignishandler zu diesem Ereignis festlegen.

Wenn es schon um ein VB.NET Button Beispiel geht, dann auch um das Click-Ereignis 🤓!

Ein Beispiel-Ereignishandler

Hier findest Du einen Beispiel-Ereignishandler:

Private Sub btnSayHello_Click(sender As Object, e As EventArgs) Handles btnSayHello.Click
    ' write what should happen next
End Sub

Dort drin bestimmst Du, was passieren soll, wenn auf den Button geklickt wird, bzw. genauer genommen, wenn der Button sein Click-Ereignis auslöst.

Code – VB.NET Button Beispiel

Da es sich bei diesem Beitrag ein vor allem an Anfänger gerichtetes Beispiel handelt, beginne ich bei den kompletten Basics.

Den Button mit Code versehen

Um den Button mit Code zu versehen, sprich das was passiert, wenn man darauf zum Beispiel klickt, etc. gibt es 3 gängige Möglichkeiten.

Die vierte und mir erstmals gerade zuletzt – 😂 – einfallende Möglichkeit stelle ich im Beitrag VB.NET Button zur Laufzeit erstellen vor.

Über Doppelklick im Designer

Die vermutlich einfachste Methode für Beginner ist es, den Button im Designer doppelt anzuklicken.

Dadurch kommen wir in das – ich nenne es immer gerne – Haupt-Event des jeweiligen Controls.

VB.NET Button im Designer doppelklicken um Klick-Ereignishandler zu generieren

Mit dem Doppelklick generiert uns Visual Studio automatisch einen passenden Ereignishandler in Form von einer Sub – verknüpft an das Ereignis mit dem Handles-Schlüsselwort.

Via Dropdown im Designer

Eine nächste Möglichkeit wäre die Generierung des Handlers über die Dropdowns im Designer.

Klicke dafür den Button an, um Ihn auszuwählen und schaue anschließend rechts in die Eigenschaften.

Oben im Eigenschafts-Fenster siehst Du einen kleinen Blitz, klicke Ihn an und suche nach dem Click-Ereignis, mache dann einen Doppelklick in die leere Zelle daneben.

VB.NET Button Click Event via Designer Dropdown generieren

Per Dropdown in der Code-Ansicht

Folgende und vorerst letzte Möglichkeit verwende ich gerne, wenn ich mich gerade sowieso in der Code-Ansicht aufhalte.

Gehe dazu im Designer auf die zweite ComboBox, oben in der Mitte des Bildschirms (zumindest wenn Du ein Steuerelement der aktuellen Form bearbeiten möchtest!).

Wähle anschließend das Ereignis aus, Welches Du mit Code versehen, bzw. wofür Du einen Ereignishandler generieren möchtest.

VB.NET Button Click Event via Code Dropdowns generieren

Handler-Code hinzufügen

Nun, da wir den Handler für den Button auf eine der beschriebenen Art generiert haben, können wir endlich „tatsächlichen Code“ hinzufügen.

Um weiterhin einfach zu bleiben fügen wir die Anzeige einer simple MessageBox hinzu.

Mehr als einen Handler

Was vor allem viele Anfänger nicht wissen ist, dass es nicht in Stein gemeißelt ist, bei einem Handler zu bleiben.

Wir können dem Click-Ereignis des Buttons auch ohne Probleme mehrere Ereignishandler der gleichen Signatur – dem gleichen Aufbau der Methode – hinzufügen.

Kompletter Code – VB.NET Button Beispiel

Hier findest Du den Code zu meinem VB.NET Button Beispiel:

Mit nur einem Ereignishandler

Public Class Form1
    Private Sub btnSayHello_Click(sender As Object, e As EventArgs) Handles btnSayHello.Click
        MessageBox.Show("Hallo Welt!")
    End Sub
End Class

Mit mehr als einem Ereignishandler

Public Class Form1
    Private Sub btnSayHello_Click(sender As Object, e As EventArgs) Handles btnSayHello.Click
        MessageBox.Show("Hallo Welt!")
    End Sub
    Private Sub btnSayHello2_Click(sender As Object, e As EventArgs) Handles btnSayHello.Click
        MessageBox.Show("Hallo Welt! 2")
    End Sub
End Class

Downloads

Button Example

Der Beitrag VB.NET Button Beispiel erschien zuerst auf Robert Skibbe.

VB.NET Button Click auslösen

Robert Skibbe — Tue, 29 Jun 2021 13:09:55 +0000

VB.NET Button Click auslösen

In diesem Beitrag erkläre ich Dir, wie Du in VB.NET ein Button Click auslösen kannst – und zwar via Code!

Falls Du noch gar nicht mit dem Button-Steuerelement gearbeitet hast, kannst Du Dir unter folgendem Link meinen allgemeinen Beitrag zum Button Beispiel anschauen.

Wie Du in VB.NET einen Button zur Laufzeit erstellst, kannst Du in diesem Beitrag hier lernen.

Wir waren alle schonmal da

Ich glaube jeder .NET Entwickler kam zu Beginn seiner Entwickler-Karriere irgendwann an diesen Punkt.

Man hat etwas Tolles in seinen Button gecoded und es lief rund und ohne Fehler.

Nun kommt der Punkt, an dem man diese Funktionalität – versteckter Tipp löl – nun von anderer Stelle aus aufrufen möchte.

Kreative Spielereien

Im Laufe meiner Tätigkeit als Softwareentwickler im Bereich von VB.NET habe ich schon so Einiges gesehen.

Ein lustiges Beispiel war ein völliger VB.NET-Anfänger – daher seid in Gedanken nicht zu hart zu Ihm –, Welcher per codeorientierter Mausbewegung, etc. einen Button anklicken wollte 😂.

Zum Glück muss man nicht auf solche wirklich komplizierte Methoden zurückgreifen, wo kämen wir denn da hin!

Sei gewarnt

Ich möchte an dieser Stelle schonmal direkt den Spoiler erwähnen, dass das, was Du vorhast, nicht das Gelbe vom Ei ist!

Sei gewarnt

Schreib Dich nicht ab, lern‘..

Ebenfalls möchte ich Dir hier aber keinen Vorwurf machen, denn Du wusstest es vermutlich einfach nicht besser, als Du danach gesucht hast.

Ich selbst kenne diese Problematik aus meiner Anfangszeit als .NET-Entwickler!

Selbstverständlich bin ich froh, dass Dich Deine Suche auf meine Seite und somit zu mir geführt hat 😊.

Meine Erfahrung – häufige Billligung

Umso lustiger wird es – zumeist – nachher, wie man den Wald vor lauter Bäumen nicht sehen konnte.

Manchmal ist es leider jedoch nicht unbedingt so lustig, vor allem, wenn gewisse Aktionen Folgen in: Wartung, Verständnis und mehr nach sich ziehen.

„Leider“ musste ich schon oft die Erfahrung machen, dass ehemalige Nachhilfe-Schüler, Internetforen-Nutzer, jedoch auch Kunden, etc. bewusst den falschen Weg wählten.

Oft hieß es: „Ja, ich weiß, dass das so nicht gut ist, aber das ist jetzt einfacher so!“

Code – VB.NET Button Click auslösen

Vorwort

Um das Beispiel nicht zu verkomplizieren habe ich auf tiefgehendere Sachen wie die z. B. die Dependency-Injection verzichtet.

Das Beispiel dürfte ohnehin Aufgrund der zusätzlichen Klassen für Anfänger schon etwas schwieriger sein.

Insgesamt hängt das natürlich vom individuellen Fortschritt in VB.NET und dem Verständnis dafür ab.

Manueller Aufruf der Handler-Sub – Erster Anlauf

Der erste deinerseits versuchte Anlauf könnte ungefähr wie folgt, ausgesehen haben, bzw. aussehen.

Du versuchst die Dir bekannte Sub des Button-Click Ereignishandlers einfach händisch, also via Code aufzurufen.

btnSearchBills_Click()

Doch während Du die Zeile fast fertig tippst, fällt Dir vermutlich auf, dass da was fehlt 🙈.

Die Sub, die Du aufrufen wolltest, erwartet nämlich zwei Parameter, Welche Dich eventuell vor die Frage stellen: „Wo bekomme ich Diese her?“.

sender As Object, e As EventArgs

In der Theorie ist die „Lösung“ ganz einfach – zumindest, wenn man weiß wie 😂:

sender As Object

Der „sender“ ist ja letztendlich nichts anderes, als das Objekt, Welches das Ereignis ausgelöst hat, worauf der Ereignishandler dann reagiert.

Da wir ja wissen, dass der Button letztendlich das Ereignis auslösen würde, können wir Diesen ja schonmal übergeben und machen somit Signatur-technisch nichts verkehrt.

e As EventArgs

Der andere fehlende Parameter, also der Zweite, ist da etwas komplizierter, obwohl ich auch schon beim Ersten sagen kann: „Wenn Du schon beim Sender auf die Lösung gekommen bist – Respekt!“

Die EventArgs-Klasse bietet ein „Shared-Readonly-Feld“ namens „Empty“ an.

Wie der Name schon verrät, handelt es sich bei dem dahinterstehenden „Wert“ praktisch um „leere EventArgs„, Welche wir dann mitliefern können, falls wir keine Event-Daten an sich benötigen.

btnSearchBills_Click(btnSearchBills, EventArgs.Empty)

PerformClick – Der einfache Ansatz

Im Endeffekt müssen wir es uns gar nicht so kompliziert wie oben machen.

Das Rumschlagen mit Parametern und das manuelle Aufrufen der Ereignishandler-Sub ist nicht notwendig, da der Button von Haus aus eine Möglichkeit bietet.

Die Methode, die wir suchen heißt *Trommelwirbel*: PerformClick:

btnSearchBills.PerformClick()

VB.NET Button Click auslösen – Der Richtige Ansatz

Im letzten und größten Abschnitt des Beitrages, kommen wir zum „richtigen“ Ansatz.

Ich halte die vorherigen Ansätze für einen schlechten Stil, bzw. für falsch, weil Sie meiner Meinung nach falsche Absichten widerspiegeln.

Wenn man möchte, dass ein Button Click via Code ausgelöst wird, dann möchte man nicht wirklich den Button auslösen, sondern den Code, der dahinter steckt!

Benötigte Steuerelemente

DataGridView

In dem DataGridview zeigen wir die für das Beispiel genutzten Testdaten in Form von Rechnungsdaten an.

2 Labels

Um die Textboxen optional mit Informationen zu bestücken

TextBox

Eine Textbox für die Suche nach einer Rechnung via Id.

TextBox

Dann noch eine weitere Textbox für die Suche nach Rechnungen via Kunden-Name.

Button

Einen Button für den Reset der Suchfelder

Button

Die Suchfunktion auszulösen wird von diesem Button gesteuert.

Eigenschaften

billService

Der Rechnungsservice ist – wie für Services bei Dependency Injection üblich, aber in diesem Fall nicht verwendet – eine „Private Property“.

Bills

Bei „bills“ handelt es sich um die Rechnungsdaten, die wir für dieses Beispiel testweise erstellen, laden und anzeigen werden.

Konstruktoren

New

Wir brauchen in unserem Fall nur den Standard-Konstruktor, Welchen wir für die Vorbereitung unseres Services und z. B. dem DataGridView nutzen.

Sub New()
    InitializeComponent()
    ' should be done with dependency injection like things
    ' just for displaying puporses..
    billService = New BillService()
    Bills = New List(Of Bill)
    ConfigureBillDataGrid()
End Sub

Methoden

ConfigureBillDataGrid

Ich denke diese Methode ist relativ selbsterklärend.

Private Sub ConfigureBillDataGrid()
    With dgvBills
        .AllowUserToAddRows = False
        .AllowUserToDeleteRows = False
        .AllowUserToResizeRows = False
        .AllowUserToOrderColumns = False
        .AllowUserToResizeColumns = False
        .ReadOnly = True
        .SelectionMode = DataGridViewSelectionMode.FullRowSelect
        .BackgroundColor = Color.White
        .RowHeadersVisible = False
        ' columns being added in visual designer..
    End With
End Sub

btnSearchBills_Click

Das ist die Click-Ereignishandler-Sub für den Button.

Private Sub btnSearchBills_Click(sender As Object, e As EventArgs) Handles btnSearchBills.Click
    SearchBills()
End Sub

SearchBills

Das ist der Star des Tages, denn diese Sub ist die letztendliche Alternative zum „Button.PerformClick()“.

ShowBillsInDataGrid

Hier kommt der Code rein, der notwendig ist, um die Rechnungen anzuzeigen.

Private Sub ShowBillsInDataGrid(bills As List(Of Bill))
    ' could/should be done with BindingList which supports AddRange
    ' but thats part of another tutorial :)
    ' so this is it for now
    dgvBills.DataSource = Nothing
    Me.Bills.Clear()
    Me.Bills.AddRange(bills)
    dgvBills.DataSource = Me.Bills
End Sub

btnClearSearchFields_Click

Das ist der Ereignishandler für das Klick-Ereignis des Reset-Buttons für die Suchfelder.

Private Sub btnClearSearchFields_Click(sender As Object, e As EventArgs) Handles btnClearSearchFields.Click
    tbBillId.Clear()
    tbBillCustomer.Clear()
    ' or
    ' tbBillCustomer.Text = ""
End Sub

SearchBox_KeyDown

Das ist die Methode, die auf die KeyDown-Ereignisse der 2 Suchfelder reagiert.

Wenn in einem der Suchfelder die Escape-Taste gedrückt wird, nehmen wir das als Befehl dafür, dass die Felder zurückgesetzt werden sollen.

Bei der Verwendung der Enter-Taste, lösen wir die Suche der Rechnungen erneut aus.

Private Sub SearchBox_KeyDown(sender As Object, e As KeyEventArgs) Handles tbBillId.KeyDown, tbBillCustomer.KeyDown
    If e.KeyCode = Keys.Escape Then
       Dim theTextBox = CType(sender, TextBox)
       theTextBox.Clear()
    ElseIf e.KeyCode = Keys.Enter Then
        SearchBills()
    End If
End Sub

Bill-Klasse

Diese Klasse spiegelt eine einzelne Rechnung wieder.

Die Id ist denke ich selbstredend..

Der Customer wurde hier bewusst als String, statt als Objekt gewählt, um das Beispiel einfacher zu halten und den Fokus nicht zu verschieben.

Public Class Bill

    Public Property Id As Integer

    ' should be an object but for this example, made easier
    Public Property Customer As String

    Sub New()

    End Sub

    Sub New(id As Integer)
        Me.Id = id
    End Sub

    Sub New(id As Integer, customer As String)
        Me.Id = id
        Me.Customer = customer
    End Sub

End Class

BillService-Klasse

Diese Klasse spiegelt einen Service für die Aktionen bezüglich der Rechnungen wieder.

Wenn eine neue Instanz der BillService-Klasse erzeugt wird, lade ich im Konstruktor deren Testdaten, ansonsten würden Diese natürlich aus einer Datenbank o. Ä. kommen.

Sie bietet eine Funktion an, um eine Rechnung via Id zu suchen.

Zusätzlich gibt es eine Funktion, um Rechnungen anhand des Kundennamens zu finden.

Um die Parameter dynamisch zu halten, habe ich ein Dictionary verwendet.

Wenn in Diesem ein Schlüssel namens „customer“ drin ist, wird der dahinter stehende Wert als Such-Name verwendet – Großschreibung nicht beachtend.

Public Class BillService

    Private bills As List(Of Bill)

    Sub New()
        bills = New List(Of Bill)
        MockupData()
    End Sub

    Private Sub MockupData()
        With bills
            .Add(New Bill(1, "John Doe"))
            .Add(New Bill(2, "Jane Doe"))
            .Add(New Bill(3, "Maximilian Maximum"))
            .Add(New Bill(4, "Jesus Christ"))
            .Add(New Bill(5, "Michael Jackson"))
        End With
    End Sub

    Public Function FindById(id As Integer) As Bill
        Return bills.SingleOrDefault(Function(x) x.Id = id)
        '' or the selfmade long version:
        'For Each bill In bills
        '    If bill.Id = id Then
        '        Return bill
        '    End If
        'Next
        'Return Nothing
    End Function

    Public Function FindAllBy(criteria As Dictionary(Of String, String)) As List(Of Bill)
        Dim filteredBills = New List(Of Bill)
        ' first put all in
        filteredBills.AddRange(bills)
        ' filter for example by name 
        If criteria.ContainsKey("customer") Then
            Dim customer = criteria.Item("customer").ToLower()
            filteredBills = filteredBills.Where(Function(x) x.Customer.ToLower().Contains(customer)).ToList()
        End If
        ' add more filtering..
        Return filteredBills
    End Function

End Class

Der komplette Code – VB.NET Button Click auslösen

In diesem Abschnitt findest du den kompletten Code zum Thema: VB.NET Button Click auslösen.

Public Class Form1

    Private Property billService As BillService

    Public Property Bills As List(Of Bill)

    Sub New()
        InitializeComponent()
        ' should be done with dependency injection like things
        ' just for displaying puporses..
        billService = New BillService()
        Bills = New List(Of Bill)
        ConfigureBillDataGrid()
    End Sub

    Private Sub ConfigureBillDataGrid()
        With dgvBills
            .AllowUserToAddRows = False
            .AllowUserToDeleteRows = False
            .AllowUserToResizeRows = False
            .AllowUserToOrderColumns = False
            .AllowUserToResizeColumns = False
            .ReadOnly = True
            .SelectionMode = DataGridViewSelectionMode.FullRowSelect
            .BackgroundColor = Color.White
            .RowHeadersVisible = False
            ' columns being added in visual designer..
        End With
    End Sub

    Private Sub btnSearchBills_Click(sender As Object, e As EventArgs) Handles btnSearchBills.Click
        SearchBills()
    End Sub

    Private Sub SearchBills()
        Dim givenIdText = tbBillId.Text.Trim()
        Dim billId As Integer
        Dim bills As List(Of Bill) = New List(Of Bill)
        If Integer.TryParse(givenIdText, billId) Then
            Dim bill = billService.FindById(billId)
            If bill IsNot Nothing Then
                bills.Add(bill)
            End If
            ShowBillsInDataGrid(bills)
            ' OpenDetailForm() – Maybe?
            Return
        End If

        Dim searchCriteria = New Dictionary(Of String, String)

        Dim customerName = tbBillCustomer.Text.Trim()
        If Not String.IsNullOrWhiteSpace(customerName) Then
            searchCriteria.Add("customer", customerName)
        End If

        Dim searchResults = billService.FindAllBy(searchCriteria)
        bills.AddRange(searchResults)
        ShowBillsInDataGrid(bills)
    End Sub

    Private Sub ShowBillsInDataGrid(bills As List(Of Bill))
        ' could/should be done with BindingList which supports AddRange
        ' but thats part of another tutorial :)
        ' so this is it for now
        dgvBills.DataSource = Nothing
        Me.Bills.Clear()
        Me.Bills.AddRange(bills)
        dgvBills.DataSource = Me.Bills
    End Sub

    Private Sub btnClearSearchFields_Click(sender As Object, e As EventArgs) Handles btnClearSearchFields.Click
        tbBillId.Clear()
        tbBillCustomer.Clear()
        ' or
        ' tbBillCustomer.Text = ""
    End Sub

    Private Sub SearchBox_KeyDown(sender As Object, e As KeyEventArgs) Handles tbBillId.KeyDown, tbBillCustomer.KeyDown
        If e.KeyCode = Keys.Escape Then
            Dim theTextBox = CType(sender, TextBox)
            theTextBox.Clear()
        ElseIf e.KeyCode = Keys.Enter Then
            SearchBills()
        End If
    End Sub

End Class

Public Class Bill

    Public Property Id As Integer

    ' should be an object but for this example, made easier
    Public Property Customer As String

    Sub New()

    End Sub

    Sub New(id As Integer)
        Me.Id = id
    End Sub

    Sub New(id As Integer, customer As String)
        Me.Id = id
        Me.Customer = customer
    End Sub

End Class

Public Class BillService

    Private bills As List(Of Bill)

    Sub New()
        bills = New List(Of Bill)
        MockupData()
    End Sub

    Private Sub MockupData()
        With bills
            .Add(New Bill(1, "John Doe"))
            .Add(New Bill(2, "Jane Doe"))
            .Add(New Bill(3, "Maximilian Maximum"))
            .Add(New Bill(4, "Jesus Christ"))
            .Add(New Bill(5, "Michael Jackson"))
        End With
    End Sub

    Public Function FindById(id As Integer) As Bill
        Return bills.SingleOrDefault(Function(x) x.Id = id)
        '' or the selfmade long version:
        'For Each bill In bills
        '    If bill.Id = id Then
        '        Return bill
        '    End If
        'Next
        'Return Nothing
    End Function

    Public Function FindAllBy(criteria As Dictionary(Of String, String)) As List(Of Bill)
        Dim filteredBills = New List(Of Bill)
        ' first put all in
        filteredBills.AddRange(bills)
        ' filter for example by name 
        If criteria.ContainsKey("customer") Then
            Dim customer = criteria.Item("customer").ToLower()
            filteredBills = filteredBills.Where(Function(x) x.Customer.ToLower().Contains(customer)).ToList()
        End If
        ' add more filtering..
        Return filteredBills
    End Function

End Class

Downloads

SimulateButtonClick Example

Der Beitrag VB.NET Button Click auslösen erschien zuerst auf Robert Skibbe.