Daten in ein VB NET DataGridView füllen

Willkommen zum heutigen Beitrag „VB NET DataGridView füllen„!

Tja da sind wir am heutigen Tage wieder mit einer neuen Problemstellung, willkommen zurück 😛!

Du möchtest also in Visual Basic NET das typische Tabellen-Steuerelement namens DataGridView mit Daten füllen!?

Dann lass uns auch gleich schon direkt loslegen!

Die erste sich stellende Frage an dieser Stelle ist natürlich die goldene Frage Nr. 1.

Frage Dich also zurst: „Woher kommen meine Daten!?“ – Aus einer Datenbank? Aus einer Textdatei!?

Nur zur Darstellung!

Wie eigentlich immer, sind die Steuerelemente natürlich nur zur letztendlichen visuellen Darstellung da.

Sie selbst sollten für gewöhnlich keine Daten „darstellen“ – wenn Du verstehst was ich meine!

Besonders in anderen Sprachen und „Stacks“ wie z. B. WPF wirst Du diese Herangehensweise kennen- und lieben lernen.

Denke an das Beispiel anhand einer simplen TextBox, Welche einen Vornamen verarbeitet:

Wenn Du einen Vornamen in Deinem Programm verarbeitest, dann sollte nicht die TextBox diesen Vornamen widerspiegeln!

Letztendlich wäre es gut, wenn Du eine dahinter geschaltete Eigenschaft hast, Welche dann den Vornamen beinhaltet.

Die TextBox wird lediglich angewiesen, diesen Vornamen visuell darzustellen.

Sie sagt praktisch: „Hey guck mal, das befindet sich im Hintergrund in den Daten“.

Was Sie allerdings nicht sagen sollte ist: „Ich >bin< die Daten„!

So sollte es auch bei fast allen anderen Steuerelementen und im Optimalfall auch dem DataGridView als Tabelle sein.

Der gute alte Weg – Ein VB NET DataGridView füllen

Kommen wir im ersten Beispiel zum „guten alten Weg„, Welcher es eigentlich nicht ist, also gut..

Warum „er“ dennoch als „gut“ bekannt ist? Naja, weil es wie immer die Routine der Menschen ist, Welche etwas als „gut“ betitelt.

Man ist es durchaus als Anfänger gewohnt, dem DataGridView direkte Kommandos via „Items“-Auflistung zu geben.

Dies kommt – zu meinem Bedauern – viel zu häufig vor, leider ist es nicht so toll, wie es einfach erscheint.

Was Objekte gemeinsam haben..

Das funktioniert deshalb so einfach, weil die „Items“-Auflistung vom Typ „DataGridViewRowCollection“ ist.

Und naja was soll ich sagen, daher ist die Auflistung eine Zusammensetzung aus einzelnen „DataGridViewRows„.

Diese einzelnen Reihen sowie die Auflistung als solches haben somit wie jede Objekt-Instanz:

• Eigenschaften
• Methoden (Funktionen, Subs)
• Ereignisse
• …

Schaue Dir also für das erste Beispiel die Methoden der „DataGridViewRowCollection“-Klasse an.

Dort finden wir die verschiedenen „Add„-Methoden, Welche – wie der Name schon sagt – für das Hinzufügen zuständig ist.

DataGridView zusammenbauen

Bevor wir im ersten Beispiel nun Daten einfügen können, müsstest Du zuerst noch ein DataGridView anlegen.

Erstelle also nun im nächsten Schritt das DataGridView, Welches dann gleich mit Daten gefüllt wird.

Nimm gerne dieses hier als Beispiel:

Beachte jedoch, dass ich wie fast immer folgende Eigenschaften gesetzt habe.

Diese benötige ich persönlich fast in 95% der Projekte..

• AllowUserToAddRows – False
• AllowUserToDeleteRows – False
• AllowUserToResizeRows – False
• AlternatingRowsDefaultCellStyle – BackgroundColor auf LightGray
• BackgroundColor – White
• Dock – Fill
• MultiSelect – False
• ReadOnly – True
• RowHeadersVisible – False
• SelectionMode – FullRowSelect
• ..und dann noch die obigen Spalten!

Daten/Reihen hinzufügen

Schauen wir uns nun die verschiedenen Überladungen der „Add“-Methode an.

Ich werde hier natürlich nicht alle durchgehen, da Du Sie ja in der obigen Dokumentation ansehen kannst.

