Improved project management with UML diagrams

When managing big or a bit more complex software you will sometimes find yourself overwhelmed by the sheer amount of code and or classes. For sure, intelligent design like using neat programming patterns and structuring your app optimized in terms of – for example – a flat hierarchy can help. When your project gets bigger and more feature rich, it will almost always grow in complexity as well. Wouldn’t it be great to have some sort of common denominator where you can come back to and take your developer brain to some sort of a little pause for thought?

In a hurry? No problem, I got you covered! If you just want to know, how to create a UML diagram inside of Visual Studio, just jump to the corresponding section using the link.

One of my favourite personal tools for this is a UML diagram. UML is an acronym standing for the words „Unified Modeling Language“ which is – as the name already suggests – a language for describing common modeling aspects of relating objects. This way we can express things like „a customer has a first and a last name“ or „one customer has one or more residences“. There can even be more complex expressions as well like „a ViewModel implements an IViewModel interface“.

Keep (sadly) in mind though, that „strict“ UML diagrams aren’t really possible without extensions, etc. Out of the box you can pretty much just create class diagrams.

I mean sure, „a little pause for thought“ is a bit over the top, because you need to read through the diagram anyways, but believe me, it’s a lot easier than building up relations in your head without any help. There’s almost nothing worse than a cold dive into some random or even kinda known project without any serious documentation – and a UML diagram is one of my preferred parts of a good documentation.

Creating a UML diagram the old fashioned way

Creating a UML diagram isn’t pretty hard itself, it’s just like taking a pencil and a piece of paper and letting your thoughts flow. I mean you of course have to move within some sort of „rule based boundaries“ if you want to be compliant with typical UML design rules – which you actually should. However, this way other developers can easily read and interpret your drawn models and the overall diagram which will save a lot of time considering the projects development and progression.

Let’s start with a quick and simple example on how to create a (manual – pencil and paper based) UML diagram. We will model a „x implements y“ relation which is pretty typical in terms of pattern based programming – but let’s not dive too deep into that. I mean, in „the real world“ or in a real job scenario, you would have a lot more classes and you could even divide a UML diagram into seperate sections or create multiple diagrams existing on their own. Nobody forces you to represent your whole application through one diagram.

The example represents a relation between a class called „Customer“ which implements an interface called „ICanGiveFeedback“ providing the „GiveFeedback“ method. The customer therefore is something, which is able to give feedback doing it its own way. To be honest – as you might already saw – this isn’t really drawn, only looks alike, hehe.

For sure we could start with things like abstract blabla, but let’s keep it easy like this for our example. I have excluded things like parameters and return types as well, to keep it as easy as possible as well.

The problem with this approach

As you – being potentially working in the software industry *wink* – might already know, systems and software will change. This means, you would have to adjust your diagrams and documentation over and over. Now imagine, you would need to change your diagrams – manually! This would pretty much suck, right!? This is where Visual Studio comes into play, helping us being more productive and fast considering UML diagrams with auto generation of those.

Using Visual Studio to create a UML diagram

Now we can go to the good part, which involves the automatic generation of UML diagrams through the usage of our Visual Studio IDE. Not only does this make everything easier in the first step, it will help us keeping our diagrams up to date as well.

Prerequisites

Make sure, that you now have an open project ready and at least 1-2 classes / interfaces inside, otherwise it wouldn’t be pretty much possible or boring. If not, take those to classes and add them to your project:

public interface ICanGiveFeedback
{

    void GiveFeedback();

}

public class Customer : ICanGiveFeedback
{

    public void GiveFeedback()
    {
        // usually you would have some sort
        // of product or service to give feedback
        // on but this is only an example, so...
    }

}

Public Interface ICanGiveFeedback

    Sub GiveFeedback()

End Interface

Public Class Customer
    Implements ICanGiveFeedback

    Public Sub GiveFeedback() Implements ICanGiveFeedback.GiveFeedback
        ' usually you would have some sort
        ' of product or service to give feedback
        ' on but this is only an example, so...
    End Sub

End Class

Having the component installed via Visual Studio installer

Before you can use the following method, make sure that you actually have enabled / installed the corresponding component via the Visual Studio installer executable. Otherwise you wouldn’t be able to use the shown method / it wouldn’t be shown to you at all.

Keep in mind, that you need to save your currently open Visual Studio projects, or you won’t be able to make changes to your installation.

1. Download the Visual Studio installer

If you don’t already have the Visual Studio installer parked on your systems download folder, go ahead and download it again.

2. Open the Installer executable

After downloading (or already having) the Visual Studio installer file, open it and confirm eventual admin prompts. Keep in mind to choose the right one corresponding to your overall used Visual Studio version. I myself never had problems with just using the latest.

3. Click the „modify“ button

Search for the right version of your Visual Studio installation an click the „modify“ button on the right side. You will then be able to modify your existing Visual Studio IDE configuration.

4. Search for „class designer“

Inside of the „individual components“ tab, search for the „class designer“ component and mark it, so it will be a part of our changes. Confirm your selection with the button on the bottom right – this will trigger the change process for your VS installation. If it’s already installed you will only see a „close“ button.

Creating the UML diagram

If you have finished every previous step, you can now start with the actual process of creating your UML diagram automatically through Visual Studio.

Follow these steps:

1. Right click on your project (or a folder inside of it)
2. Choose „Add“
3. Select „New Item…“
4. Search for „Class Diagram“ and select it
5. Confirm

Filling the diagram with life

As you have created your class diagram now, it should look pretty empty, right? No problem! It’s not a bug, it’s an actual feature. You can decide which classes, etc. should actually be a part of this specific class diagram! Just play around by dragging and dropping some classes and interfaces on the class diagram „surface“ like in the image below:

The final result

In the last step you can take a look at my generated class diagram containing the class and the interface of the example from above. Please don’t get confused as I used an example project from my mentoring activity:

As you can see this is quite different from an actual UML diagram – but I think this is the closest you can get with Visual Studio without extensions.

More

See the following posts for more .NET related stuff:

• Building better objects with rskibbe.Core.Composition
• Searching and listing bluetooth devices in .NET
• The WPF ListView Control

Der Beitrag Creating easy UML diagrams with Visual Studio erschien zuerst auf Robert Skibbe.

The WPF ListView – listing items / things

In today’s post, we are going to talk about one of the most basic controls: The WPF ListView. We will take a look at the different use cases of the ListView and we will try out some of the architectural styles. As MVVM is like the „way to go“ in WPF, I will definitely examine this, but we won’t forget the „old way“. Like always, I will provide different source code examples in the two most used .NET languages, being C# and VB.NET.

This guide and all examples are compatible with .NET 8 and .NET 9.

Speaking of languages: Make sure Visual Studio is set up correctly → Change VS Installer Language.

Need quick help? Jump to the corresponding sections by using the table of contents. When you are using the code behind based approach, jump there. If you are more the MVVM guy, you could jump and start with the „MVVM approach“ section.

What is a WPF ListView?

When stumbling upon this control, the first question coming to your mind could be: „Well, what is a ListView – in the Windows Presentation Foundation – in the first place?“. I mean, by the name, you could just assume, that it’s something for displaying like a „list“ of something, right? I mean, you are pretty much on the right side, but what makes it different from like a DataGrid, or even a ListBox? Don’t worry, we will cover this is a few minutes, further down below.

The definition, I guess?

Let’s first define, what a ListView really is by like definition:

A WPF ListView provides the basic tools needed, to help you displaying a set of data items. This can be easily done in like different views or layouts, depending on your usecase. Each item of those ListViews are displayed, using something called ListViewItem. A ListViewItem iteself is – more or less – just another template-ish element, being a ContentControl.

Examining the ListView

Let’s take a quick sneak peek into the inheritance-tree, of the WPF ListView Control, by pressing F12, while being on one of those with your mouse cursor. There you can see, that it actually inherits from the class ListBox.

Inheritance tree

Going further down, there are some other classes in the inheritance tree as well, like the Selector & the ItemsControl class. I think, for most persons, it’s actually a surprise / a „good to know“-thing, that the ListView actually inherits from the ListBox class.

At this point, you can see, that there’s pretty much going on in the background. The ListView itself is actually derived from a few levels of control hierarchy and is therefore bringing a lot „to the table“. For sure, we can’t go to every level in detail, but I think the most important ones for you are beginning at the ItemsControl.

I mean, in a real application scenario, you would most likely fetch some data like the „charts“ or something like that. Those could then be displayed inside your ListView by specifying what should actually appear. The chart object could be composed from many different objects and therefore you would need to specify a bit further.

A first example – with XAML & code behind

Let’s now focus on creating an actual first example of the ListView Control. To do so, we usually need to first have some kind of data to display. At this point, we will just create some hardcoded items, to see, how the ListView and its ListViewItems are created in the first place. Keep in mind, that we will do this and more in an MVVM manner, later – which is the preferred way for me personally.

We will surround the ListView by a GroupBox Control, to have some kind of labelling, etc. So go ahead and create a GroupBox XAML markup inside your MainWindow.xaml (inside the root Grid). You can write something like „Music stars“, etc. inside the Header Property of that GroupBox, like this, we have some kind of heading for our list.

After that, we can add some sort of styling like padding, a width and alignments to that GroupBox, to make it look less bruised. The final, but first testing XAML code could therefore look like this:

    <Grid>
        <GroupBox Header="Some items" Padding="8" Width="200" VerticalAlignment="Center" HorizontalAlignment="Center">
            <ListView>
                <ListView.Items>
                    <ListViewItem Content="Jimmy Hendrix" />
                    <ListViewItem Content="Michael Jackson" />
                    <ListViewItem Content="The Beatles" />
                </ListView.Items>
            </ListView>
        </GroupBox>
    </Grid>

The visual representation of that XAML code from above, will just look as simple as this.

How to add items to the WPF ListView?

To add some items to the ListView in a „code behind“-manner, we need to specify a usual handler for like the click event, of for example a button. We can then react to that click inside of the handler and actually add a new item to the ListView. Go ahead and add a button inside of your MainWindow (Grid) and specify the „Click“-Property.

<Button Click="Button_Click" />

It will suggest, to create an actual handler, you can confirm this and press F12 while being on the „Button_Click“ text. After that, it will automatically jump to the corresponding part in your code – the code behind file. Feel free to rename that handler (in XAML & code) to pick a better name, like „btnAddItem_Click“.

Inside of the click handler, we need to somehow say: „Hey, ListView, please remove an item!“. And we are only able to do so, if we have something to talk to. Currently, the ListView doesn’t have a name, so you should go back and specify a name for it:

<ListView x:Name="MusicArtistList" ....>
    <!-- .... -->
</ListView>

The button click handler itself could just look like the following. We are just telling the property of the „MusicArtistList“, called „Items“: „Hey, please add another entry to yourself, thanks!“.

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        MusicArtistList.Items.Add("Sam Smith");
    }

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        MusicArtistList.Items.Add("Sam Smith")
    End Sub

How to remove items from the ListView again?

If you have followed the above steps to actually add an item inside of our ListView, then you could be ready to remove it again. Keep in mind, that you should have like the click handler ready (by specifying the Buttons click property with like „btnRemove_Click“) and that the ListView needs a name. Otherwise, we wouldn’t be able to target it from the code behind file.

    private void btnRemove_Click(object sender, RoutedEventArgs e)
    {
        // this only works that easy due to our current "strings" example
        MusicArtistList.Items.Remove("Sam Smith");
    }

    Private Sub btnRemove_Click(sender As Object, e As RoutedEventArgs)
        ' this only works that easy due to our current "strings" example
        MusicArtistList.Items.Remove("Sam Smith")
    End Sub

How to delete the selected item in the ListView?

This one here is a bit different, because we can’t know at compile time, which one of the items, the user will select. We can’t therefore hardcode like a specific string thing, to be deleted later. We need a possibility, to get the currently selected item and delete it somehow.

This is actually pretty easy, as we get everything we need to know, from the ListView itself. We will first check, if there’s an actual selection and if so, we will delete that item by providing its index.

    private void btnRemoveSelectedItem_Click(object sender, RoutedEventArgs e)
    {
        bool noItemSelected = MusicArtistList.SelectedIndex == -1;
        if (noItemSelected)
            return;
        MusicArtistList.Items.RemoveAt(MusicArtistList.SelectedIndex);
    }

Private Sub btnRemoveSelectedItem_Click(sender As Object, e As RoutedEventArgs)
    Dim noItemSelected As Boolean = MusicArtistList.SelectedIndex = -1
    If noItemSelected Then
        Return
    End If
    MusicArtistList.Items.RemoveAt(MusicArtistList.SelectedIndex)
End Sub

Okay, but not flexible, nor practical – imo

So in the end, we just created a small ListView representation with like 3 entries for our music stars / artists. Currently, this isn’t really good, as it’s not dynamic or based on „real data“. We just hardcoded those ListViewItems inside the ListView and this isn’t pretty much practical.

The other problem with our current example is, that it’s not pretty flexible, currently we are having only like „1 Column“. With that, we can only display one „thing“ per item and we are not really different from a ListBox. What if we wanted to publish some sort of „year of birth“ information? I mean sure, we could just pump it into one string, but nah, that doesn’t feel right.

What we really need are some sort of columns and guess what, the ListView supports this out of the box, by just specifying the View property.

Working with „real data“ – MVVM approach

Moving away from that unpractical non-databased „stringish“ approach from above, we will now start a newer, clean version of our ListView Control. But first, we need to actually define „what“ to display, I mean, we need some sort of a so called „Model“ (or even a ViewModel – but I’ll leave it at that for now). As we wanted to display some sort of „music star“-overview, we could think of a better term in the first place. I will call it list of artists, so let’s now create a new class called „MusicArtist“ inside a matching folder.

Go ahead and create the corresponding folder inside your WPF project, first. We will call that folder like „Models“ – remember, I don’t want to go too deep into the MVVM cosmos. I would encourage you to refer to my C# MVVM post for that and don’t be confused, it will for work VB.NET as well. I mean the characteristics of Model-View-ViewModel are in the focus, not the language itself :).

The „MusicArtist“ model class

Thinking about the class itself and keeping our example from above in mind, we could say, that a music artist has the following properties. For sure, it’s just for our example and I’m trying to stay as easy as possible, so feel free to change anything you would like to.

using System;

namespace WpfListViewExampleCs.Models;

public class MusicArtist
{

    public string FirstName { get; set; }

    public string LastName { get; set; }

    public DateTime Birthday { get; set; }

    public MusicArtist(string firstName, string lastName, DateTime birthday)
    {
        FirstName = firstName;
        LastName = lastName;
        Birthday = birthday;
    }
}

Imports System

Namespace WpfListViewExampleCs.Models

    Public Class MusicArtist

        Public Property FirstName As String

        Public Property LastName As String

        Public Property Birthday As DateTime

        Public Sub New(firstName As String, lastName As String, birthday As DateTime)
            Me.FirstName = firstName
            Me.LastName = lastName
            Me.Birthday = birthday
        End Sub

    End Class