Folgende ist allerdings die meiner Meinung nach für dich – im ersten Beispiel – die Interessanteste Überladung:

• Add(Object[])

Wie Du anhand der Signatur erkennen kannst, möchte diese Überladung ein (param) Array von Objekten.

Durch die spezielle Definition müssen wir auch nicht erst ein Array erstellen und Werte einfügen.

Stattdessen können wir die Werte direkt getrennt durch Kommas auflisten.

Hardcoded

Passend zu unserem designten DataGridView würde das Hinzufügen von Daten also so aussehen:

dgvArticles.Rows.Add(1, "Article 1", "KG", 9.95, 16.49, 50)

Natürlich könnte man das auch in einer Schleife aufrufen.

Obwohl das zumindest in diesem Beispiel nicht den größten Sinn macht, zeige ich es trotzdem mal.

Wir fügen einfach mal 5 Einträge durch eine zählergesteuerte Schleife hinzu.

Dabei benutze ich meine sehr gemochte „String–Interpolation“ (mit dem Dollar-Zeichen).

Damit kann ich die Strings ein wenig einfacher zusammenbauen, als ständig „&…“ zu benutzen.

Als Schleife – Beispiel

For i = 1 To 5
    dgvArticles.Rows.Add(i, $"Article {i}", "KG", 9.95, 16.49, 50)
Next

Ich meine normalerweise müssten die Einträge vermutlich sowieso von einer Art Datenquelle kommen.

Ob man nun eine Datenbank, eine Textdatei, oder sonstige Dinge verwendet..

Aus einem Dialog heraus

Nun wird es hier schon ein wenig interessanter, da wir nun einmal die Eingaben aus einem Dialog entgegennehmen.

Füge dem Projekt nun eine neue Form hinzu und benenne Sie z. B. als „frmArticle“.

Danach kannst Du Sie analog zu meinem Beispiel designen (lad Dir am besten das Beispiel herunter):

Danach sorgen wir dafür, dass der Dialog auch wirklich angezeigt und dessen Ergebnis verarbeitet wird.

Gehe dazu in den „Form1„-Code und erstelle einen neuen Ereignishandler für den „Add row“-Button:

    Private Sub btnAddRow_Click(sender As Object, e As EventArgs) Handles btnAddRow.Click
        Dim dialog = New frmArticle()
        Dim result = dialog.ShowDialog(Me)
        If result <> DialogResult.OK Then
            Return
        End If
        Dim id = Convert.ToInt32(dialog.nudId.Value)
        Dim name = dialog.tbName.Text.Trim()
        Dim unit = dialog.cbbUnit.Text
        Dim purchasingPrice = dialog.nudPurchasingPrice.Value
        Dim sellingPrice = dialog.nudSellingPrice.Value
        Dim stock = Convert.ToInt32(dialog.nudStock.Value)
        dgvArticles.Rows.Add(id, name, unit, purchasingPrice, sellingPrice, stock)
    End Sub

Zuerst instanziieren wir hier eine neue Dialog-Instanz.

Danach zeigen wir diese Instanz an, indem wir die „ShowDialog„-Methode aufrufen und „Me“ (also die aktuelle Form) als „Papa“ mitgeben.

Den Rückgabewert der Funktion speichern wir in der Variable „result„, um dann zu checken, ob’s „OK“ war.

Falls nicht, verlassen wir den Ereignishandler mit einem Early-Return.

Anschließend ziehen wir uns die einzelnen Daten aus den jeweiligen Steuerelementen.

Auch hier könnte man mit Datenbindung arbeiten und so mit Eigenschaften arbeiten, aber das lassen wir hier erstmal..

Zum Schluss fügen wir die Daten dem DataGridView wie oben bereits gezeigt hinzu.

Gehen wir aber noch einmal zurück zum Artikel-Dialog selbst.

Dort brauchen wir zuerst den Handler des Abbrechen-Buttons:

    Private Sub btnCancel_Click(sender As Object, e As EventArgs) Handles btnCancel.Click
        DialogResult = DialogResult.Cancel
    End Sub

Der setzt das „DialogResult“ der Form, woraufhin die Form dann mit diesem Ergebnis geschlossen wird.