End Namespace

In my example here, the music artist has two properties for the name, meaning a first- and a lastname. I don’t like the „name“ only approach, as you can’t easily separate the names in some situations. Well, I mean yeah, before you mention it: „The Beatles“ isn’t really nicely separatable in this manner, but, welcome to the world of software development. I would say, this isn’t the right moment to argue about this, so feel free – again – to change that as you wish. Additionally I thought about using the birthday property, to show some sort of formatting in the XAML as well.

Displaying bound data inside the WPF ListView

After specifying some kind of model to actually display inside the ListView, we now go ahead and tell the ListView about its datasource. The ListView will then know: „Where can I fetch my data from? What is my data?“.

Preventing a known error

But before, we need to clean up the old code, otherwise we could run into an error like this:

System.InvalidOperationException: „The items collection must be empty before using itemssource“

To avoid this error, you need to remove the manually added items inside our XAML code. You can’t like say: „Hey, fetch the items from this datasource here“ AND put them in manually by XAML. Please go ahead and remove this marked area from the XAML code:

Giving the ListView its datasource

In the next step, we will actually care for some items being displayed. For this, we will use the DataSource property of the ListView and bind to some property from our ViewModel. Don’t be scared, if you don’t know what a ViewModel is! Maybe this is another chance, to refer to my blog post considering the MVVM pattern.

<ListView ItemsSource="{Binding MusicArtists}">
<!-- rest of the listview.. -->
</ListView>

We won’t create a separate ViewModel right now, for this simple example, we will use the MainWindow itself. This is pretty much easier at this point and it won’t push you too far away from the actual topic. Never the less, we still need a bindable property inside our MainWindow, which we are going to create, now.

Creating a bindable property

To create the announced property, just build some normal property inside your MainWindow (for example) called „MusicArtists“. This could look like the following code, keep in mind, that we should use something which implements the „INotifyCollectionChanged“ interface. But yes, I hear you, this should be a topic for another blog post, so just take it like that for now.

Next, create that property called „MusicArtists“ of type of „ObservableCollection“, with the generic type argument „MusicArtist“. We could also just make it like readonly, but those are fine tuning things, which aren’t necessary right now.

The last important step is, to say: „Hey, MainWindow, your DataContext is actually.. you!“. Then the MainWindow will know where to find the corresponding „MusicArtists“, which we are going to bind very soon from the XAML side. Take a look at the following example XAML code:

using System;
using System.Collections.ObjectModel;
using System.Windows;
using WpfListViewExampleCs.Models;

namespace WpfListViewExampleCs;

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{

    public ObservableCollection<MusicArtist> MusicArtists { get; set; }

    public MainWindow()
    {
        InitializeComponent();
        MusicArtists = new ObservableCollection<MusicArtist>();
        DataContext = this;
    }
}

Imports System
Imports System.Collections.ObjectModel
Imports System.Windows
Imports WpfListViewExampleCs.Models

Namespace WpfListViewExampleCs

    Public Partial Class MainWindow
        Inherits Window

        Public Property MusicArtists As ObservableCollection(Of MusicArtist)

        Public Sub New()
            InitializeComponent()
            MusicArtists = New ObservableCollection(Of MusicArtist)()
            DataContext = Me
        End Sub

    End Class

End Namespace

Filling up some data

Currently, the ListView wouldn’t be able to display much, because there just aren’t no items inside the „MusicArtists“, yet. So in the next step we are going to fill up some items, to make the ListView be able to display those. This is the reason, why we added a quick constructor inside the „MusicArtist“ class: Creating quick example artists.

Let’s re-create the MainWindow constructor for this:

// rest of the MainWindow code behind file

    public MainWindow()
    {
        InitializeComponent();
        MusicArtists = new ObservableCollection<MusicArtist>();
        MusicArtists.Add(new MusicArtist("Jimmy", "Hendrix", new DateTime(1942, 11, 27)));
        MusicArtists.Add(new MusicArtist("Michael", "Jackson", new DateTime(1958, 8, 29)));
        MusicArtists.Add(new MusicArtist("The", "Beatles", new DateTime(1960, 1, 1)));
        DataContext = this;
    }

// rest of the MainWindow code behind file

' rest of the MainWindow code behind file

Public Sub New()
    InitializeComponent()
    MusicArtists = New ObservableCollection(Of MusicArtist)()
    MusicArtists.Add(New MusicArtist("Jimmy", "Hendrix", New DateTime(1942, 11, 27)))
    MusicArtists.Add(New MusicArtist("Michael", "Jackson", New DateTime(1958, 8, 29)))
    MusicArtists.Add(New MusicArtist("The", "Beatles", New DateTime(1960, 1, 1)))
    DataContext = Me
End Sub

' rest of the MainWindow code behind file

But it’s displaying rubbish now?

If you are looking at the current results, you would pretty much only see rubbish. If you didn’t look until now, please watch the following screenshot, then you probably will. The items are more or less being displayed, but there’s only something like „Blabla.Bla.MusicArtist“ written.

The reason for that is, that the corresponding ListViewItem actually knows: „Hey, there is something called MusicArtist“. But it’s also asking itself: „well, how am I supposed to display this? Property A, B, C, WHAT!?“. In the end it thinks: „You know what, dev? I’m just going to display THAT over here“.

By „that“ I’m meaning the complete path to the corresponding class instance type. We are having a class called „MusicArtist“ inside our project called „WpfListViewExampleCs“ AND inside the „Models“ namespace. So this is basically why that „rubbish“ comes out of it, it displays the complete namespace to class path!

Overriding that „default-rubbish“

Before we are going to use the final solution for this, I first want to explain and show you, how you could potentially solve it at this point. Please keep in mind, that this solution depends on your usecase! Usually, if you want to display like „multiple columns“, you would actually need – well – multiple columns.