Danach legen wir den Code für den „Hinzufügen„-Knopf fest:

    Private Sub btnAdd_Click(sender As Object, e As EventArgs) Handles btnAdd.Click
        If Not ValidateInput() Then
            Return
        End If
        DialogResult = DialogResult.OK
    End Sub

Dort prüfen wir den Rückgabewert der gleich noch folgenden Funktion und „early returnen“ hier wieder, falls Sie „False“ zurückgibt.

Anschließend setzen wir das „DialogResult“ auf „OK„, woraufhin auch hier die Form geschlossen wird.

Zum Schluss kommt dann hier noch die kleine „ValidateInput„-Funktion:

    Private Function ValidateInput() As Boolean
        ' dont care about id..

        Dim name = tbName.Text.Trim()
        If String.IsNullOrWhiteSpace(name) Then
            MessageBox.Show("Please provide an article name")
            Return False
        End If

        Dim unit = cbbUnit.Text
        If String.IsNullOrWhiteSpace(unit) Then
            MessageBox.Show("Please provide an article unit")
            Return False
        End If

        ' prices are handled by the numeric up downs..
        ' stock is handled by numeric up down

        Return True
    End Function

Die Id wird hier erstmal nicht weiter geprüft, da das „NumericUpDown“ schon notwendige Eigenschaften gesetzt hat.

Somit übernimmt es die Prüfung für „Min-“ und „MaxValue„, sowie den Dezimalstellen.

Das gilt übrigens auch für die anderen „NumericUpDowns“ auf der Form.

Die einzigen beiden zu prüfenden Werte wären der Name und die Einheit.

Dort checken wir einfach, dass die Werte nicht „leer“ sind.

Wenn alles okay war, kommen wir ans Ende der Funktion und geben „True“ zurück.

Add(x, y, z) sieht blöd aus, oder!?

Ich meine man muss kein Sherlock Holmes sein, um zu sehen, dass das irgendwie blöd aussieht:

dgvArticles.Rows.Add(1, "Article 1", "KG", 9.95, 16.49, 50)

Denkst Du z. B., dass Du auch noch in einem Jahr weißt, was die 50 bedeutet?

Ist es vielleicht die Kilogramm-Anzahl, oder doch eine Mindestbestellmenge?

Was passiert zum Beispiel, wenn sich die Spalten-Reihenfolge ändert?

Möchtest Du dann viele einzelne Stellen im Code anpassen – ne, oder!?

Es muss natürlich auch nicht immer sein, dass Du der einzige Entwickler im Bunde bist.

Denkst Du, dass dies besonders leserlich und einfach zu verstehen für andere Entwickler ist?

Zusammengefasst würde ich mal behaupten, dass es folgendes nicht ist:

• „sauber„
• leserlich
• einfach zu verstehen
• gut zu behalten

Ja aber..

Klar, jetzt wirst Du mir ggf. mit der Ausrede kommen:

„Ja, aber ein Objekt-Konstruktor kann doch auch lang sein und durch Kommas getrennt sein“.

Da hast Du natürlich recht, weshalb das natürlich auch ebenso der Grund ist, weshalb man „lange“ Konstruktoren vermeiden sollte.

Die schmerzende Länge definiert hier mit Sicherheit jedes Entwickler-Team in dessen Konventionen selbst.

Aber zum Glück gibt es genug Beiträge und Bücher darüber, weshalb die relativ einfache Antwort: „Zwischen 2-3 Parametern“ sein kann.

Besonders bei einem Model, oder einer Entität namens „Artikel“ muss man aber wirklich von vielen Eigenschaften ausgehen.

Daher würde ich hier allgemein nicht großartig anfangen einen Konstruktor aufzublähen..

Der modernere Weg – Das VB NET DataGridView füllen

Kommen wir im nächsten Szenario zu einer etwas moderneren Herangehensweise.

Ich würde diese Weise auch durchaus als wesentlich sauberer bezeichnen, warum – siehst Du gleich.

Du kannst auch hierfür die grafische Oberfläche aus dem Beispiel von oben verwenden.

Ggf. kopierst Du das Projekt einmal, um beide Varianten separat vorliegen zu haben.

Im nächsten Beispiel werden wir nun eine datengebundene Variante verwenden.

Das verbessert neben dem oben angesprochenen „Spalten-Reihenfolgen-Problem“ auch noch andere Aspekte.

Sauber(er)es Feeling