In the image from above, you are seeing the default object class „ToString“ output. To change it, you can just override it in your derived class – being the „MusicArtist“-class like in a second. Hint: I’m using the newer, shorter version of the overriding functionality. This means, no body parantheses and an arrow (for C#), as well as string interpolation (for both languages).

You could add this to the „MusicArtist“ class:

// rest of the MusicArtist class

public override string ToString()
    => $"{FirstName} {LastName}";

// rest of the MusicArtist class

' rest of the MusicArtist class

Public Overrides Function ToString() As String
    Return $"{FirstName} {LastName}"
End Function

' rest of the MusicArtist class

So the current / new output would look like this:

Using the ListViews „View“ Property creating columns

After cleaning up that „namespace and class“-mess we saw in the last section, we now can go the last step (I think). Currently, our ListView is only displaying some kind of single dimensioned data, which is not thaaaat bad, but I guess bad for multi-dimensioned data? What if I wanted to have some sort of separated columns for first and last name? This is exactly, where the so called „View“-property of the WPF ListView comes into play!

But why a ListView, why no DataGrid instead?

Sure, you could ask yourself: „Why would I use a ListView, when I could use a DataGrid instead?“. The answer is: „It depends“, yeah, I hate those answers as well.. Usually there’s one rule floating around in the internet: Use a DataGrid, if you need editing, use a ListView otherwise – bang. I would pretty much love going deeper into this topic, but well, I think this post is already too big, isn’t it?

Specifying a „View“-template

To start creating those columns we talked about, we need to specify some sort of template for the View property. But it’s not a usual „DataTemplate“, it’s something more special, lemme give you an example. The basic view provided from WPF itself, is something called a „GridView“. I mean, the name pretty much suggests what it is. If needed, you could create something similiar for your own needs, but again, I think this would blow up this post even more..

So let’s stick with the basic GridView for now. Back into your MVVM prepared ListView, we can now provide a GridView template for our ListView. Watch out for that nice string format functionality, where I specified a custom format for that birthday binding. Basically all you have to do is, providing the columns you want, with a header of your choice. Then you need to tell the ListViewItem, where it should pull the data from (being the DisplayMemberPath-Binding).

            <ListView ItemsSource="{Binding MusicArtists}">
                <ListView.View>
                    <GridView>
                        <GridView.Columns>
                            <GridViewColumn Header="FirstName" DisplayMemberBinding="{Binding FirstName}" />
                            <GridViewColumn Header="LastName" DisplayMemberBinding="{Binding LastName}" />
                            <GridViewColumn Header="Birthday" DisplayMemberBinding="{Binding Birthday, StringFormat={}{0:dd.MM.yyyy}}" />
                        </GridView.Columns>
                    </GridView>
                </ListView.View>
            </ListView>

And finally, you end up having this nice thing here:

Adding, removing, etc. the MVVM way – preparations

Because it’s a bit harder, I saved this topic (and other) for the end of this blog post. You actually need some sort of „ICommand“ implementation, which we won’t cover here, but I will give you the example code needed. There will be another blog post about those commands in english, currently, it’s only available in german, sorry.

A DelegateCommand base class

Please go ahead and create another folder inside your project, called „Utils„. We will deposit a small class over there, which helps us with the buttons in MVVM style. The class I’m talking about looks like this, it’s a basic implementation of a delegated action (with check) for the ICommand-interface:

using System.Windows.Input;
using System;

namespace Utils
{
    public class DelegateCommand : ICommand
    {
        private Action<object?> _action;

        private Func<object?, bool>? _canExecute;

        public DelegateCommand(Action<object?> action)
        {
            _action = action;
        }

        public DelegateCommand(Action<object?> action, Func<object?, bool> 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;
    }
}

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

A PropertyChangedBase class

Without going into too much detail, please copy this class and put it into the „Utils“ folder as well. There is a blog post for the INotifyPropertyChanged-interface, but currently it’s only in german. Maybe you could use a browser-translator for now, but I will add the english version soon. So now, please take this class:

using System.Runtime.CompilerServices;
using System.ComponentModel;

namespace Utils;

public abstract class PropertyChangedBase : INotifyPropertyChanged
{
    protected void NotifyOfPropertyChange([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
    public event PropertyChangedEventHandler? PropertyChanged;
}

Imports System.ComponentModel
Imports System.Runtime.CompilerServices

Namespace Utils

    Public Class PropertyChangedBase
        Implements INotifyPropertyChanged

        Protected Sub NotifyOfPropertyChange(<CallerMemberName> Optional propertyName As String = Nothing)
            RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propertyName))
        End Sub

        Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged

    End Class

End Namespace

Corresponding buttons

Please add something like a StackPanel and 3 Buttons inside of it. There will be one button for adding and one for removing an item at a specific position. The third button will be for removing the selected item. At this point, we will also those commands, please have a look at the following XAML. Please pardon me for not making this visually appealing, it’s only for its functional purpose.

Keep in mind, that you also need to create 3 new properties of type of „DelegateCommand“, 1 for each command, being:

• AddItemCommand
• RemoveItemCommand
• RemoveItemAtIndexCommand

        <GroupBox Header="Music stars" Padding="8" Width="400" VerticalAlignment="Center" HorizontalAlignment="Center">
            <StackPanel>
                <ListView SelectedItem="{Binding SelectedMusicArtist}" ItemsSource="{Binding MusicArtists}">
                    <ListView.View>
                        <GridView>
                            <GridView.Columns>
                                <GridViewColumn Header="FirstName" DisplayMemberBinding="{Binding FirstName}" />
                                <GridViewColumn Header="LastName" DisplayMemberBinding="{Binding LastName}" />
                                <GridViewColumn Header="Birthday" DisplayMemberBinding="{Binding Birthday, StringFormat={}{0:dd.MM.yyyy}}" />
                            </GridView.Columns>
                        </GridView>
                    </ListView.View>
                </ListView>
                <StackPanel Orientation="Horizontal" Margin="0 12 0 0" HorizontalAlignment="Right">
                    <Button Command="{Binding AddItemCommand}" Content="Add item" Margin="0 0 8 0" />
                    <Button Command="{Binding RemoveItemCommand}" Content="Remove item" Margin="0 0 8 0" />
                    <Button Command="{Binding RemoveItemAtIndexCommand}" Content="Remove item at index" />
                </StackPanel>
            </StackPanel>
        </GroupBox>

The „new“ UI now looks like this:

The MainViewModel

Now create a new folder called „ViewModels“ and a „MainViewModel“ class inside. Let the „MainViewModel“ class inherit from the „PropertyChangedBase“ you copied from the previous paragraph. The view (code behind) file should now be abandoned as it’s getting too much otherwise.

Over here we fully implemented the „SelectedMusicArtist“-property to actually tell the „RemoveItemCommand“: „Hey, here was something selected, check if you can be executed now“. We’re subscribing to the „CollectionChanged“ event of the ObservableCollection as well. This way, we can also refresh the commands state, when the collection is changed.

In the next steps, we are going to instantiate the commands and therefore telling them, what to do and when.

using System;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using Utils;
using WpfListViewExampleCs.Models;

namespace WpfListViewExampleCs.ViewModels;

public class MainViewModel : PropertyChangedBase
{

    public ObservableCollection<MusicArtist> MusicArtists { get; set; }

    private MusicArtist? _selectedMusicArtist;

    public MusicArtist? SelectedMusicArtist
    {
        get => _selectedMusicArtist;
        set
        {
            if (_selectedMusicArtist == value)
                return;
            _selectedMusicArtist = value;
            RemoveItemCommand.RaiseCanExecuteChanged();
        }
    }

    public DelegateCommand AddItemCommand { get; set; }

    public DelegateCommand RemoveItemCommand { get; set; }

    public DelegateCommand RemoveItemAtIndexCommand { get; set; }

    public MainViewModel()
    {
        MusicArtists = new ObservableCollection<MusicArtist>();
        MusicArtists.CollectionChanged += MusicArtists_CollectionChanged;
        MusicArtists.Add(new MusicArtist("Jimmy", "Hendrix", new DateTime(1942, 11, 27)));
        MusicArtists.Add(new MusicArtist("Michael", "Jackson", new DateTime(1958, 8, 29)));
        MusicArtists.Add(new MusicArtist("The", "Beatles", new DateTime(1960, 1, 1)));
    }

    private void MusicArtists_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
    {
        RemoveItemCommand.RaiseCanExecuteChanged();
        RemoveItemAtIndexCommand.RaiseCanExecuteChanged();
    }

}

Imports System
Imports System.Collections.ObjectModel
Imports System.Collections.Specialized
Imports Utils
Imports WpfListViewExampleCs.Models

Namespace WpfListViewExampleCs.ViewModels

    Public Class MainViewModel
        Inherits PropertyChangedBase

        Public Property MusicArtists As ObservableCollection(Of MusicArtist)

        Private _selectedMusicArtist As MusicArtist?

        Public Property SelectedMusicArtist As MusicArtist?
            Get
                Return _selectedMusicArtist
            End Get
            Set(ByVal value As MusicArtist?)
                If _selectedMusicArtist = value Then Return
                _selectedMusicArtist = value
                RemoveItemCommand.RaiseCanExecuteChanged()
            End Set
        End Property

        Public Property AddItemCommand As DelegateCommand

        Public Property RemoveItemCommand As DelegateCommand

        Public Property RemoveItemAtIndexCommand As DelegateCommand

        Public Sub New()
            MusicArtists = New ObservableCollection(Of MusicArtist)()
            AddHandler MusicArtists.CollectionChanged, AddressOf MusicArtists_CollectionChanged
            MusicArtists.Add(New MusicArtist("Jimmy", "Hendrix", New DateTime(1942, 11, 27)))
            MusicArtists.Add(New MusicArtist("Michael", "Jackson", New DateTime(1958, 8, 29)))
            MusicArtists.Add(New MusicArtist("The", "Beatles", New DateTime(1960, 1, 1)))
        End Sub

        Private Sub MusicArtists_CollectionChanged(ByVal sender As Object?, ByVal e As NotifyCollectionChangedEventArgs)
            RemoveItemCommand.RaiseCanExecuteChanged()
            RemoveItemAtIndexCommand.RaiseCanExecuteChanged()
        End Sub

    End Class

End Namespace

Modern alternative (.NET 6+): CommunityToolkit.Mvvm

Writing DelegateCommand and PropertyChangedBase manually works perfectly fine 👉 and understanding how they work is exactly why we did it this way. But in 2026, you would typically reach for the CommunityToolkit.Mvvm NuGet package instead.

It ships source generators like [ObservableProperty] and [RelayCommand], which produce the same boilerplate automatically at compile time, meaning less code to write and maintain.

Compare the two approaches with these small code snippets:

❌ Manual (what we did above)

private MusicArtist? _selectedMusicArtist;
public MusicArtist? SelectedMusicArtist {
    get => _selectedMusicArtist;
    set { _selectedMusicArtist = value; NotifyOfPropertyChange(); }
}

✅ CommunityToolkit.Mvvm

[ObservableProperty]
private MusicArtist? _selectedMusicArtist;

Well worth a look once you are comfortable with the concepts above!

Assign a ViewModel to the MainWindow

To be able to this all work, make sure, you set an appropriate ViewModel for your MainWindow. Otherwise, the binding system wouldn’t know, where to search for your bindings. This is done by adding this code to your MainWindow XAML file:

<!-- create a namespace mapping at the top of your file -->
xmlns:vm="clr-namespace:WpfListViewExampleCs.ViewModels"

<!-- Set the DataContext MainViewModel instance by XAML -->
<Window.DataContext>
    <vm:MainViewModel />
</Window.DataContext>

How to add WPF ListView items with MVVM

After you got our little helper class from above inside your „Utils“ folder and everything else ready, we can now continue. Adding items is now kinda different, because our items are actually bound and not just simple strings. Our commands wants at least to know, what it should do, when executed. We can pass a function, to let the command determine, if it can be executed. I mean, we don’t want a „remove selected item“ to happen, when there’s no item, right?

The following code is needed for the actual functionality: Instantiate the command inside the constructor (don’t forget to take the command property from above!).

    // other properties

    public DelegateCommand AddItemCommand { get; set; }

    public MainViewModel()
    {
        AddItemCommand = new DelegateCommand(AddItem);

        // list instantiation etc..
    }

    // the delegate function to be executed on click
    private void AddItem(object? parameter)
    {
        // adding miley cyrus, as we have no dynamic dialog, as it's not a part of this here..
        MusicArtists.Add(new MusicArtist("Miley", "Cyrus", new DateTime(1992, 11, 23)));
    }

    ' other properties
   
    Public Property AddItemCommand As DelegateCommand

    Sub New()
        AddItemCommand = new DelegateCommand(AddItem);

        ' list instantiation etc..
    End Sub

    Private Sub AddItem(parameter As Object)
        MusicArtists.Add(New MusicArtist("Miley", "Cyrus", New DateTime(1992, 11, 23)))
    End Sub

Removing the selected item MVVM style

The important thing here is, that we can only remove a selected item, if there is actually one selected. Please check the „SelectedMusicArtist“-property from the above MainViewModel for this. If the selected item (therefore the SelectedMusicArtist) changes, we tell the command to refresh.

    // other properties

    public DelegateCommand RemoveItemCommand { get; set; }

    public MainViewModel()
    {
        RemoveItemCommand = new DelegateCommand(RemoveItem, CanRemoveItem);

        // list instantiation etc..
    }

    private void RemoveItem(object? parameter)
    {
        // we should know that SelectedMusicArtist isn't null, therefore the !
        MusicArtists.Remove(SelectedMusicArtist!);
    }

    private bool CanRemoveItem(object? parameter)
    {
        return SelectedMusicArtist != null;
    }

    ' other properties
   
    Public Property RemoveItemCommand As DelegateCommand

    Sub New()
        RemoveItemCommand = new DelegateCommand(RemoveItem, CanRemoveItem);

        ' list instantiation etc..
    End Sub

    Private Sub RemoveItem(parameter As Object)
        MusicArtists.Remove(SelectedMusicArtist)
    End Sub

    Private Function CanRemoveItem(parameter As Object) As Boolean
        Return SelectedMusicArtist IsNot Nothing
    End Function

Deleting an item by index, MVVM like

In the last example, we do pretty much the same, but with some hardcoded index, just as an example!

    // other properties

    public DelegateCommand RemoveItemAtIndexCommand { get; set; }

    public MainViewModel()
    {
        RemoveItemAtIndexCommand = new DelegateCommand(RemoveItemAtIndex, CanRemoveItemAtIndex);

        // list instantiation etc..
    }

    private void RemoveItemAtIndex(object? parameter)
    {
        // we need at least one item inside
        MusicArtists.RemoveAt(0);
    }

    private bool CanRemoveItemAtIndex(object? parameter)
    {
        return MusicArtists.Count > 0;
    }

    ' other properties
   
    Public Property RemoveItemAtIndexCommand As DelegateCommand

    Sub New()
        RemoveItemAtIndexCommand = new DelegateCommand(RemoveItemAtIndex, CanRemoveItemAtIndex);

        ' list instantiation etc..
    End Sub

    Private Sub RemoveItemAtIndex(parameter As Object)
        MusicArtists.RemoveAt(0)
    End Sub

    Private Function CanRemoveItemAtIndex(parameter As Object) As Boolean
        MusicArtists.Count > 0
    End Function

Conclusion – WPF ListView Control

If you want to have a control, which is able to display things in like a list, being able to select one or more items out of it, the ListView is possibly your choice. When thinking about: „Should I use a ListView or a DataGrid“, you should choose the ListView, if editing is not a concern. As mostly always, you have the option to go for the code behind, or the MVVM approach, I would personally always choose the MVVM one. It seems much cleaner for my personal preferences and doesn’t mix up UI with business code. Feel free to leave any comment on how to improve this article, or if I may explained something wrong.

FAQ

Downloads

If you need quick and ready to use examples, just go ahead and download the ones you need. Maybe I’ll add some more later.

Der Beitrag The WPF ListView Control – the complete Guide in 2026 erschien zuerst auf Robert Skibbe.

Artikeldaten-Beispiel: Einlesen aus .csv-Datei

Hast Du Dich auch schonmal gefragt, wie Du eine CSV-Preisliste in VB.NET einlesen kannst? Gestern habe ich einen YouTube-Kommentar, bzw. einen Video-Wunsch eines Benutzers erhalten, wo es genau darum ging. Natürlich bin ich ein guter Klein-YouTuber *schnief* und setze die Wünsche meiner Zuschauer selbstverständlich um 😉!

💡 Wenn Du ein schnelles Code-Beispiel brauchst, scrolle einfach nach unten zum kompletten Code, oder den Downloads. Auch wenn dieses Beispiel auf VB.NET ausgelegt ist, kannst Du es selbstverständlich auch kinderleicht für C# verwenden.

Da der User unter dem VB-Video kommentiert hatte, dachte ich, ich mache es direkt passend – dennoch arbeite ich heutzutage fast nur noch mit C# (außer ein Kunde wünscht es anders, oder ich mache ein Video zu VB.NET).

Keine Lust auf Text? Einfach als Video schauen

Falls Du keine Lust hat, diesen Beitrag in Textform zu lesen, kannst Du natürlich auch zum passenden YouTube-Video von mir rüberschwenken. Einfach in das Rechteck hier drüber klicken und schon geht es los.

Gedanken, die man sich machen sollte: Objektorientierung

Bevor wir mit dem eigentlichen „Problem“, also der programmiertechnischen Herausforderung starten, setzen wir unsere Segel erstmal Richtung Datentypen. Wir machen uns also im ersten Schritt Gedanken darüber, mit welcher Art Daten, bzw. mit welchen Objekten wir arbeiten werden. Hier kommt bei einer Artikel-, bzw. Preisliste natürlich ein „Ding“ sofort in unseren Kopf: Der Artikel!

Eine letztendliche Auflistung dieser Artikel ist ja dann praktische unsere Preisliste im objektorientierten Sinne. Wenn Diese schön sauber gebaut ist, haben wir anschließend sogar noch die Möglichkeit, Sie zu filtern und weiterzuverarbeiten. Dazu kommen wir dann weiter unten..

Damit wir die Klasse allerdings gut strukturieren können (erneut – hier einfach gehalten), schauen wir uns im nächsten Schritt die Datei selbst an. Bringt ja schließlich nichts, mit Spekulationen zu programmieren, wir brauchen harte Fakten!

Die Preisliste.csv-Datei für VB.NET

Wenn wir an eine typische CSV-Datei denken, dann denkt man wohl an verschiedene Werte, Welche durch Kommata getrennt sind (naja, „comma separated values“ halt, gell?). Jede Zeile steht hierbei für einen jeweils eigenen Datensatz / Artikel.

Also ungefähr so:

Name,Preis
Artikel 1,12.95
Artikel 2,120.95
Artikel 3,1000

Man trifft allerdings häufiger auf so eine Variante hier an, also durch Semikola (ja, ist tatsächlich der Plural von Semikolon und hat nichts mit dem Getränk zu tun!) getrennte Spalten:

Name;Preis
Artikel 1;12.95
Artikel 2;120.95
Artikel 3;1000

Im Endeffekt ist uns das auch fast egal, denn dann verarbeiten wir die Spalten einfach nur durch ein anders getrenntes Zeichen – muss man aber trotzdem drauf achten. Ebenso wichtig ist hier das Encoding, es könnte zu Problemen mit Umlauten sowie Sonderzeichen führen. Hierbei bin ich ein Fan von UTF-8 :)!

Da wir die Daten nun kennen, bauen wir im nächsten Schritt einfach die Artikel-Klasse.

Die Artikel-Klasse

Fangen wir also nun mit der Erstellung einer passenden Klasse an. Beachte jedoch, dass ich Diese für dieses Beispiel hier klein und einfach gehalten habe. Je nach Anwendungsfall, müsstest Du die Klasse natürlich noch um die ein oder andere Eigenschaft / Funktionalität erweitern.

Lege also eine neue Datei im Projekt an und bezeichne Diese als „Artikel.vb“:

Public Class Artikel

    Public Property Name As String

    Public Property Preis As Decimal

End Class

public class Artikel
{

    public string Name { get; set; }

    public decimal Preis { get; set; }

}

Hierbei habe ich die beiden für mich wichtigsten Eigenschaften des Artikels gewählt:

1. Name – natürlich ein String
2. Preis – ein Decimal

Optionaler, leerer Konstruktor

Nachdem wir diese beiden Eigenschaften definiert haben, könntest Du eventuell einen expliziten, leeren Konstruktor anlegen. Auch wenn Dieser praktisch von Haus aus vorhanden und „KISS – Keep It Smart & Simple“ an der Tagesordnung ist, finde ich es so (persönlich) trotzdem sauberer. Allerspätestens wenn Du (wie häufig) Parameter bei der Erstellung übergeben möchtest, bist Du darauf sowieso angewiesen.

Erweitere also die Artikel-Klasse bei Bedarf um den parameterlosen Konstruktor:

' Rest der Klasse...

Sub New()
  
End Sub

' ...

// Rest der Klasse...

public Artikel()
{

}

// ...

Auf geht’s in die Form

Im nächsten Step hüpfen wir in das Formular, Welches uns lediglich einen Button und auch noch eine Tabelle (DataGridView) bereitstellen wird. Wenn wir auf den Button klicken, sollen die Artikeldaten aus der CSV-Datei verarbeitet und anschließend dargestellt werden. Schaue Dir hierzu ggf. noch einmal das Beitragsbild von ganz oben an und designe es nach Bedarf ähnlich.

Klicke nun einmal doppelt auf die Form, damit wir direkt einmal das DataGridView konfigurieren können. Wir stellen hierbei die automatische Generierung der Spalten aus, Diese legen wir selbst fest, weil wir später noch eine „lesbarere Spalte“ definieren wollen! Durch den Doppelklick (oder einem anderen Weg) solltest Du nun im Load-Ereignishandler des Formulars sein:

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        'Dim enUsCulture = New CultureInfo("en-US")
        'Thread.CurrentThread.CurrentCulture = enUsCulture
        DataGridView1.AutoGenerateColumns = False
    End Sub

Beachte, dass die obigen beiden Anweisungen gebraucht werden, wenn Du in der CSV-Datei ein englisches Zahlenformat (also „49.95“ statt „49,95“) verwendest. Damit setzt Du die sogenannte CultureInfo auf „Englisch“.

Danach kommen wir zum wichtigen, gerade eben angesprochenen Punkt: Wir schalten die automatische Generierung von Spalten bei Zuweisung einer Datenquelle aus. Dies geht durch das Zuweisen von „False“ mit der „AutoGenerateColumns“-Eigenschaft. Falls Du die automatisch generierten Spalten behalten möchtest, kommentiere diese Zeile natürlich dementsprechend aus.

DataGridView-Spalten konfigurieren

Nun kannst Du die Spalten des DataGridViews (bei ausgeschalteter Auto-Generierung) manuell festlegen. Gehe dazu mit einem Klick auf Dein DataGridView und wähle im Eigenschaftsfenster (Designer!) die „Columns“-Eigenschaft. Verwende die 3 Punkte, damit sich ein Menü öffnet und pflege die erwünschten Spalten ein. Im Beispiel von oben sind das zwei: Name und Preis.

Achte hier auf die Bezeichnung der Spalte (cName, cPreis z. B.) und wähle einen entsprechenden Kopf-Text. Das Wichtigste bei der Verwendung via Datenbindung ist hier, dass Du die „DataPropertyName“-Eigenschaft setzt. Diese muss auf den Namen der zu bindenden / darzustellenden Eigenschaft gesetzt werden. In unserem Fall ist das „Name“ und „Preis“ – siehe Eigenschaften der Artikel-Klasse.

Dies ist besonders relevant, wenn Du (wie ich) lieber die sauber als Euro-Wert formatierte Variante des Preises sehen möchtest. Ergänze hierzu die Artikel-Klasse um eine passende ReadOnly-Eigenschaft:

' restliche Artikel-Klasse..

    Public ReadOnly Property LesbarerPreis As String
        Get
            Return Preis.ToString("C2")
        End Get
    End Property

' ...

Achtung bei xx.xx und xx,xx!

Beachte hierbei, dass Du ggf. oben die CultureInfo geändert hast, er würde daher nun die englische Ausgabe verwenden. Erinnere Dich hierzu, dass wir die „Sprache“ global geändert/gesetzt haben, damit er die Zahlen aus der CSV-Datei richtig verarbeitet. Du könntest hier nun z. B. die deutsche CultureInfo mitgeben, damit dies hier funktioniert:

' restliche Artikel-Klasse...

    ' Shared - bitte nicht bei jedem Abruf der Property neu instanziieren 🙈
    Private Shared deutscheCultureInfo = New CultureInfo("de-DE")

    Public ReadOnly Property LesbarerPreis As String
        Get
            Return Preis.ToString("C2", deutscheCultureInfo)
        End Get
    End Property

' ....

// restliche Artikel-Klasse...    

    // Shared - bitte nicht bei jedem Abruf der Property neu instanziieren 🙈
    private static var deutscheCultureInfo = new CultureInfo("de-DE");

    public string LesbarerPreis
    {
        get
        {
            return Preis.ToString("C2", deutscheCultureInfo);
        }
    }

// ...

Erstelle im nächsten Schritt einen Handler für das Klick-Ereignis des Buttons und den dementsprechenden Code. Um Dich nicht direkt mit dem Code zu erschlagen, teile ich Ihn in verdauliche Aspekte auf.

Was ist zu tun – der Pseudo-Code

• Unser Quell der Daten ist eine Datei -> ergo, wir brauchen Dateioperationen
• Dateipfad zusammenstückeln -> woher lesen wir?
• Datei einlesen -> Dateioperation durchführen
• Wir möchten 0, 1, oder mehrere Artikel aus der Datei bekommen -> wird verwenden einen dementsprechenden Datentyp: Array / List
• Die erste Zeile der Datei ist die Kopf-Zeile -> hier gibt es wichtige Informationen über die Struktur der Datei
• Jede sonstige Zeile beinhaltet jeweils einen Artikel

Anhand der Fakten sähe unser (erstes) Vorhaben also pseudo-code-mäßig so aus:

- Lese Zeilen aus Datei
- Verarbeite die erste Zeile, um Basis-Informationen zu erhalten
- Lese und verarbeite die restlichen Zeilen und erstelle jeweils einen Artikel daraus
- Fügen den Artikel unserer objektorientierten / virtuellen Preisliste hinzu

Dies würde näher an .NET formuliert erstmal grob wie gleich folgend aussehen. Man beachte hier von Beginn an das „Async“ Schlüsselwort – wir haben sicherlich nicht vor eine synchrone und eventuell hängende IO-Operation durchzuführen. Stell Dir vor, die Datei wäre 10MB groß, dann freut man sich hier mit der synchronen Variante sicherlich nicht! Nun zum Code:

    Private Async Sub btnPreislisteEinlesen_Click(sender As Object, e As EventArgs) Handles btnPreislisteEinlesen.Click
        Dim dateipfad = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "preisliste.csv")
        Dim zeilen = Await File.ReadAllLinesAsync(dateipfad)

        Dim artikelListe = New List(Of Artikel)()
        For Each zeile In zeilen
            Dim artikel = New Artikel()
            ' zeile verarbeiten und Artikel befüllen
            artikelListe.Add(artikel)
        Next

        ' Rest...

    End Sub