Insgesamt fühlt es sich – jedenfalls für mich und viele andere Entwickler – einfach sauberer an.

Das mag vom Empfinden her vermutlich daran liegen, dass man eine klare Trennung zwischen Daten und Oberfläche hat.

Im vorherigen Beispiel haben wir stattdessen die GUI sozusagen mit den Daten vermischt – ihh!

Auch wenn das „DataGridView“ viele Methoden zur Befüllung mit Daten unterstützt, ist Diese die von mir am meisten Genutzte.

Lass uns also im nächsten Schritt die Vorbereitungen dazu treffen!

Klasse erstellen

Yay, endlich ist es soweit und wir können zu dem Punkt kommen, der die Objektorientierung wohl am meisten prägt.

Ich spreche dabei selbstverständlich vom Thema Klassen, Welche die Baupläne von Objekten darstellen.

Erst wenn man diese Pläne „umsetzt„, entstehen daraus konkrete Objekte, mit denen man dann arbeiten kann.

Diese Objekte kann man – wie Du gleich sehen wirst – auch für unser „DataGridView“ verwenden.

In Kombination brauchen wir natürlich noch irgendetwas, was diese Instanzen/Objekte der Klassen dann auflisten kann.

Eine Liste muss her

Wenn man so an Auflistungen denkt, kommen einem vermutlich zuerst Dinge wie das ganz rudimentäre Array in den Sinn.

Als nächstes macht man sich ggf. Gedanken über Listen, bzw. deren generische Variante.

Leider reichen die sehr (auch meinerseits) beliebten Listen nicht aus, da ein entscheidender Faktor fehlt.

Häufig arbeiten wir in solchen Szenarien mit Aktionen, Welche dann Einträge hinzufügen, oder eben auch löschen.

Dabei ist es natürlich von Relevanz, dass die Liste z. B. eine Entfernung eines Elements auch „nach außen kommuniziert„.

Das sollte Sie deshalb im Optimalfall tun, damit andere (vor allem grafische) Elemente, eine Chance haben zu reagieren.

Im konkreten Fall unserer kleinen tabellarischen Darstellung, könnte die Tabelle somit neu gezeichnet werden.

Das geht nur eben schlecht, wenn unsere Tabelle (also das DataGridView) davon gar nichts mitbekommt.

Die Alternative zur List Of

Wie bereits erwähnt benötigen wir eine andere Art Liste, um unsere Arbeit zu erledigen.

Wenn wir ein wenig im NET Framework graben, kommen wir auf die sogenannte „BindingList„.

Diese ist wie der Name schon suggeriert, für die Bindung von Daten geeignet.

Durch Ihre generische Art, können wir die „BindingList“ für alle möglichen Arten von Objekten verwenden.

Eine Artikel-Klasse – unseren Bauplan erstellen

Zunächst gehen wir hin und erstellen im nächsten Schritt den Bauplan für unsere Objekte, also eine Klasse.

Analog zum oben bereits veranschaulichten Beispiel, könnte die Artikel–Klasse so aussehen:

Public Class Article

    Public Property Id As Integer

    Public Property Name As String

    Public Property Unit As String

    Public Property PurchasingPrice As Decimal

    Public Property SellingPrice As Decimal

    Public Property Stock As Integer

    Sub New()

    End Sub

End Class

Danach müssen wir die definierte Klasse natürlich noch in Kombination mit der „BindingList“ verwenden.

Eine Eigenschaft für die Auflistung/Liste

Gehe also im nächsten Schritt in die Form-Klasse und lege dort eine neue Eigenschaft namens „Articles“ an:

Public Property Articles As BindingList(Of Article)

Anschließend instanziieren wir diese Eigenschaft im Konstruktor der Form.

Ansonsten würden wir natürlich eine Nullverweisausnahme bekommen, sprich ein Objekt verwenden, Welches (noch) „nicht existiert“.

    Sub New()
        InitializeComponent()
        Articles = New BindingList(Of Article)
    End Sub

Danach können wir im Load-Ereignishandler dem „DataGridView“ die Datenquelle zuordnen.

Anschließend laden wir mit der gleich folgenden Methode ein paar Testdaten.

Diese würde im Normalfall eventuell aus einer Datenbank, Textdatei, oder woher auch immer kommen.