private async void btnPreislisteEinlesen_Click(object sender, EventArgs e)
{
    var dateipfad = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "preisliste.csv");
    var zeilen = await File.ReadAllLinesAsync(dateipfad);

    var artikelListe = new List<Artikel>();
    foreach (var zeile in zeilen)
    {
        var artikel = new Artikel();
        // zeile verarbeiten und Artikel befüllen
        artikelListe.Add(artikel);
    }
}

Wenn alles so einfach wäre..

Grundsätzlich würde das obige Vorgehen vermutlich erstmal aushalten, aber jeder, der mal „echte Daten“ importiert hat, wird wissen, dass das leider nicht so einfach ist. Kunden, Exporte von System, usw. spielen einem häufig eben genau das aus, was man nicht erwartet, deswegen ist jede Art von Flexibilität willkommen!

Denke z. B. an die folgende Situation – wir erwarten:

Name;Preis
Artikel 1;12.95
Artikel 2;120.95
Artikel 3;1000

Es kommt aber eine getauschte Variante.. und stell‘ Dir dies nun mit 15 vertauschten Spalten vor 🤮..

Preis;Name
12.95;Artikel 1
120.95;Artikel 2
1000;Artikel 3

Im nächsten Schritt bauen wir daher eine Funktionalität ein, Welche von selbst erkennt, wo sich die jeweiligen Spalten befinden. Wir lesen also die Header-Spalte und schauen: „Wo befindet sich der Preis?“. Dies könnte man sogar noch weiter spinnen und mit Übersetzungen, Abkürzungen und Co. machen, aber gut, ich lasse die Kirche mal wieder im Dorf.

Verfeinerung – yummy!

Die Erkennung der korrekten Spalten (Indices) wäre dementsprechend in dem Moment angebracht, wenn wir in der ersten Zeile sind. Nun kannst Du auch sehen, warum ich eine For- und keine For-Each-Schleife genommen habe. Dies kannst Du selbstverständlich so machen, wie Du es für richtig hältst. Achte nur darauf, dass Du nicht etwa in jeder Iteration irgendwie so einen Quatsch wie „IndexOf“ machst, da er sonst pro Schleifendurchlauf nochmal alle Einträge durch muss.

Da wir uns die Positionen natürlich nicht in jedem Durchlauf erneut suchen möchten (und auch nicht können, da wir nicht „nochmal“ in Zeile 0/1 sind), initialisieren wir uns die Variablen außerhalb. Ich nehme hier bewusst die -1, da man so ggf. noch prüfen könnte, ob eine jeweilige Spalte überhaupt gefunden wurde.

' außerhalb der For-Schleife
        Dim nameIndex = -1
        Dim preisIndex = -1

' innerhalb der For-Schleife 
        Dim zeile = zeilen(i)
        Dim daten = zeile.Split(";")           
        Dim ersteZeile = i = 0
        If ersteZeile Then
            For j = 0 To daten.Length - 1
                Dim headerBezeichnung = daten(j)
                If headerBezeichnung = "Name" Then
                    nameIndex = j
                ElseIf headerBezeichnung = "Preis" Then
                    preisIndex = j
                End If
            Next
            Continue For
        End If
' .. weiterer Inhalt der For-Schleife

Verarbeiten eines jeweiligen Artikels / Datensatzes

Nun ist es an der Zeit, den Datensatz, also die Zeile eines jeweiligen Artikels zu verarbeiten. Wir kennen an dieser Stelle bereits die Positionen der jeweiligen Informationen können daher also direkt damit arbeiten. Hier eine Möglichkeit den Artikel zu befüllen, man könnte freilich auch einen passenden Konstruktor verwenden:

' Innerhalb der For-Schleife...
    Dim artikel = New Artikel()
    artikel.Name = daten(nameIndex)
    artikel.Preis = Convert.ToDecimal(daten(preisIndex))
    artikelListe.Add(artikel)
' ...

// Innerhalb der For-Schleife...
var artikel = new Artikel();
artikel.Name = daten(nameIndex);
artikel.Preis = Convert.ToDecimal(daten(preisIndex));
artikelListe.Add(artikel);
// ...

    Private Async Sub btnPreislisteEinlesen_Click(sender As Object, e As EventArgs) Handles btnPreislisteEinlesen.Click
        Dim dateipfad = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "preisliste.csv")
        Dim zeilen = Await File.ReadAllLinesAsync(dateipfad)

        Dim nameIndex = -1
        Dim preisIndex = -1

        Dim artikelListe = New List(Of Artikel)
        For i = 0 To zeilen.Length - 1
            Dim zeile = zeilen(i)
            Dim daten = zeile.Split(";")

            Dim ersteZeile = i = 0
            If ersteZeile Then
                For j = 0 To daten.Length - 1
                    Dim headerBezeichnung = daten(j)
                    If headerBezeichnung = "Name" Then
                        nameIndex = j
                    ElseIf headerBezeichnung = "Preis" Then
                        preisIndex = j
                    End If
                Next
                Continue For
            End If

            Dim artikel = New Artikel()
            artikel.Name = daten(nameIndex)
            artikel.Preis = Convert.ToDecimal(daten(preisIndex))
            artikelListe.Add(artikel)
        Next
        DataGridView1.DataSource = artikelListe
    End Sub

private async void btnPreislisteEinlesen_Click(object sender, EventArgs e)
{
    var dateipfad = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "preisliste.csv");
    var zeilen = await File.ReadAllLinesAsync(dateipfad);

    var nameIndex = -1;
    var preisIndex = -1;

    var artikelListe = new List<Artikel>();
    for (var i = 0; i <= zeilen.Length - 1; i++)
    {
        var zeile = zeilen(i);
        var daten = zeile.Split(";");

        var ersteZeile = i == 0;
        if (ersteZeile)
        {
            for (var j = 0; j <= daten.Length - 1; j++)
            {
                var headerBezeichnung = daten(j);
                if (headerBezeichnung == "Name")
                    nameIndex = j;
                else if (headerBezeichnung == "Preis")
                    preisIndex = j;
            }
            continue;
        }

        var artikel = new Artikel();
        artikel.Name = daten(nameIndex);
        artikel.Preis = Convert.ToDecimal(daten(preisIndex));
        artikelListe.Add(artikel);
    }
    DataGridView1.DataSource = artikelListe;
}

Darstellen im DataGridView

Nun fehlt nur noch ein letzter Schritt, um unseren verarbeiteten Artikeldaten in unserer Tabelle (DataGridView) darstellen zu können. Füge dazu einfach den gleich folgenden Code nach der For-Schleife ein. Vergiss allerdings nicht, dass Du die Konfiguration der Spalten oben tätigen solltest!

' For Schleife

' For Schleife Ende

' artikelListe = Deine Variable (vom Typ List(Of Artikel)), Welche die verarbeiteten Artikel beinhaltet
DataGridView1.DataSource = artikelListe

Kompletter Code

Hast Du es eilig? Kein Problem, kenne ich! Nimm Dir, was Du brauchst einfach hier weg, oder lade das Beispielprojekt weiter unten herunter. Bevor die Wörter-Polizei kommt: „Artikäl“ ist mit Absicht so geschrieben..

Die Preisliste.csv

Name;Preis;
Artikäl 1;15,95;
Artikel 2;49,95;
Artikel 3;120,95;

Die Artikel-Klasse

Public Class Artikel

    Public Property Name As String

    Public Property Preis As Decimal

    Public ReadOnly Property LesbarerPreis As String
        Get
            Return Preis.ToString("C2")
        End Get
    End Property

    Sub New()

    End Sub

End Class

public class Artikel
{
    public string Name { get; set; }

    public decimal Preis { get; set; }

    public string LesbarerPreis
    {
        get
        {
            return Preis.ToString("C2");
        }
    }

    public Artikel()
    {
    }
}

Der Form-Code

Imports System.IO

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        'Dim enUsCulture = New CultureInfo("de-DE")
        'Thread.CurrentThread.CurrentCulture = enUsCulture
        DataGridView1.AutoGenerateColumns = False
    End Sub

    Private Async Sub btnPreislisteEinlesen_Click(sender As Object, e As EventArgs) Handles btnPreislisteEinlesen.Click
        Dim dateipfad = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "preisliste.csv")
        Dim zeilen = Await File.ReadAllLinesAsync(dateipfad)

        Dim nameIndex = -1
        Dim preisIndex = -1

        Dim artikelListe = New List(Of Artikel)
        For i = 0 To zeilen.Length - 1
            Dim zeile = zeilen(i)
            Dim daten = zeile.Split(";")

            Dim ersteZeile = i = 0
            If ersteZeile Then
                For j = 0 To daten.Length - 1
                    Dim headerBezeichnung = daten(j)
                    If headerBezeichnung = "Name" Then
                        nameIndex = j
                    ElseIf headerBezeichnung = "Preis" Then
                        preisIndex = j
                    End If
                Next
                Continue For
            End If

            Dim artikel = New Artikel()
            artikel.Name = daten(nameIndex)
            artikel.Preis = Convert.ToDecimal(daten(preisIndex))
            artikelListe.Add(artikel)
        Next
        DataGridView1.DataSource = artikelListe
    End Sub

End Class

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Text;
using System.Threading.Tasks;
using Microsoft.VisualBasic;

public class Form1
{
    private void Form1_Load(object sender, EventArgs e)
    {
        // Dim enUsCulture = New CultureInfo("de-DE")
        // Thread.CurrentThread.CurrentCulture = enUsCulture
        DataGridView1.AutoGenerateColumns = false;
    }

    private async void btnPreislisteEinlesen_Click(object sender, EventArgs e)
    {
        var dateipfad = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "preisliste.csv");
        var zeilen = await File.ReadAllLinesAsync(dateipfad);

        var nameIndex = -1;
        var preisIndex = -1;

        var artikelListe = new List<Artikel>();
        for (var i = 0; i <= zeilen.Length - 1; i++)
        {
            var zeile = zeilen(i);
            var daten = zeile.Split(";");

            var ersteZeile = i == 0;
            if (ersteZeile)
            {
                for (var j = 0; j <= daten.Length - 1; j++)
                {
                    var headerBezeichnung = daten(j);
                    if (headerBezeichnung == "Name")
                        nameIndex = j;
                    else if (headerBezeichnung == "Preis")
                        preisIndex = j;
                }
                continue;
            }

            var artikel = new Artikel();
            artikel.Name = daten(nameIndex);
            artikel.Preis = Convert.ToDecimal(daten(preisIndex));
            artikelListe.Add(artikel);
        }
        DataGridView1.DataSource = artikelListe;
    }
}

Downloads

Du brauchst ein schnelles Code-Beispiel, um alles in eigener Hand ausprobieren zu können? Dann lade es Dir hier einfach kostenlos das herunter!

Weiterführende Links

Vielleicht ist auch einer der folgenden Beiträge für Dich interessant:

• Ini Dateien lesen und schreiben
• Chikarten und Tags mit VB.NET und Arduino auslesen
• Wie man ein eigenes VB.NET Plugin-System baut

Der Beitrag Eine CSV-Preisliste mit VB.NET einlesen – 2024-Version erschien zuerst auf Robert Skibbe.

RFID Chips mit Visual Basic .NET und dem Arduino Mikrocontroller auslesen