Für unser Beispiel lade ich die Daten allerdings bewusst aus einer Methode heraus..

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles Me.Load
        dgvArticles.DataSource = Articles
        LoadArticleTestData()
    End Sub

    Private Sub LoadArticleTestData()
        Articles.Add(New Article() With {
            .Id = 1,
            .Name = "Article 1",
            .Unit = "KG",
            .PurchasingPrice = 9.95,
            .SellingPrice = 12.99,
            .Stock = 50
        })
        Articles.Add(New Article() With {
            .Id = 2,
            .Name = "Article 2",
            .Unit = "l",
            .PurchasingPrice = 13.95,
            .SellingPrice = 19.99,
            .Stock = 0
        })
        Articles.Add(New Article() With {
            .Id = 3,
            .Name = "Article 3",
            .Unit = "ml",
            .PurchasingPrice = 3.49,
            .SellingPrice = 6.99,
            .Stock = 20
        })
    End Sub

Beachte bitte, dass die Liste für jeden „Add-Vorgang“ ein getrenntes Ereignis auslöst.

Die Liste sagt also sowas wie „Hey, hier ist was hinzugekommen„.

Wenn Du natürlich nun Daten aus einer Datenbank lädst (30, 300, oder gar 30000 Einträge), spielt dieser Aspekt eine Rolle.

Für mich persönlich ist diese Rolle sogar ganz und gar nicht zu unterschätzen.

Wenn die Auflistung 3000 mal das „ItemAdded“ (oder ähnlich) auslöst, ist das für mich eher weniger effizient.

Stattdessen wäre es ja sinnvoll, wenn die Liste ein einziges Mal nach Abschluss des Ladevorgangs sagt:

„So liebe zuhörenden Steuerelemente, bitte nun neu zeichnen, da ich mich verändert habe“.

Leider besitzt die „BindingList“ von Haus aus keine „AddRange„-Methode.

Zum Glück können wir diese aber relativ einfach und zügig mit einer Extension nacharbeiten.

BindingList AddRange-Extension

Lege hierzu einen neuen Ordner im Projekt an, den Du dann z. B. „Utils“ nennen kannst.

Erstelle darin ein Modul namens „BindingListExtensions“ und füge folgenden Code ein:

Imports System.ComponentModel
Imports System.Runtime.CompilerServices

Namespace Utils

    Module BindingListExtensions

        <Extension()>
        Public Sub AddRange(Of T)(bindingList As BindingList(Of T), collection As IEnumerable(Of T))
            Dim oldRaiseEvents = bindingList.RaiseListChangedEvents
            bindingList.RaiseListChangedEvents = False
            Try
                For Each item In collection
                    bindingList.Add(item)
                Next
            Finally
                bindingList.RaiseListChangedEvents = oldRaiseEvents
                If bindingList.RaiseListChangedEvents Then
                    bindingList.ResetBindings()
                End If
            End Try
        End Sub

    End Module

End Namespace

Die „BindingList„-Klasse wird hiermit dann um die „AddRange„-Methode erweitert.

In der Methode selbst merken wir uns oben den aktuellen Wert der „RaiseListChangedEvents„-Eigenschaft.

Diese bestimmt, ob für gewisse Vorgänge dann ein „Ich habe mich verändert„-Ereignis ausgelöst werden soll.

Anschließend deaktivieren wir diesen Benachrichtigungs-Mechanismus, damit Dieser pausiert.

Danach fügen wir die einzelnen Elemente in die Auflistung ein, wobei man sich theoretisch das Try-Catch sparen könnte.

Eigentlich kann in diesem Fall nicht viel falsch gehen..

Nachdem wir alle Elemente hinzugefügt haben, setzen wir die „RaiseListChangedEvents„-Eigenschaft wieder auf den vorherigen Wert.

Danach setzen wir die Datenbindungen mit Hilfe der „ResetBindings„-Methode zurück.

Elemente/Artikel mit AddRange hinzufügen

Final konnten wir so dann das zigfache Auslösen der Ereignisse unterbinden und ein effizienteres Hinzufügen umsetzen.

Schauen wir uns nun einmal an, wie ein beispielhafter Aufruf der Methode aussehen könnte.

Wir haben also nach wie vor unsere instanziierte „Articles„-Eigenschaft.

Ebenso rufen im Load-Ereignishandler immer noch die „LoadArticleTestData„-Methode auf.