Wer in VB.NET Daten aus einem RFID-Chip auslesen möchte, trifft unter normalen Umständen vermutlich auf die handelsüblichen Geräte. Ruckzuck an den PC angeschlossen sind Sie auch schon startklar, uns die ausgelesenen Daten als Tastatur-Input bereitzustellen. Gleichzeitig liegt genau hier das Problem, jedoch gleich mehr dazu. Im heutigen Beitrag beschäftigen wir uns also mit einem RFID-Scanner der Marke Eigenbau und schauen uns die Verarbeitung mit VB.NET an.

Zu den bekannten Einsatzgebieten der kleinen RFID-Sensoren zählen unter anderem: Zugangs- und Zugriffskontrollen wie z. B. Ticketsysteme und Türen, aber ebenso bei unseren tierischen Freunden und sogar im Ausweis finden Sie Ihre Anwendung. Selbst beim Einkauf können wir mit der RFID-Technologie kontaktlose Bezahlvorgänge durchführen und somit unseren Alltag erleichtern.

💡 Achtung: In diesem Beitrag geht es in erster Linie um die Verarbeitung der RFID-Daten seitens VB.NET. Ich werde in einem zukünftigen Beitrag noch die Seite des Mikrocontrollers (Arduino Nano, Mega, whatever) erläutern. Hier beschäftigen wir uns ein wenig mit den Aspekten wie Handhabung und Sicherheit. Ich verwende in diesem Beitrag Affiliate-Links, womit Du mich vollkommen kostenlos bei einem Kauf über die Links unterstützen kannst.

VB.NET RFID Reader aus dem Handel = meist „Tastatur-a-like only“

Kommen wir nochmal genauer auf das Problem mit der angesprochenen Tastatur-Emulation (wenn das der exakt korrekte Ausdruck ist..) zurück. Wenn wir mit solchen Geräten, bzw. Sensoren wie einem RFID-Scanner arbeiten möchten, dann natürlich so flexibel wie möglich. Man stellt sich also vor, man startet seine Anwendung, lässt Sie in Ruhe laufen und wenn man loslegen will, kommt ein Kollege und möchte sich „eben“ im System anmelden.

Dies funktioniert mit den gängigen Geräten im Discount-Bereich häufig nicht, da Diese zwangsweise eine fokussierte Oberfläche (TextBox, etc.) benötigen. Das ist freilich nicht gerade cool, wenn wir eine Bestellung bearbeiten und zig Daten neu eingeben müssten, nachdem unser Kollege fertig ist. Schöner wäre es hingegen, wenn unser Kollege seinen Chip einscannt, eine kleine Maske kommt und er seine 2–3 Eingaben so erledigen könnte. Anschließend könnten wir dann mit unserer Arbeit fortfahren und wir wären durch.

Sicherlich gibt es vermutlich auch andere Varianten, Welche dann zig andere Funktionen unterstützen, aber hier bewegen wir uns dann auch zumeist im vergleichsweise teureren Preis-Segment. Leider bieten die handelsüblichen Geräte also häufig nur eine Art „nix Halbes und nix Ganzes“-Lösung. Das Gerät emuliert häufig einfach nur eine Art Tastatur, Welche dann die einzelnen Daten-Bestandteile runterschreibt und häufig mit einem „Enter“ bestätigt.

Was benötigen wir für den VB.NET RFID Reader

Bedenke den blauen Hinweis oben, dass wir in diesem Beitrag vorerst nur die VB.NET Seite der Medaille betrachten. Trotzdem möchte ich hier eben noch einmal die verwendeten Dinge auflisten, alles Weitere wird dann in einem zukünftigen Beitrag ergänzend erscheinen.

Wir benötigen also:

• Einen Mikrocontroller wie z. B. den Arduino Nano in meinem Fall
• Die Arduino IDE (am häufigsten verwendet)
• Ein RFID Kit (häufig bestehend aus Sensor, Pins und Chipkarten/Anhänger)
• Ausreichend Jumper-Kabel (je nach Setup – hier 7 male to female)
• 1 Mini-USB Kabel zur Verbindung des Arduinos zum PC (eigentlich immer beim Arduino dabei..)

Nachdem wir nun von den Hardware-Komponenten erstmal startklar sind, widmen wir uns nach der Verbindung endlich dem Visual Basic NET Code.

Den RFID Scanner mit unserem PC verbinden

Ebenso einfach wie der oben beschriebene Weg mit den handelsüblichen RFID Scanner-Geräten, verfahren wir auch mit unserem Eigenbau. Verbinde den Arduino mithilfe eines Mini-USB Kabel mit einem USB-Port Deiner Wahl. Es sollte dann ein normales „Pling-Plong“-Geräusch kommen, Welches wie üblich das Anschließen eines neuen Gerätes signalisiert.

Verbindungsprobleme

Natürlich kann auch hier das ein oder andere Problem auf Dich zukommen, so traf es auch mich – Thema Treiber.. Um den typischen CH340 Chip erkennbar und zum Laufen zu bringen, installierst Du den für Dein System passenden Treiber. Danach wirst Du vermutlich zu einem Neustart Deines PCs aufgefordert, Welchen Du auch – um weitere Fehlerquellen zu vermeiden – durchführen solltest.

💡 Achtung: Bei der Treiber-Seite handelt es sich um einen chinesischen Anbieter. Achte auf das für dich passende Paket und verwende ggf. die z. B. in Chrome vorhandene Übersetzungs-Funktion. Grundsätzlich ist das dicke blaue Download-Icon aber nicht zu übersehen. Der „341SER.zip“-Treiber sollte auch für die 340er Variante funktionieren. Gerne würde ich Dir den Treiber ebenfalls zum Download anbieten, aber ich möchte vermeiden, dass Du nachher mit einem veralteten Treiber arbeitest.

Öffne dann einfach die „SETUP.exe“ im „CH341SER“-Ordner und klicke auf „install“:

Starte anschließend Deinen PC wie gesagt am besten neu, damit Du keine eventuellen Installations-, bzw. Erkennungsprobleme hast. Danach sollte der CH340 Chip ganz normal als COM-Port im Gerätemanager auftauchen (natürlich nur wenn tatsächlich physisch verbunden – Captain Obvious..):

Code – RFID-Daten über VB.NET auslesen

Kommen wir nun zum vermutlich heißt ersehnten VB.NET Code zum Auslesen der jeweiligen RFID-Daten. Im Mittelpunkt aller Dinge steht hier die SerialPort-Klasse, Welche Du ggf. noch via NuGet-Paket installieren musst. Suche dazu am besten im NuGet-Paketmanager nach „System.IO.Ports“, oder verwende diesen Link, dort drin befindet sich die Klasse. Nachdem wir jetzt über die erforderlichen Mittel für die Kommunikation via COM-Ports besitzen, können wir starten.

Lege z. B. eine .NET 6 Windows Forms App an und gehe wie gewohnt mit F7 in den Code hinter der Form. Zuerst legen wir (je nach Belieben/gewünschten Einschränkungen) eine Eigenschaft namens „Connection“ an, Welche unsere SerialPort-Verbindung widerspiegeln wird.

Public Property Connection As SerialPort

Als nächstes fügen wir noch ein „Dictionary“ für eine Zuweisung von Uids (Strings – die Ids der gescannten Chips) zu Nutzern (User-Klasse) hinzu. Beachte hierbei, dass ich mit einer generischen Variante, also einem Interface arbeite, alternativ kannst Du das große „i“ auch weglassen. Die User-Klasse erstellen wir gleich und dient nur zur Veranschaulichung.

Public Property UidsToUser As IDictionary(Of String, User)

Vorbereiten der Verbindung

Erstelle als Nächstes einen Konstruktor für die Form, indem Du „Sub New“ innerhalb der „Form1“-Klasse tippst und mit „Enter“ bestätigst. Dann sollte Visual Studio Dir ein grobes Skelett für den Konstruktor generieren, diesen passen wir wie folgt an:

    Sub New()
        InitializeComponent()
        Connection = New SerialPort("COM3", 9600, Parity.None, 8, StopBits.One)
        AddHandler Connection.DataReceived, AddressOf Connection_DataReceived
    End Sub

Zuerst lassen wir die von Haus aus kommende „InitializeComponent“-Methode unangetastet, da unsere eventuellen Form-Steuerelemente sonst nicht funktionieren würden. Danach instanziieren wir eine neue Instanz der Klasse „SerialPort“ mit einigen Werten.

• COM3 – steht für den für die Kommunikation zu wählenden COM-Port. In meinem Fall steckt mein Arduino am COM-Port Nr. 3.
• 9600 – ist die sogenannte Baudrate und regelt die „Kommunikationsgeschwindigkeit“ zwischen Arduino und PC. Achte hier darauf, dass Du den gleichen Wert wie in Deinem Arduino Sketch unter „Serial.Begin(<der Wert>)“ wählst.

Dann stellen wir noch gewisse andere Dinge wie die Parität, die Daten-Bits und die Stop-Bits ein. (Ich erspare Dir jede einzelne Erklärung hier..).

Im letzten Konstruktor-Schritt bezüglich der SerialPort-Verbindung fügen wir auch noch einen Ereignishandler für das „DataReceived“-Ereignis hinzu.

Verbindung starten

Danach können wir einen weiteren Handler generieren, hierbei handelt es sich um den Ereignishandler für das „Form Load“-Ereignis. Darin werden wir dann die Verbindung zum Arduino (über den SerialPort) öffnen, ansonsten können wir natürlich nicht kommunizieren 😉.

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Connection.Open()
    End Sub

Auf Daten reagieren/lauschen

Nun müssen wir den oben zugewiesenen (aber bisher nicht existenten) Ereignishandler für das „DataReceived“-Ereignis erstellen. Das geht erstmal ganz einfach wie folgt:

    Private Sub Connection_DataReceived(sender As Object, e As SerialDataReceivedEventArgs)
        Dim text = Connection.ReadLine().TrimStart().TrimEnd()
        If text.StartsWith("RFID:") Then
            Dim uid = text.Split(":")(1)
            Invoke(Sub() OnUidScanned(uid))
        End If
    End Sub

💡 Achtung: Ich habe seitens des Arduino-Codes sichergestellt, dass wir mit einem Zeilenumbruch arbeiten/kommunizieren. Daher kann ich hier mit dem „ReadLine“-Befehl arbeiten. Beachte allerdings bei Deinen geplanten Projekten, dass das „DataReceived“-Ereignis (wie der Name schon sagt) lediglich sagt: „Ey, hier sind Daten“ – das heißt aber nicht, dass ALLE Daten da sind, die Du Dir vorstellst. Da wir hier aber mit einer kleinen Datenmenge a la „RFID:DieUid“ arbeiten, werden wir hier aller Voraussicht nach kein Problem bekommen. Wenn Du allerdings ellenlange Texte hin und her schiebst, könnte es zu einem Problem werden – aber auch dazu in einem anderen Beitrag mehr..

Nun lesen wir mit „ReadLine“ die Daten ein und „säubern“ Diese anschließend durch Verkettung von „TrimStart“ und „TrimEnd“. Das verhindert unnötige und unerwartete Leerzeichen, kann aber natürlich auch durch saubere Programmierung am Arduino verhindert werden..

Nun vor-verarbeiten

Grundsätzlich haben wir den Text, Welcher vom Arduino kommt endlich vorliegen und können Ihn verarbeiten. Beachte, dass ich hier ein kleines „Protokoll“ einhalte, auch wenn es nur praktisch gesehen aus einem Teil besteht. Ich halte mich an meine Regel, dass ich beim erfolgreichen Einlesen eines RFID-Chips den String „RFID:“ gefolgt von der Uid-Zeichenfolge und einem Zeilenumbruch durch den SerialPort jage.

Ergo muss ich mich natürlich an der Gegenstelle (VB.NET) daran halten und die Daten dementsprechend auslesen und verarbeiten. Das mache ich dann im nächsten Schritt, indem ich prüfe, ob die eingelesenen Daten mit einem „RFID:“ beginnen. Ich splitte also den String anhand des Doppelpunktes und nehme mir den zweiten Teil des Strings als Uid.

Daten an die UI delegieren

Anders als gedacht sollte man hier normalerweise nun nicht mit einer Art „ich update mal jetzt direkt die UI a la Label1.Text = …“ arbeiten. Das liegt daran, dass das Ereignis vom SerialPort (und somit unser Handler) meines Wissens nach auf einem anderen Thread als die UI ausgeführt wird. Von dort aus also nun auf die grafische Oberfläche zuzugreifen sollte aller Wahrscheinlichkeit nach einen „Cross Thread bla blupp“-Fehler auslösen.

Um dies zu vermeiden, verwende ich die „Invoke“-Methode der Form in Kombination mit einem inline definierten Delegaten („Sub() <etc>..“). Dieser Delegat hat einen zugrunde liegenden Aufruf namens „OnUidScanned“ – mit dem passenden String-Parameter. Alternativ könntest Du hier auch mit einem „BeginInvoke“-Aufruf arbeiten, dies lässt den Aufrufer nicht auf den Abschluss des Codes warten.

Reine Erkennung von Uids fertig – und nun?

An dieser Stelle haben wir unser Grundgerüst, was das Auslesen und „parsen“ der Uids der Chips betrifft fertig. Nun wirst Du Dich hoffentlich fragen – ja cool, und was nun? Nur Geduld junger Padawan, es geht direkt weiter. Als Nächstes definieren wir (in .NET-Manier) eine typische Ereignis-Methode namens „On…“. Diese kann bei Bedarf in Sub-Klassen überschrieben werden und dient als Basis für unser eigenes Ereignis.

Erstelle nun am Ende der Datei (da lege ich die Ereignisse eigentlich immer ab) ein Ereignis wie das Folgende. Beachte dabei, dass man normalerweise eine eigene von EventArgs abgeleitete Klasse für die Ereignisinformationen verwenden sollte, darauf habe ich hier verzichtet. Unser Ereignis beinhaltet nur die Uid-Information, also einen simplen String.

Public Event UidScanned As EventHandler(Of String)

Die passende „On“-Methode würde also so aussehen:

    Protected Overridable Sub OnUidScanned(uid As String)
        RaiseEvent UidScanned(Me, uid)
    End Sub

Zu guter Letzt verknüpfen wir nun unser eigens erstelltes Ereignis via Handles-Klausel mit einer passenden Methode als Handler:

    Private Sub Me_UidScanned(sender As Object, uid As String) Handles Me.UidScanned
        Dim user As User = Nothing
        UidsToUser.TryGetValue(uid, user)
        If user Is Nothing Then
            MessageBox.Show("Login failed!")
            Return
        End If
        MessageBox.Show($"Hey {user.Name}!")
    End Sub

Hier initialisieren wir zuerst eine leere Variable namens „User“, Welche anschließend durch die „TryGetValue“-Funktion der generischen Dictionary Klasseninstanz befüllt werden sollte. Wenn kein zur Uid passender Nutzer ermittelt werden konnte, wird hier eine kleine „Login failed!“-Meldung ausgegeben. Ansonsten zeigen wir testweise den Namen des jeweils ermittelten Nutzers an.

💡 Achtung: Hier noch der Hinweis, dass es sich hierbei keinesfalls um einen „production ready“ Code handelt. Das Beispiel dient lediglich zur Veranschaulichung des Empfangs von seriellen Sensordaten via SerialPort. Jeder mit einigermaßen vorhandenen Disassembler-Kenntnissen würde in wenigen Sekunden an die jeweiligen Chip-Uids kommen. Normalerweise sollte das Programm nur als Schnittstelle dienen, also die Daten einlesen und an eine passende (Web-) Schnittstelle zur Verarbeitung weiterleiten. Wenn sicher über Https übertragen, könnte die Schnittstelle also anhand der Uid einen passenden Nutzer aus der Datenbank laden und einen Zugriff ermöglichen. Auch wenn ich diesen Satz hasse: „..aber das würde den Rahmen sprengen“ / „The princess is in another castle“ – wenn Du mich verstehst 😛..

Die User-Klasse

Bevor ich es vergesse, hier noch die verwendete, simple User-Klasse:

Public Class User

    Public Property Name As String

    Sub New(name As String)
        Me.Name = name
    End Sub

    Public Overrides Function ToString() As String
        Return Name
    End Function

End Class

Weitere Links

• Arduino RFID Scanner
• Virtuelle COM Ports emulieren mit com0com

Downloads

Wie immer findest Du hier am Schluss den vollständigen Download des (VB.NET) Codes. Ggf. ergänze ich der Vollständigkeit halber trotzdem noch den Arduino-Code, ansonsten wird Dieser später in dem getrennten Arduino-Teil kommen.

Der Beitrag 🔑 VB.NET RFID Scanner – Chips mit dem Arduino Mikrocontroller auslesen erschien zuerst auf Robert Skibbe.

VB NET MouseMove – Mausposition durch Code setzen

Du möchtest einen „VB NET MouseMove„-Befehl realisieren, aber weißt nicht ganz wie Du das anstellen sollst?

Lerne im diesmaligen Beitrag, wie Du in VB NET eine Mausbewegung via Code ausführen kannst.

Zugehörig zu den anderen AutoIt3-Beiträgen, fahre ich mit der kleinen Serie hier nun fort.

Du brauchst Dir auch keine besonderen Sorgen über die Speichergröße der hier verwendeten Hilfsmittel machen.

Darauf gehe ich aber zu einem späteren Zeitpunkt noch einmal kurz ein.

Auch wenn Du damit vermutlich keinen „OSU!„-Bot bauen kannst denke ich, dass es hier und da sehr hilfreich sein kann!

Auf YouTube ansehen – VB NET MouseMove simulieren

Wenn Du lieber ein Video sehen möchtest, statt Dich durch den Beitrag zu lesen, kannst Du das hier auch tun.

Gerne schweife ich in meinen Beiträgen auch mal ab und bringe hier und da Nebeninformationen rein.

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

Sicherlich ist man vom Fernseher und von Videos gewohnt, hier und da mal durch zu zappen.

Ich finde allerdings, dass das Scrollen zu bestimmten Überschriften einfacher und leichter von der Hand geht.

Glücklicherweise hat YouTube seit längerer Zeit eine Art Kapitelübersicht hinzugefügt.

Wie ich auf den Beitrag kam

Auch wenn wir damit wie oben schon erwähnt vermutlich keinen „OSU!“-Bot bauen können, geht dennoch einiges.

In Kombination mit den anderen unten verlinkten Funktionalitäten kann man so manches realisieren.

Ich selbst kam nicht selten in die Versuchung gewisse Tools zur Erleichterung meiner Arbeit und auch des Gamings zu umzusetzen.

Daher beschäftigen wir uns in diesem Beitrag damit, wie man gewisse Mausbewegungen via Code steuern kann.

Im nächsten Teil des Beitrags schauen wir dazu allerdings erstmal die notwendigen Tools an.

Danach beschäftigen wir uns mit dem Aufsetzen des Visual Studio Projektes und der Installation der notwendigen Bibliotheken.

Nicht ohne Hilfe – wir nutzen AutoIt

Für unser Vorhaben, Welches auch roh in VB NET möglich wäre, verwenden wir hier allerdings bewusst die Bibliothek von AutoIt3.

Ich habe im „ImageSearch“-Beitrag schon einmal angesprochen dass viele Entwickler kritisch mit der Speichergröße der Projekte umgehen.

In erster Linie ist das natürlich völlig nachvollziehbar, da ich selbst ein Freund des KISS (Keep It Smart and Simple) bin.

Ich denke allerdings, dass es Situationen gibt, wo man es auch übertreiben kann.

In Festplatten–Generation „Terrabyte zum Preis von damaligen 80GB“ nörgle ich nicht für 1MB rum.

Das was letztendlich zählen sollte, ist die Relation zwischen Aufwand und Erfolg, bzw. das Erreichen des Ziels.

In intelligent entwickelten, bzw. strukturierten Programmen ist der spätere Austausch kein Problem.

Daher immer schön sauber mit Interfaces und deren Implementierungen arbeiten *zwinker*.

Ein neues Projekt anlegen und in Visual Studio vorbereiten

Nun wären wir an der Stelle, die notwendigen Libraries herunterzuladen.

Erledige das gern direkt hier, oder suche Dir anderweitige Quellen im Netz dafür.

Erstelle danach einfach ein neues Windows Forms-, oder ein WPF-Projekt.

Füge die „AutoItX3.Assembly.dll„-Datei nun als Verweis hinzu, damit wir Diese im Code nutzen können.

Relativ simpel geht das in Visual Studio zum Beispiel außen rechts über den Projektmappen-Explorer.

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

Neben dem genannten Weg, gibt es auch noch andere Möglichkeiten, zum Beispiel über das obige „Hauptmenü“.

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.

Der Code – VB NET MouseMove

Nun kommen wir endlich an den Punkt, wo wir uns an den Code heranwagen.

Nachdem Du alle Vorbereitungen abgeschlossen hast, kann Du nun den Namespace importieren.

Dadurch kannst Du dann auf die benötigte Klasse zugreifen:

Imports AutoIt

Durch die nun verfügbare Klasse „AutoItX„, können wir jetzt die Mausbewegungen an sich realisieren.

Klicke Dir nun vielleicht noch vorher eine GUI wie Diese hier, mit 2 Labels, 2 Textboxen und einen Button zurecht:

Die beiden Labels sollen Dich auch noch in einem halben Jahr dran erinnern, welche Inputs wohin müssen.

Bei den Textboxen verzichten wir bei der Eingabe der Koordinaten in diesem Beispiel auf eine Prüfung.

Wir prüfen also nicht explizit, ob es sich dabei wirklich um Zahlen handelt, etc.

Anschließend holen wir uns die Koordinaten aus den Textboxen und wandeln Diese um.

Dafür verwenden wir natürlich den korrekten Datentyp namens Integer:

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

Nun kommen wir zum goldenen Teil des Beitrages, also der Durchführung der Mausbewegung selbst.

Dazu benutzen wir die importierte Klasse „AutoItX“ in Kombination mit den gerade festgelegten Koordinaten.

Optional könntest Du auch noch eine Art Geschwindigkeit der Bewegung, bzw. der „Animation“ festlegen .

Dim movementSpeed = 50
AutoItX.MouseMove(x, y, movementSpeed)

Als nächstes möchte ich die Parameter noch der Vollständigkeit halber erläutern, oder eher auflisten.

Detailliertere Informationen findest Du auf der offiziellen Seite, bzw. der offiziellen Dokumentation:

MouseMove-Parameter

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.

speed As Integer

Gibt die Geschwindigkeit der Bewegung an.

Der komplette Code – TL;DR

Obwohl der Code hier vermutlich nicht durch seine Quantität glänzt, hier nochmal alles in einem Stück.

Imports AutoIt

Public Class Form1

    Private Sub btnMoveMouse_Click(sender As Object, e As EventArgs) Handles btnMoveMouse.Click
        Dim x = Integer.Parse(tbX.Text)
        Dim y = Integer.Parse(tbY.Text)
        Dim moveSpeed = 50
        AutoItX.MouseMove(x, y, moveSpeed)
    End Sub

End Class

Weiterführende Links

• Visual Basic NET MouseClick simulieren
• VB NET ImageSearch in Spielen, auf dem Desktop, etc.
• Visual Basic .NET Texterkennung auf Bildern via Google Cloud Vision API [OCR]

Downloads

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

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

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

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

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:

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

• VB NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen
• VB NET Web API – Währungskurs Service Konsum von Grund auf erklärt
• VB.NET Texterkennung auf Bildern via Google Cloud Vision API [OCR]

Downloads

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

VB.NET Texterkennung auf Bildern [OCR]

Du möchtest eine VB.NET Texterkennung auf Bildern umsetzen, weiß nur noch nicht ganz wie?

Kein Problem! In meinem heutigen Beitrag und dem dazugehörigen YouTube-Video, erkläre ich es Dir!

Dazu brauchst Du nicht viel mehr als ein passendes NuGet-Package von Google und die passenden Zugangsdaten.

Im Videoformat auf YouTube ansehen

Falls Du Dir das Tutorial lieber in flüssigerer Form ansehen möchtest, kannst Du Dir selbstverständlich auch das folgende YouTube-Video ansehen.

Dort zeige ich Dir alles Schritt für Schritt und im Detail, wie Du Deine Texterkennung „ready to go“ machst.

Ebenso weise ich Dich auf diverse Dinge wie Fehlermeldungen und Nutzungskontingente der „Google Cloud Vision“-Schnittstelle hin.

Einsatzmöglichkeiten und Hintergründe

Die Einsatzmöglichkeiten der optischen Zeichenerkennung sind breit gestreut.

Mit der Verwendung der „optical character recoginition“ (kurz OCR) können z. B. viele Bereiche im Arbeitsalltag erleichtert werden.

Häufig vertreten ist die OCR beispielweise im Bereich der Finanzen, Steuerdokumente etc. automatisch eingelesen und abgeglichen werden.

Dies hat natürlich den Vorteil, dass man kein zusätzliches Personal benötigt, um die Arbeit zu erledigen.

Neben dem personellen Faktor und den damit verbundenen Kosten an sich, ist eine automatisierte Variante durch OCR natürlich auch performanter.

Man kann also den (denke ich) wichtigsten Bereich als Digitalisierung von Dokumenten bezeichnen.

Meine eigene Story zur OCR

Ich selbst bin hier und da mal aus verschiedenen Gründen auf das Thema OCR gestoßen.

Wir Du oben im Video eventuell gesehen hast, verwende ich dort eine Yu-Gi-Oh!-Karte.

Für die weniger „Trading-Cardgame“ orientierte Leser, ist Yu-Gi-Oh! praktisch nur ein Sammelkartenspiel, wo es verschiedene Arten von Karten gibt.

Darunter befinden sich Monster, Zauber- und Fallenkarten und mehr, Welche selbst unterschiedliche Funktionen im Spiel selbst haben.

Wie fast immer, wenn wir über eines der Lieblingsthemen des Menschen, also das Sammeln nachdenken, gibt es natürlich auch einen gewissen Wert.

Während normale „Common“-Karten zu Centbeträgen, bzw. überhaupt gehandelt werden, gibt es auch durchaus Wertvollere.

Wenn man den folgenden Betrag, der „Tournament Black Luster Soldier“-Karte hört, könnte man glatt in Ohnmacht fallen.

Setze Dich also daher besser hin, wenn Du nicht sowieso schon auf Deinem Stuhl o. Ä. Platz genommen hast.

Die teuerste Karte der Welt

Die laut meiner Erfahrung teuerste Karte der Welt soll round about 2 Millionen US-Dollar kosten, ja richtig gelesen.

Diese Karte wurde im Jahr 1999 in Japan im Rahmen einer Yu-Gi-Oh!-Meisterschaft an den Gewinner übergeben.

Ich selbst kannte mich durchaus gut im Bereich Yu-Gi-Oh! aus, hatte aber natürlich keine Lust meine Karten manuell durchzuschauen.

Im Endeffekt denke ich mir natürlich: „Wofür kannst Du denn programmieren?“.

So begann ich damals mich mit OCR auseinanderzusetzen und die Google Cloud Vision API zum Laufen zu bringen.

Mit einer Webcam bin ich dann letztendlich die einzelnen Karten durchgegangen und so Karte für Karte überprüft.

Gerne hätte ich hierfür eine Art Maschine gehabt, die also auch das Aufheben- und Ablegen von Karten unterstützte.

Diese Maschinen gibt es auch, kosten aber leider ein paar tausend Euro – ich hatte sogar die Idee selbst eine zu bauen, habe Diese aber verworfen.

Wie sich herausstellte hatte ich in meiner Sammlung hier und da ein paar gute Karten versteckt.

Darunter befand sich unter anderem eine „Elementarheld Bubbleman“-Karte, Welche ich für ca. 34€ auf eBay verkaufen konnte – nice!

Bis heute bin ich auch noch stolzer Besitzer einer „Wolkenkratzer“-Karte, Welche einen Fehldruck besitzt, es fehlt dort der Aufdruck des Titels.

Nun aber genug vom Trading Card Game und zurück zum eigentlichen Thema – VB.NET Texterkennung auf Bildern.

Google Cloud Vision API

Die Google Cloud Vision API dient der Erkennung von Daten auf Bildern und kann somit in vielen Bereichen eine Hilfe sein.

Durch die einfache, intuitive Verwendung und die einfache Installation via NuGet-Paket-Manager lässt Dich schnell starten.

Schreibe doch gerne in die Kommentare unten und lass mich wissen, wofür Du die Google Cloud Vision API verwendest!

Die Dokumentation zur API für z. B. weitere Recherche, findest Du im angegeben Link.

Die Anwendung – VB.NET Texterkennung auf Bildern

Einen Einblick in das fertige Beispiel siehst Du hier im animierten Gif-Bild.

Die Datei, bzw. das Bild wird hier eingelesen und anschließend mit der API von Google ausgewertet.

Anschließend verarbeiten wir die vom Server verarbeiteten Daten, wie wir es letztendlich möchten.

Installation des NuGet-Paketes

Der erste Schritt in Richtung Ziel ist es, das von Google bereitgestellte NuGet-Paket für die Google Cloud Vision API zu installieren.

Das geht entweder über den Paketmanager, oder direkt über die NuGet-Paket-Manager-Konsole.

In der Konsole führen wir einfach den folgenden Befehl aus und alles Notwendige wird installiert.

Ich verwende hier erfolgreich die angegebene Version „2.3.0“:

Install-Package Google.Cloud.Vision.V1 -Version 2.3.0

Alternativ kann man laut Google-Dokumentation auch diesen Befehl hier verwenden:

Install-Package Google.Apis

Allerdings hört sich das für mich so an, als würde man hier praktisch alle möglichen APIs installieren, Du kannst es ja mal testen..

Dienstkonto erstellen – VB.NET Texterkennung auf Bildern