Diese Methode könnte dann so aussehen:

    Private Sub LoadArticleTestData()
        Dim myArticles = New List(Of Article)
        myArticles.Add(New Article() With {
            .Id = 1,
            .Name = "Article 1",
            .Unit = "KG",
            .PurchasingPrice = 9.95,
            .SellingPrice = 12.99,
            .Stock = 50
        })
        myArticles.Add(New Article() With {
            .Id = 2,
            .Name = "Article 2",
            .Unit = "l",
            .PurchasingPrice = 13.95,
            .SellingPrice = 19.99,
            .Stock = 0
        })
        myArticles.Add(New Article() With {
            .Id = 3,
            .Name = "Article 3",
            .Unit = "ml",
            .PurchasingPrice = 3.49,
            .SellingPrice = 6.99,
            .Stock = 20
        })
        Articles.AddRange(myArticles)
    End Sub

Wir erstellen hier also erstmal eine lokale Liste für die Sub, Welche eine normale Liste darstellt.

Danach fügen wir die einzelnen Artikel hinzu und verwenden zum Schluss die definierte „AddRange„-Methode.

Vergiss hier nicht die notwendigen Imports oberhalb der Form hinzuzufügen:

Imports System.ComponentModel
Imports VBDataGridViewFillExample.Utils

Public Class Form1

' ...

End Class

Downloads

Weiterführende Links

• Dein eigenes VB NET Plugin-System
• Das WPF DataGrid als moderne DataGridView-Alternative
• Eine Alternative für das Webbrowser-Steuerelement

Der Beitrag Ein VB NET DataGridView füllen erschien zuerst auf Robert Skibbe.

VB.NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen

Eine VB NET ImageSearch, also eine Bildersuche wollte vermutlich jeder Entwickler im NET Umfeld einmal realisieren.

Ach Gott wie präsent mir diese Momente noch im Gedächtnis sind, kleines Beispiel gefällig? Kein Problem!

Egal ob beim Ingame-Angeln, wo man praktisch immer wieder die exakt gleichen Aktionen durchführt, oder beim „craften“ von Gegenständen..

Auch wenn diese Beispiele eher mit dem Gaming-Sektor zu tun haben, gibt es mit Sicherheit genug Einsatzmöglichkeiten im Büro.

So oder so hat man sicherlich nicht immer Lust und vor allem die Zeit, diese Art von „Monkey-Work“, also praktisch die Arbeit für „Blöde“ zu erledigen.

Auf YouTube ansehen – VB NET ImageSearch

Falls Du die visuelle Darstellung, bzw. Erklärung des Beitrages bevorzugst, kannst Du natürlich auch das dementsprechende Video anschauen.

Ich habe allerdings in diesem Beitrag einige Neben-Themen eingebracht und kann mir auch hier die Zeit nehmen, ein wenig drum rum zu erklären.

Dieser Beitrag hier ist daher etwas länger und ausführlicher als das Video – just sayin‘.

Ursprung und Idee zum Beitrag – VB NET ImageSearch

In solchen häufig wiederkehrenden Momenten hat man sicherlich das Bedürfnis nach Hilfe.

Man möchte seinem Hausroboter einfach sagen können: „Hey, mach Du das bitte mal, ich habe keine Lust“.

Schnell wird man allerdings feststellen, dass das zu oft einfach nicht geht, bis auf in bestimmten Fällen.

Als Entwickler haben wir natürlich glücklicherweise die Möglichkeit uns verschiedene Hilfsmittel zu bauen.

Ob privat, beruflich, oder für’s Spielen diverser Spiele, können wir uns viele Hilfsmittel programmieren.

Vom einfachen Angel-Bot, Welcher eine bestimmte Abfolge immer wieder abarbeitet, bis hin zu komplexeren Bereichen.

Darunter könnte ich mir z. B. einen „Crafter-Bot“ vorstellen, Welcher nach gewissen Commands wie „Strg+Alt+<XY>“ komplexe Gegenstände erstellen kann.

Hilfsmittel zur Hand

Wir arbeiten in diesem Beitrag nicht ohne weitere Hilfsmittel, warum sollte man auch darauf verzichten.

Viele nützliche Funktionalitäten wurden bereits erfunden und erfolgreich über lange Zeit getestet.

Für viele Entwickler spielt natürlich die Größe der jeweiligen Hilfsmittel eine Rolle, man möchte natürlich keine 2GB großen Tools installieren.