Im nächsten Schritt müssen wir für die Verwendung der API ein Dienstkonto erstellen, dafür findest Du den passenden Button auf der verlinkten Seite von Google.

Falls Du noch kein Projekt hast (war bei mir nicht der Fall), musst Du ggf. noch ein Projekt erstellen, das dürfte aber nicht weiter schwer sein.

Nachdem Du ein Projekt zur Verfügung hast, wählst Du Dieses aus und kannst das Dienstkonto erstellen:

Ich habe für meine Testzwecke einfach nur „fueryoutube“ eingetragen und die optionalen Felder einfach leer gelassen.

Schlüssel erstellen

Wenn das Dienstkonto erstellt ist, kannst Du dort nun einen Schlüssel im dementsprechenden Tab erstellen (JSON):

Schlüssel als JSON herunterladen

Die JSON Datei wird dann heruntergeladen und ist für unseren Code verwendbar:

Nachdem wir nun fürs Erste mit der Google-Konfiguration fertig sind, können wir dann endlich zum Code starten.

Code – VB.NET Texterkennung auf Bildern

Nun können wir uns dem Code und somit dem eigentlichen Spaß, also der VB.NET Texterkennung auf Bildern widmen – seufz..

Konstanten

Im ersten Schritt legen wir 3 Konstanten an, Welcher diverse Werte speichern werden.

Public Const GOOGLE_APP_CREDENTIALS_ENV_VAR_NAME As String = "GOOGLE_APPLICATION_CREDENTIALS"
Public Const CREDENTIALS_FILE_PATH As String = "C:\Users\Anwender\Downloads\credentials.json"
Public Const CARD_IMAGE_FILE_PATH As String = "C:\Users\Anwender\Downloads\ElementarHeld Bubbleman.jpg"

GOOGLE_APP_CREDENTIALS_ENV_VAR_NAME

Diese Konstante beinhaltet den Namen der Umgebungsvariable, Welche wir laut Google-Dokumentation verwenden müssen.

CREDENTIALS_FILE_PATH

Dies ist ein simpler Dateipfad, wo sich nachher die Datei mit unseren Zugangsdaten befindet, Welche wir oben als JSON-Datei heruntergeladen haben. Achte auf einen passenden Namen!

CARD_IMAGE_FILE_PATH

Die letzte Konstante speichert den Pfad zum jeweiligen Bild, Welches wir einlesen und verarbeiten möchten. Der Google Client erwartet letztendlich ein Bild. Dieses Bild hat einen eigenen von Google definierten Dateityp, wovon mit Factory-Methoden einzelne Instanzen erzeugt werden können. Dazu gleich mehr..

Der Aufruf selbst

Kommen wir nun nach dem Motto „das Beste kommt zum Schluss“, an den eigentlichen Aufruf der Google-Schnittstelle:

    Private Async Sub btnRecognizeCardText_Click(sender As Object, e As EventArgs) Handles btnRecognizeCardText.Click
        Environment.SetEnvironmentVariable(GOOGLE_APP_CREDENTIALS_ENV_VAR_NAME, CREDENTIALS_FILE_PATH)
        ' Dim img = Image.FetchFromUri("")
        Dim img = Await Image.FromFileAsync(CARD_IMAGE_FILE_PATH)
        Dim client = Await ImageAnnotatorClient.CreateAsync()
        Dim textAnnotations = Await client.DetectTextAsync(img)
        For Each anno In textAnnotations
            tbRecognizedText.AppendText($"{anno.Description} ")
        Next
    End Sub

In der ersten Zeile setzen wir wie von der Dokumentation vorgegeben eine Umgebungsvariable mit passendem Namen. Dies könnte man natürlich auch nur einmalig im Load machen..

Danach können wir auf verschiedene Weisen ein passendes Image der Google Library erzeugen.

In diesem Beispiel verwende ich dafür die „FromFileAsync“-Factory-Funktion.

Schaue mit Hilfe von Intellisense-Code-Vorschlägen doch einfach mal die anderen Möglichkeiten durch.

Danach erzeuge ich mit Hilfe der „ImageAnnotatorClient.CreateAsync“-Factory- Funktion , einen neuen Client, womit wir die Anfragen dann gleich senden.

Beim Client kann ich dann die „DetectTextAsync“-Funktion mit Hilfe des „Bild“-Parameters aufrufen und bekomme die erkannten Daten zurück.

Diese durchlaufe ich anschließend mit Hilfe der Schleife und zeige Sie in der Textbox an.

Auch hier der Tipp: Schaue Dir mit Intellisense (oder mit der Doku) die alternativen Methoden wie „DetectLogos“ an.

Die passende Doku dazu findest Du unter diesem Link: „Google Cloud Vision API V1„.

Kompletter Code – VB.NET Texterkennung auf Bildern

Imports Google.Cloud.Vision.V1

Public Class Form1

    Public Const GOOGLE_APP_CREDENTIALS_ENV_VAR_NAME As String = "GOOGLE_APPLICATION_CREDENTIALS"

    Public Const CREDENTIALS_FILE_PATH As String = "C:\Users\Anwender\Downloads\credentials.json"

    Public Const CARD_IMAGE_FILE_PATH As String = "C:\Users\Anwender\Downloads\ElementarHeld Bubbleman.jpg"

    Private Async Sub btnRecognizeCardText_Click(sender As Object, e As EventArgs) Handles btnRecognizeCardText.Click
        Environment.SetEnvironmentVariable(GOOGLE_APP_CREDENTIALS_ENV_VAR_NAME, CREDENTIALS_FILE_PATH)
        ' Dim img = Image.FetchFromUri("")
        Dim img = Await Image.FromFileAsync(CARD_IMAGE_FILE_PATH)
        Dim client = Await ImageAnnotatorClient.CreateAsync()
        Dim textAnnotations = Await client.DetectTextAsync(img)
        For Each anno In textAnnotations
            tbRecognizedText.AppendText($"{anno.Description} ")
        Next
    End Sub

End Class

Downloads & Links

Der Beitrag VB.NET Texterkennung auf Bildern via Google Cloud Vision API [OCR] erschien zuerst auf Robert Skibbe.

VBA

Ein weiteres Akronym Namens VBA geistert seit längerer Zeit in der Welt der IT, aber auch im Büroalltag umher.

Besonders Büroangestellte nutzen VBA häufig in Kombination mit den Microsoft Office Produkten, teilweise auch ohne es aktiv zu wissen.

Doch was ist dieses VBA „Ding“ denn nun, wofür wurde es erfunden und was macht man damit genau?

Was ist VBA?

VBA ist wie oben schon eingängig erwähnt ein Akronym, also eine Abkürzung für die Wörter „Visual Basic for Applications„.

Was irgendwie nach einer Art Brillenputzmittel, bzw. Auflage auf Brillen klingt, ist in Wahrheit eine Skriptsprache.

Diese Skriptsprache wurde von der Firma Microsoft unterstützend zu vielen Ihrer Office Produkte, wie z. B. Excel und Word entwickelt.

Wofür VBA?

Da wir nun verstanden haben wo VBA eingesetzt wird, also bei bestehenden Produkten wie z. B. Microsoft Excel, schauen wir uns nun dessen Verwendung an.

Meiner persönlichen Erfahrung nach, denken viele Kenner sofort an Excel, wenn sie das Stichwort „VBA“ hören, nicht ohne Grund.

Auch wenn die Microsoft Office Produktfamilie natürlich über einen sehr großen Funktionsumfang verfügt, hat man häufig individuelle Wünsche.

Neben den individuellen Wünschen spielt natürlich auch z. B. die Automatisierung von gewissen Prozessen eine große Rolle.

Wer hat schon Lust, die häufig an Praktikanten verteilte Arbeit zu übernehmen und sich dumm und dusselig zu klicken.

Dafür könnte man sich einige kleine Skripte in VBA bauen, Die einem dann diese unangenehme Arbeit abnehmen, oder zumindest erleichtert.

Was ist nun das VB in VBA?

Nun kommst Du ggf. mit deinen Englischkenntnissen an den Punkt, wo Du die Bedeutung des „..for Applications“ verstanden hast.

Denn wie erklärt, erweitert man bestehende Office-Programme durch VBA um seine individuell gewünschten Programm–Funktionen.

Was dabei allerdings noch offen bleibt ist dieser Teil namens „Visual Basic“ in VBA.

Visual Basic (Classic) – oder auch kurz „VB“ – ist die Programmiersprache worauf VBA letztendlich basiert.

Sie ist der Vorreiter für die Sprache, weshalb diese Webseite vor vielen Jahren überhaupt entstanden ist – Visual Basic NET.

Einsatzbeispiel für VBA

Wie oben bereits erwähnt gibt es teilweise Situationen in denen man sich gerne ein Skript für wiederkehrende Arbeiten erstellen möchte.

Damit könnte man nach initial investierter Zeit, zukünftig ein Vielfaches dieser Arbeitszeit und Arbeitskraft sparen und vereinfachen.

Schauen wir uns dafür in diesem Abschnitt einmal ein kleines Beispiel an, wo wir so eine individuelle Erweiterung genauer betrachten.

Das Beispiel in all seinen vollständigen Details findest Du im Beitrag „Serienbrief mit Ecxel„, ich werde hier die wesentlichen Schritte wiederholen.

Dabei ergänze ich einige Sachen, Welche zu diesem Beitrag hier besser passen und daher einfacher nachvollziehbar sind.

Das Dilemma mit den Adressen

Jeder der schonmal in seinem Leben mit Adress-Daten gearbeitet hat, kennt das dahinter steckende Dilemma.

Mal werden Postleitzahl und Ort vertauscht, hier und da ein Leerzeichen zu viel und und und.

Manchmal fragt man sich wirklich, wie Diese herauskommenden Daten letztendlich zustande kommen.

Ich selbst kenne das aufgrund einer ehemaligen Arbeitskollegin aus einen vergangenen Job sehr gut.

Monkey Work als Beispiel – Kein Einzelfall

Sie war den ganzen Arbeitstag (!) damit beschäftigt, Adressen zu korrigieren und aufzuarbeiten – schrecklich.

Leider ist das absolut kein Einzelfall, auch bei einem ehemaligen Kunden kannte ich Mitarbeiter, die dieser Arbeit nachkamen.

Oftmals ist es in solchen Unternehmen leider die Folge von fehlendem Budget für individuelle Entwicklungen.

Manchmal meint man auch, man könne sich dafür keine Zeit nehmen „..ich muss schließlich mein Tagesgeschäft fortführen..“.

Fangen wir lieber nicht die mentale Debatte an, ob diese Vorgehensweisen so sinnvoll waren..

Fokussieren wir uns stattdessen lieber auf das ursprüngliche Problem, eine kleine Funktionalität zur Korrektur von Adressen zu erstellen.

Natürlich werde ich hier nur ein kleines Beispiel machen, da es nicht um die Funktionalität geht.

Mir geht es hier besonders um das Verständnis über die Einsatzmöglichkeiten von VBA.

Tabellenstruktur & Beispieldaten

Schaue Dir am besten einfach mal folgende Tabellenstruktur und die darin befindlichen Daten an:

Dir fällt sehr wahrscheinlich der falsche Datensatz in der dritten Zeile auf.

Dort wurde bei der Eingabe (aus welcher Quelle auch immer), leider die Postleitzahl mit dem Ort vertauscht.

Natürlich könnten wir bei diesen wenigen Einträgen auch eine manuelle Korrektur durchführen.

Wenn ich allerdings an den erwähnten Kunden denke, dann hatte man mit ungefähr 200 Bestellungen am Tag ein Problem.

Lösungsansatz

Wenn wir nun über einen möglichen Lösungsansatz nachdenken, könnte man wie folgt vorgehen.

Man geht das aktive Tabellenblatt bei z. B. einem Klick eines Buttons mit einer Schleife durch.

In jedem Schleifendurchlauf prüft man, ob z. B. im Ort Zahlen enthalten sind.

Vermutlich gibt es hier noch andere Ansätze, allerdings reicht das für unser Beispiel aus.

Meine Gedanken dabei waren, dass in einem Ort definitiv keine Zahlen vorkommen und eine Postleitzahl soweit ich weiß in einigen Gebieten auch Buchstaben enthalten kann.

Im Endeffekt kann man das ja je nach individuellem Wunsch anpassen, bzw. verändern.

Code

In diesem Abschnitt schauen wir uns den möglichen Code für die oben genannte Variante an.

Der erste Bestandteil ist wie erwähnt das Durchlaufen der Zeilen, des aktiven Tabellenblatts:

Dim rowRange As Range
For Each rowRange In ActiveSheet.UsedRange.Rows
  ' mach was mit der Range namens rowRange
Next

Danach könnten wir einstellen, dass die Reihe nur verarbeitet wird, wenn beide notwendigen Datenfelder ausgefüllt sind.

Dazu benutze ich wie immer gerne, ein so genanntes „Early Return„, ich weise die Schleife in den nächsten Durchlauf, statt If-Konstrukte tief zu verschachteln:

Dim zipText As String
zipText = ActiveSheet.Cells(rowRange.Row, 1).Text
Dim hasNoZip As Boolean
hasNoZip = zipText = ""

Dim cityText As String
cityText = ActiveSheet.Cells(rowRange.Row, 2).Text
Dim hasNoCity As Boolean
hasNoCity = cityText = ""

If hasNoZip Or hasNoCity Then
  Continue For
End If

Zum Schluss können wir dann unsere Prüfung und die Tausch-Arbeit selbst durchführen.

Dazu könnten wir auf komplizierte „Regular Expressions“ zurückgreifen, jedoch bin ich ein Fan von „KISS„, daher verwenden wir einfach den „Like“-Operator:

Dim cityContainsNoNumber As Boolean
cityContainsNoNumber = cityText Not Like "*[0-9]*"
If cityContainsNoNumber Then
  ' wieder early return / Continue
  Continue For
End If

Im letzten Schritt folgt der Tausch der Werte:

ActiveSheet.Cells(rowRange.Row, 1).Text = cityText
ActiveSheet.Cells(rowRange.Row, 2).Text = zipText

Kompletter Code

Hier findest Du noch einmal den vollständigen Code, um die PLZ mit dem Ort/der Stadt zu tauschen, wenn die Stadt eine Zahl enthält:

Dim rowRange As Range
For Each rowRange In ActiveSheet.UsedRange.Rows
  Dim zipText As String
  zipText = ActiveSheet.Cells(rowRange.Row, 1).Text
  Dim hasNoZip As Boolean
  hasNoZip = zipText = ""

  Dim cityText As String
  cityText = ActiveSheet.Cells(rowRange.Row, 2).Text
  Dim hasNoCity As Boolean
  hasNoCity = cityText = ""

  If hasNoZip Or hasNoCity Then
    Continue For
  End If

  Dim cityContainsNoNumber As Boolean
  cityContainsNoNumber = cityText Not Like "*[0-9]*"
  If cityContainsNoNumber Then
    Continue For
  End If

  ActiveSheet.Cells(rowRange.Row, 1).Text = cityText
  ActiveSheet.Cells(rowRange.Row, 2).Text = zipText
Next

Wo den Code unterbringen?

Damit Du den Code von oben verwenden kannst, muss er natürlich irgendwo untergebracht werden, damit er auch ausgeführt wird.

Das passiert in Excel z. B. häufig durch sogenannte Makros, wie Du auch in diesen Beiträgen erfahren konntest: Excel Makros erstellen, oder Excel Makro Button.

Fazit – VBA

In diesem Beitrag hast Du gelernt, wie Du dein Erlebnis von Office Produkten wie z. B. Excel verbessern kannst.

Dies geschieht durch die auf der Visual Basic (Classic) basierenden Skriptsprache namens Visual Basic for Applications, oder kurz „VBA„.

Diese Verbesserungen können in Form von zusätzlichen Funktionen, oder auch in Form von konkreten arbeitserleichternden Mitteln existieren.

Downloads

Der Beitrag VBA erschien zuerst auf Robert Skibbe.

VB.NET Anwendungsdauer auslesen

In VB.NET die Anwendungsdauer auslesen ist ein Problem, vor Welchem ich heute selbst stand, daher dachte ich, ich teile meine Lösung mit Dir.

Je nach Sicherheitsanforderungen deiner Anwendung, könntest Du basierend auf dieser Zeitmessung zum Beispiel Nutzungsbegrenzungen festlegen.

Beachte, dass es wie fast immer unterschiedliche Wege gibt, diese Problemstellung anzugehen und ich nur eine Möglichkeit zeige.

Schaue doch zu einem anderen Zeitpunkt auch gerne bei diesen Beiträgen vorbei: VB.NET data binding Tutorial, Dein Eigenes TicTacToe Spiel, VB.NET Array.

Meine erste Problemstellung – wo?

Der erste Gedanke, Welcher mich beim Umsetzen dieser Aufgabe begleitete war es, herauszufinden wo ich den Code am besten ansetze.

Am liebsten hätte ich es wie gleich folgend gehabt, um nicht großartig etwas instanziieren und durch z. B. eine Methode initialisieren zu müssen.

Ebenso finde ich das Beispiel relativ einleuchtend, denn es klingt für mich logisch, die verstrichene Zeit der Anwendung, in der Anwendungsklasse zu finden, oder?

Dim timeRunning = Application.GetTimeRunning()
' do something

Erweiterungsmethoden zu Hilfe – oder?

Grundsätzlich könnte man bei dieser Herangehensweise erstmal an Erweiterungsmethoden denken.

Mit Hilfe von Erweiterungsmethoden können wir die bestehenden .NET-Klassen, sowie eigene Klassen um Funktionalitäten erweitern.

Das würde sich für mich dann nach so etwas wie „Plug & Play“ anfühlen, also hinzufügen und „zack“, läuft!

Winforms Anlauf – VB.NET Anwendungsdauer auslesen

Mein erster Versuch, bzw. der erste Pseudocode (für Winforms) sah also so ähnlich aus:

Imports System.Runtime.CompilerServices

Module modExtensions

    Private ReadOnly StartedAt As Date = Date.Now

    <Extension>
    Public Function GetTimeRunning(app As Application) As TimeSpan
        Dim timeDiff = Date.Now - StartedAt
        Return timeDiff
    End Function

End Module

Klappt leider direkt nicht

Leider können wir Klassen mit Hilfe von Erweiterungsmethoden keine statischen (shared) Methoden hinzufügen.

Das obige Code-Beispiel würde daher die Klasse „Application“ um den jeweiligen Code erweitern.

Allerdings kann man die Methode wie erklärt dann nur auf einer Instanz der „Application“-Klasse aufrufen.

„Shared„-Methoden sind in Modulen übrigens nicht verwendbar, also nicht gültig.

Eins der Probleme bei WPF gelöst

Mit WPF können wir eines der Probleme einfach lösen, denn WPF kann auf die aktuelle Instanz der Anwendung zugreifen.

Beherbergt in der „Application„-Klasse aus einem anderen Namespace, können wir nun auf die aktuelle Instanz der Anwendung zugreifen.

Somit haben wir jetzt die Möglichkeit, die deklarierte Erweiterungsmethode zu verwenden.

Die Erweiterungsmethode erklärt

Hier erkläre ich Dir kurz die Vorgehensweise der Erweiterungsmethode und zeige Dir das erste Ergebnis.

Vorgehensweise – VB.NET Anwendungsdauer auslesen

Dort siehst Du ein beliebig benanntes Modul, Welches ein privates Feld namens „StartedAt“ besitzt.

Dieses Feld sollte die aktuelle Zeit zum Anwendungsstart widerspiegeln – sollte, aber dazu gleich mehr.

Die „GetTimeRunning“-Funktion führt eine simple Subtraktion von 2 Date (DateTime) Objekten durch.

Dabei wird die Startzeit von der aktuellen Zeit abgezogen, Welche dann die verstrichene Zeit darstellt.

Die Subtraktion der Dates ist von .NET schon implementiert und gibt als Ergebnis ein TimeSpan-Objekt aus.

Das erste Ergebnis

Schaue Dir im folgenden Bild unser erstes Ergebnis der aktuellen Herangehensweise an.

Dabei habe ich mir den Rückgabewert der Funktion einfach 2x mit Verzögerung als String ausgeben lassen.

Das habe ich ganz simpel mit der „WriteLine“-Methode der Debug-Klasse, innerhalb eines Button–Klicks umgesetzt.

Bittere Enttäuschung

Wie die Überschrift schon vermuten lässt, kommen wir mit diesem Beispiel leider nicht an unser gewünschtes Ziel.

Erklären lässt sich das zwar korrekte aber nicht funktionierende Beispiel, mit Hilfe der dahinter liegenden Ausführungslogik von .NET.

Obwohl ich schon vor dem ersten Klick ein wenig gewartet hatte, bekomme ich trotzdem einen komischen Wert.

Das liegt daran, dass das „StartedAt“-Feld des Moduls erst nach erstmaliger Verwendung des Moduls während der Laufzeit initialisiert wird.

Nach ca. 3 weiteren Sekunden habe ich dann erneut auf den Button geklickt und siehe da, ein besseres Ergebnis.

Zu diesem Zeitpunkt war das Feld bereits initialisiert und hatte somit einen „korrekten“ Wert.

Negativer Wert

Wie das Feld im ersten Schritt einen negativen Wert generieren konnte verstehe ich allerdings selbst nicht so ganz.

Auch wenn ich einige Vermutungen im Bereich DateTime-MinValue aufstelle, dürften sich Diese eigentlich nicht bewahrheiten.

Denn bevor ich auf das Feld zugreife, müsste Ihm ja trotzdem bereits der auf Modul-Ebene „Date.Now“ Wert zugewiesen sein.

Fokus auf das Wesentliche

Halten wir uns aber nicht weiter damit auf und fokussieren uns auf das Wesentliche.

Das eigentliche Problem mit der hier aufgeführten Möglichkeit ist, dass der Wert erst nach der ersten Verwendung zustande kommt.

Einen möglichen Workaround um das zweite geschilderte Problem, finden wir mit Hilfe der „Process„-Klasse.

Dort speichert die nützliche Eigenschaft „StartTime„, den Startzeitpunkt der App in der aktuellen Prozess-Instanz.

Der Code um an die „StartTime“ des momentanen Prozesses zu kommen, sieht so aus:

Dim processStartTime = Process.GetCurrentProcess().StartTime

Erweiterungsmethode V2

Wir schreiben unsere Erweiterungsmethode aus dem obigen Code-Snippet also wie folgt um:

Imports System.Runtime.CompilerServices

Module modExtensions

    <Extension>
    Public Function GetTimeRunning(app As Application) As TimeSpan
        Dim timeDiff = Date.Now - Process.GetCurrentProcess().StartTime
        Return timeDiff
    End Function

End Module

Dabei entfernen wir das Feld „StartedAt“ und ersetzen dessen Verwendung durch die hier drüber vorgestellte „StartTime„-Eigenschaft der „Process“-Klasse.

Achtung! Bei meiner Recherche bin ich auf diverse Probleme gestoßen, wenn man den Code im Debugging verwendete. Durch die gehostete Exe, ist der Prozess eventuell schon länger aktiv. Wenn man die Exe allerdings ohne Debugging startet (Strg+F5), klappt alles.

WPF läuft nun

In einer WPF-Umgebung läuft der Code mit der Erweiterungsmethode ohne Probleme.

Die WPF-Anwendung selbst, findest Du natürlich auch in der Projektmappe des Downloads.

Nachdem ich die Anwendung starte und gefühlt 3 Sekunden warte, bekomme ich folgende Ausgabe:

Winforms-Fix – VB.NET Anwendungsdauer auslesen

Nun bringen wir das Ganze Snippet auch in ähnlicher Form in Winforms-Awendungen zum Laufen.

Dazu lege ich einfach auch ein Modul an, Welches dann geschachtelte Klassen mit der Funktionalität enthält.

Module modExtensions

    Public Class Extensions

        Public Class Application

            Public Shared Function GetTimeRunning() As TimeSpan
                Dim timeDiff = Date.Now - Process.GetCurrentProcess().StartTime
                Return timeDiff
            End Function

        End Class

    End Class

End Module

Dessen Aufruf in einer Windows-Form, bzw. in einem Button Klick-Ereignishandler sieht dann ähnlich einfach aus:

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
        Debug.WriteLine(Extensions.Application.Runtime())
    End Sub

Weiterführende Links

• VB.NET Texterkennung auf Bildern via Google Cloud Vision API [OCR]
• VB NET Web API – Währungskurs Service Konsum von Grund auf erklärt
• VB NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen

Downloads – VB.NET Anwendungsdauer auslesen

Der Download enthält die Projektmappe für das „VB.NET Anwendungsdauer auslesen“-Projekt, bestehend aus dem Winforms– und dem WPF-Projekt.

Das richtige Startprojekt beim Ausprobieren des Codes kannst Du mit einem Rechtsklick auf das Projekt + "Als Startprojekt festlegen" ändern.

Der Beitrag VB.NET Anwendungsdauer auslesen erschien zuerst auf Robert Skibbe.

Excel Makro erstellen

Ein Excel Makro erstellen und damit eventuell deine Arbeit zu erleichtern, bzw. zu automatisieren ist Dein Ziel?

Dann ist es schön, dass Du auf dem Weg deiner Recherche zu meinem heutigen Beitrag gefunden hast, denn genau darum geht es heute!

Schaue gerne alternativ auch bei meinen anderen VBA Excel Beiträgen wie: Excel Makro Button, VBA For Schleife & Range VBA vorbei.

Was ist eigentlich ein Makro?

Ganz nach dem Motto „Back To The Roots“ schauen wir uns erstmal die Bedeutung eines Makros an und wofür man es letztendlich verwendet.

Makros sind vor allem im Bereich der Automatisierung von diversen Prozessen nicht wegzudenken, denn Sie können die alltägliche Arbeit erleichtern.

Sie sind für die Non-Programmierer vor allem aus dem Bereich Microsoft Excel und Co. bekannt und werden dort täglich eingesetzt.

Ein Makro ist letztendlich nichts Anderes als eine Sammlung von Anweisungen, praktisch also ein Zettel mit „Tu dies, tu jenes und danach dies & das“.

Ein Makro auslösen

Bevor wir uns der Erstellung des Makros widmen, schauen wir uns nochmal kurz vorher die Möglichkeiten zur Auslösung von Makros an.

Dazu können wir auf eher passive Ereignisse, bzw. Trigger warten, oder die aktive Varianten wie z. B. durch einen Button–Klick, oder Hotkey wählen.:

Varianten

• auslösen durch Hotkeys
• im Ladevorgang der Projektmappe
• im Code durch den Visual Basic Editor (VBE)
• und mehr..

Mit diesen Ausgangspunkten können wir uns nun im nächsten Schritt, die Erstellung eines Makros anschauen.

Vorbereitungen – Excel Makro erstellen

Oft bekommt man bei der ersten Arbeit mit Makros ein kleines „Problem„, Welches aber gar kein richtiges Problem, sondern eher ein Sicherheitsfeature ist.

Zumeist ist die Verwendung von Makros in Microsoft Excel Tabellen standardmäßig mehr oder weniger deaktiviert.

Wir müssen die mögliche Nutzung von Makros also erstmal aktivieren und das machen wir über die Optionen.

Makros aktivieren

Begebe Dich also nun unter den Punkt Datei->Optionen in die Optionen von Excel.

Achtung! Deine Optionen sehen eventuell anders aus, bei mir werden durch die Verwendung von Web-Office aktuell nur diese Optionen angezeigt.

Excel Optionen öffnen

Trust-Center & Einstellungen öffnen

Gehe anschließend auf den Punkt „Trust-Center“, oder manchmal auch „Sicherheitseinstellungen“ genannt.

Makroeinstellungen öffnen

Klicke auf den farblich markierten Button und öffne somit die Einstellungen des Trust-Centers.

Beachte natürlich die Hinweise hinter den einzelnen Optionen und öffne nur Dateien, dessen Absender Du kennst, bzw. vertraust!

Alternativ kannst Du zur gezeigten Methode auch für jede Mappe einzeln bestimmen, ob Du dessen Makros verwenden möchtest.

Diese Möglichkeit bietet Dir Excel eigentlich auch von selbst an, meist mit einem kleinen Popup.

Allerdings kann die bei häufiger Verwendung von Makros auch nervig werden, jedoch ist es die sicherere Variante.

Entwicklertools einbinden

Mit dem nächsten Schritt würde ich Dir auch gleichzeitig ans Herz legen, die Entwicklertools in dein Menüband von Excel einzubinden.

Auch hier erschaffst Du Dir so einen schnellen und einfachen Zugriff auf die eventuell notwendigen Tools.

Öffne auch hierzu wieder die Optionen von Excel und klicke links außen auf „Menüband anpassen„.

Danach kannst Du die Entwicklertools meist mit einer Checkbox auf der rechten Seite aktivieren.

Excel Makro erstellen – Die Praxis

Nachdem Du im letzten Schritt eventuell die Entwicklertools aktivierst hast, oder bereits aktiviert hattest, nutzen wir Diese auch gleich.

Klicke dafür in deinem Menüband auf die Entwicklertools und anschließend auf die Fläche namens Makros.

Gebe nun einen Namen für dein neues Makro ein und bestätige Diesen danach.

Im nächsten Schritt wird sich dadurch der VBA-Editor öffnen und schon einige Zeilen an Code zeigen.

Hier könntest Du nun den Code deines Makros eintragen und z. B. durch:

MsgBox("Yay, mein eigenes Makro!")

eine simple Messagebox anzeigen lassen.

Detailliertere Informationen findest Du auch in der offiziellen Dokumentation von Microsoft.

Der Beitrag Excel Makro erstellen erschien zuerst auf Robert Skibbe.