Viele sehen allerdings schon rot, wenn die einzelnen Helfer bereits an eine Größe von 1-2 Megabyte rangehen.

In einer Zeit wo man X Terrabyte große Festplatten schon zum Preis von den damaligen 80GB-Kloppern bekommt, sehe ich es allerdings halb so schlimm.

Ich denke man muss letztendlich immer den Mehrwert gegenüber der Eigenarbeit in Relation sehen und der Mehrwert lohnt sich hier definitiv.

Wenn man sein Programm intelligent entwickelt, hält einen nachher auch nichts davon ab, gewisse Parts isoliert auszutauschen.

Letztendlich verwenden wir dieses Mal einige Funktionalitäten der AutoIt3 Scriptsprache zu Nutze.

Vorbereitungen des Visual Studio Projekts

Lade Dir nun am besten die von mir bereitgestellten Bibliotheken herunter, oder suche Diese alternativ im Netz.

Erstelle im nächsten Schritt nun wie gewohnt ein neues Windows Forms-, oder z. B. ein neues WPF-Projekt.

Füge die heruntergeladene „AutoItX3.Assembly.dll“-Datei nun als Verweis in dein Projekt ein – die anderen Dateien werden nicht funktionieren.

Einen Verweis kannst Du über den Projektmappen–Explorer rechts außen im Visual Studio hinzufügen.

Klicke dazu einfach mit der rechten Maustaste auf „Verweise“ und suche nach der Datei, wähle alternativ einen anderen Weg.

Du musst danach auch sämtliche anderen Dateien in das Debug–Verzeichnis deines Projekts legen.

Die oben Genannte ist bereits durch den vorhin geschehenen Import vorhanden.

Ran an den Code – VB NET ImageSearch

Die Funktion um die sich hier so gut wie alles drehen wird ist die „ImageSearch“-Funktion aus der „ImageSearchDLL.dll“.

Man beachte hier die komische Schreibweise, Welche trotz „doppelt-gemoppelt“ tatsächlich richtig ist..

Diese Funktion muss erst einmal wie folgt aus der passenden Library importiert werden:

    <DllImport("ImageSearchDLL.dll")>
    Private Shared Function ImageSearch(
                                 x As Integer,
                                 y As Integer,
                                 right As Integer,
                                 bottom As Integer,
                                 imagePath As String) As IntPtr
    End Function

Vergiss hier auch nicht den Import des „DllImport“-Attributs:

Imports System.Runtime.InteropServices

Ich denke, dass die Parameter der Funktion zwar relativ einleuchtend sind, gehe aber dennoch gerne darauf ein.

Dabei wird Dir denke ich das folgende Bild noch ein wenig unter die Arme greifen:

Je kleiner der durchsuchte Bereich ist und je weniger Bildfläche somit durchsucht werden muss, desto schneller ist die Bildsuche natürlich.

Parameter

x As Integer

Der X-Parameter gibt an, auf welcher Position der X-Achse die Funktion anfangen soll zu suchen.

y As Integer

Als nächstes wird der Y-Parameter übergeben, um zu definieren, ab welcher Position auf der vertikalen Achse des Bildschirms gesucht werden soll. Achtung: Von oben nach unten gesehen = je größer der Wert, desto weiter unten auf dem Bildschirm.

right As Integer

Gibt an, bis zu welchem Punkt auf der X-Achse gesucht werden soll.

bottom As Integer

Legt fest, bis zu welchem vertikalen Punkt auf der Y-Achse gesucht wird.

imagePath As String

Hier kannst Du den Pfad zum Bild angeben (z. B. „my_button.png“). Achtung: Wenn Du eine gewisse Toleranz für die Suche angeben möchtest, kannst Du dies mit einem voranstehenden Leerzeichen und dem einem Wert von 0-255 machen. Das sieht dann wie folgt aus: „50 my_button.png“. Wenn Du meine Wrapper-Klasse verwendest, macht Diese das für Dich.

Ein einfacher Aufruf – VB NET ImageSearch

Schaue Dir hier einen einfachen, beispielhaften Aufruf der rohen „ImageSearch“-Funktion an:

' dont forget the import..
' Imports AutoIt

Dim x = 0
Dim y = 0
Dim right = 1920 ' full screen width, adjust..
Dim bottom = 1080 ' full screen height, adjust..
Dim tolerance = 50 ' a tolerance value between 0 and 255
Dim imagePath = "my_button.png"
Dim finalImagePath = $"{tolerance} {imagePath}"

Dim result = ImageSearch(x, y, right, bottom, finalImagePath)
Dim res = Marshal.PtrToStringAnsi(result)

Dim imageFound = res(0) = "1"
If Not imageFound Then
    MessageBox.Show("Image not found")
    Return
End If

Dim data = res.Split("|")

x = Integer.Parse(data(1))
y = Integer.Parse(data(2))

' optional, getting image dimensions
' Dim width = Integer.Parse(data(3))
' Dim height = Integer.Parse(data(4))

' do something with the coordinates, like moving to it
AutoItX.MouseMove(x, y)

Meine kleinen Hilfsklassen

Hier zeige ich Dir beiden (wirklich) kleinen Hilfsklassen, Welche die Arbeit mit der „ImageSearch“-Funktion ein wenig vereinfachen soll.

ImageSearchResult-Klasse

Die einfachere Klasse von beiden kommt dabei zuerst, einfach nur ein Zwischenspeicher für die Werte (alternativ könnte man eine Structure verwenden).

Public Class ImageSearchResult

    Public Property Found As Boolean

    Public Property X As Integer

    Public Property Y As Integer

    Public Property Width As Integer

    Public Property Height As Integer

    Sub New(found As Boolean)
        Me.Found = found
    End Sub

End Class

ImageSearch-Klasse

Hier wäre die Klasse, Welche Dir die Aufrufe der „ImageSearch“-Funktion ein wenig vereinfachen könnte:

Imports System.Runtime.InteropServices

Public NotInheritable Class ImageSearch

    <DllImport("ImageSearchDLL.dll")>
    Private Shared Function ImageSearch(
                                 x As Integer,
                                 y As Integer,
                                 right As Integer,
                                 bottom As Integer,
                                 imagePath As String) As IntPtr
    End Function

    Public Shared Function Execute(imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        Dim workingArea = Screen.PrimaryScreen.WorkingArea
        Dim result = DoSearch(0, 0, workingArea.Width, workingArea.Height, imagePath, tolerance)
        Return result
    End Function

    Public Shared Function Execute(x As Integer, y As Integer, right As Integer, bottom As Integer, imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        Dim result = DoSearch(x, y, right, bottom, tolerance, imagePath)
        Return result
    End Function

    Public Shared Function Execute(location As Point, rightBottom As Point, imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        Dim result = DoSearch(location.X, location.Y, rightBottom.X, rightBottom.Y, tolerance, imagePath)
        Return result
    End Function

    Private Shared Function DoSearch(x As Integer, y As Integer, right As Integer, bottom As Integer, imagePath As String, Optional tolerance As Integer = 0) As ImageSearchResult
        imagePath = $"*{tolerance} {imagePath}"

        Dim result = ImageSearch(x, y, right, bottom, imagePath)
        Dim res = Marshal.PtrToStringAnsi(result)

        Dim imageSearchResult = New ImageSearchResult(res(0) <> "0")
        If Not imageSearchResult.Found Then
            Return imageSearchResult
        End If

        Dim data = res.Split("|")

        imageSearchResult.X = Integer.Parse(data(1))
        imageSearchResult.Y = Integer.Parse(data(2))

        imageSearchResult.Width = Integer.Parse(data(3))
        imageSearchResult.Height = Integer.Parse(data(4))

        Return imageSearchResult
    End Function

End Class

Ein Beispiel mit den Hilfsklassen

Hier folgt nun das Beispiel mit Hilfe der Hilfsklassen:

Dim result = ImageSearch.Execute("stop_button.png")
' providing a tolerance
' ImageSearch.Execute("stop_button.png", 50)
' and more overloads..
If Not result.Found Then
    MessageBox.Show("Image not found")
    ' if inside a sub, etc..
    Return
End If
' move to the found coordinates
AutoItX.MouseMove(result.X, result.Y)

Besonders interessant dabei sind die verschiedenen Überladungen, Welche Dir den Aufruf vermutlich verkürzen werden.

Weiterführende Links

• VB NET MouseClick simulieren – mit AutoIt3
• VB NET Web API – Währungskurs Service Konsum von Grund auf erklärt

Downloads

Der Beitrag VB NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen erschien zuerst auf Robert Skibbe.