To make PHP generate a UUID, the most basic way would be using the native „uniqid“ function. However, keep in mind, that this one isn’t an ID considering the known UUID standards (being UUIDs, versions 1-5). If you want to generate these UUIDs, you should take a well known and tested library like ramsey/uuid.

You want to make PHP generate UUIDs for you!?

I welcome you to todays post on „How to make PHP generate a UUID for you“. In this post I will dive into the thing called universally unique identifiers. Those „special kind“ identifiers are – as the name obviously suggests – for uniquely identifying „things“.

If you would like to skip the „blabla“, jump to the manual creation here. If you would like a short library based example, click here. I would encourage you though, to study the different versions of UUIDs.

There are different versions of UUIDs, mainly you can number them from versions 1 to 7. Many projects nowadays require a new way of generating that unique identifier for like your entities. It doesn’t matter if it’s stored in a good oldMySQL Database, or in one of the document based alternatives.

Using a different approach than those normal, incremental „1, 2, ..“ ids, has become more and more popular. This doesn’t only apply for the developers side, customers and other involved parties actually want something else, too. So let’s get into the background story and later into how we can actually create/generate one.

The background story – PHP generate UUID’s

Before we actually start thinking about code, we could also start from a little different angle. So imagine having a graphical user interface, like most of the time, with some kind of list. You got that usual screen with something like a table, which displays some data about the listed entities.

So far this isn’t really exciting, I know, but what comes into your mind, when thinking about the first column? The first column inside that table, will usually display the unique identifier for that entity. So basically this will be an incrementing number, which starts at like 1 and is constantly and linearly growing.

Sure, there are some cases where people want to define another starting point like at 5000, but.. Here we are, already facing one of the common problems when using „normal“ numbers.

The thing with guessability

No matter, if typical numbers start at 300, or at 300000, you can always kinda guess, what could potentially be the next one. When you have one id, you can increment that by yourself and you could test „Hmm, what’s the next one about!?“. This is literally one thing, where some customers and developers argue about doing it different.

The main reason for the customer would mostly be, to hide actual counts from the end user. End users could guess from order number „5“, that this shop maybe just started. This could lead the end user to actually interpret more, maybe negative things into that.

Thoughts like „Hmm, this shop did just start, maybe it’s a scam..“ could arise.

Being able to generate offline

Usually the approach of working with the database or entities in general, is like the following. You have that basic overview screen, where you click this sweet „+“-button and voila. After that, you will have your detail screen displayed, which is ready to get filled out.

You will most likely fill out that form in front of you and then press something like „confirm“, or „save“. This will call some kind of api in the background, which then creates that new entity for you. During that process, the database will be contacted as central unit, being responsible for generating the new ID.

Now think about what happens, when you can’t contact the database, if you’re offline. Well I think you are correct – usually nothing will happen.. At this point, UUIDs come in handy, as they can be generated offline and can still be unique!

Uniqueness accross systems & replications

Imagine you have that one online shop, where you already got thousands of orders, bills and more data. Now imagine building up on that one shop, where you want to export and import the data in another system. Well, if you’re using normal, incremental numbers, you could easily run into some id clashes.

With UUIDs on the other hand, this most likely won’t be the case (care for the different versions here). By the word „universally“ of the full name „universally unique identifier“ this might get clearer. As I already promised, I won’t go to deep on this aspect of UUID, maybe I’ll do so in a later post!

You can just keep in mind, that UUIDs will prevent clashing, even generated on different systems.

What’s does the trend say?

As I mentioned above, the typical UUID spectrum consists of different versions, being 1 – 5. They all have their different aspects and considerations, you have to be aware of. I would therefore encourage you to do some studies, before actually using, not to mention, even generating them for yourself.

Here’s a graphic, which could give you a small overview of like which UUID versions are relevant / trending. Usually, this trend counts for like „in general“, not only for PHP. Between, this graphic is from today’s date (25.03.2026) considering data from the last 12 months:

Looking at the data, UUID v4 leads with an average interest of 64, closely followed by the newcomer UUID v7 at 52 ➡️ a clear sign of rapid adoption since its standardization in 2024. UUID v1 and v2 show minimal interest. UUID v5 was excluded from the chart as its search volume is negligible compared to the others.

The different versions of UUIDs

UUIDs (Universally Unique Identifiers) can be generated in different versions, each having a specific purpose. Of course, you need to be sure, that the underlying library (or even yourself) is correctly implementing these aspects. Here are the commonly recognized versions of UUIDs:

UUID1 (Time-based)

This version is generated from the current time and the MAC address of the computer generating the UUID. It is unique within a particular network and time period.

UUID2 (DCE Security)

It’s pretty similar to UUID version 1, but it has support for DCE security. It’s not pretty much used from my experience – supported by the shown data from above, as well.

UUID3 (Name-based, MD5 hash)

This UUID version is generated from a namespace identifier and an arbitrary name. It uses MD5 hashing to create a UUID based on the namespace and name.

UUID4 (Random)

This is – in my experience and according to the above data – still the most widely used UUID version. It’s generated using random or pseudo-random numbers and provides a high probability of uniqueness. However, UUID v7 is catching up fast (see the trend data above).

UUID5 (Name-based, SHA-1 hash)

The version 5 UUID is pretty similar to version 3, but it uses SHA-1 (Secure Hash Algorithm) hashing instead of MD5 (the message digest algorithm).

Note: UUID v5 is not included in the Google Trends comparison above, as its search interest is too low to be meaningfully compared to v1, v4 and v7.

UUID7 (Time-ordered, since RFC 9562 — 2024)

UUID version 7 was officially standardized in May 2024 (RFC 9562) and is gaining rapid adoption. Unlike UUID4, it is time-ordered — meaning UUIDs generated later will always sort higher. This greatly improves database index performance compared to random UUID4.

The ramsey/uuid library supports UUID7 since version 4.7.0:

$uuid7 = Uuid::uuid7();

If you are starting a new project in 2026, UUID7 is worth considering over UUID4 for database-backed entities.

Disadvantages of using UUIDs

I think every upside on a specific topic, will mostly have a downside as well, so let’s talk about that. On the one side, UUIDs will be that kind of added value from the aspects mentioned above. The other side like performance, indexability, etc. counts as well, for sure.

Indexability and performance

When using uuids as keys inside your database, theres one big thing which primarily comes into your mind. I’m talking about the „indexability“ and performance of actually storing the UUIDs inside your database tables. I can’t go to deep here, as there are already so many opinions on the web, so I would recommend doing further research.

One of the most reasons I’ve heard about not using UUIDs is like hard dropping performance when used on multiple joins. You should take a read on the web with search queries like „index fragmentation“.

Storage size

I’ve seen it many times, where people stored the UUIDs as like „CHAR(36)“, means strings consisting of 36 characters. Actually, the UUIDs can be stored as a 128 bit = 16 byte, unsigned number, which is kinda more space optimized. Speaking about storage size in general I think, nowadays storage is much cheaper.

Especially if you can provide a better performance, I would preferably go for that over storage. For sure, this also depends on your use case and more things like budget, etc. Anyways i’m a big fan of optimization, where it actually makes sense.

If effort doesn’t outplay the result as hard as I don’t know, then it would make sense for me, so.. Generally you could say, that an UUID needs 4 times more space than like a 4 byte integer. It’s also really nice, that MySQL added more support for UUIDs on their version 8.

Readability

Another important aspect, which has its downside as well as its upside (as mentioned in „guessability“) is readability. While it can be nice for some folks out there, that you can’t really read those identifiers as easy as simple numbers. Other stress on having non readable identifiers, as like telling your customer on a request: „Hey, do you have an id for me?“.

For sure, this wouldn’t be a good experience, having your customer tell you like 36 characters. Theres another thing coming along with that readability point, especially when talking about URLs. You can tell by just looking at those URLs:

• /api/users/cc4f998b-29d8-4163-8bbe-2a44a1ccb2ac
• /api/users/55
• /api/users/my_nice_nickname

PHP generate a UUID / GUID – Manually

After discussing some aspects about using those UUIDs, let’s now actually talk about generating a UUID with PHP. As I already mentioned, we can’t dive to deep into the different versions here, so I will focus on UUID version 4. Many online code examples use the mt_rand PHP function, which is (as it states itself from the docs) not good for generating cryptographic thingys.

After finding different examples, I think this one here is the best one, being a mix of different answers. In the first step we need to choose the „correct“ function for generating 16 random bytes. Below PHPs major version 7, this is supported by using the „openssl_random_pseudo_bytes„-function.

Starting with major PHP version 7 we can use the „random_bytes„-function. With an easy ternary operation, it could look like this:

// old version
// $data = PHP_MAJOR_VERSION < 7 ? openssl_random_pseudo_bytes(16) : random_bytes(16);

$data = random_bytes(16); // PHP 7+ / PHP 8.x

In the next step we are arranging the data, so that the version of the UUID, etc. actually matches:

$data[6] = chr(ord($data[6]) & 0x0f | 0x40);    // Set version to 0100
$data[8] = chr(ord($data[8]) & 0x3f | 0x80);    // Set bits 6-7 to 10

In the last step we are displaying the actual UUID by returning it as formatted string:

$uuid = vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));

You could also split up that last step into multiple other calls, but I think this doesn’t really help visibility here.

So the complete function could look like this:

// old
function get_guid() {
    $data = PHP_MAJOR_VERSION < 7 ? openssl_random_pseudo_bytes(16) : random_bytes(16);
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40);    // Set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80);    // Set bits 6-7 to 10
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

// new
function get_guid(): string {
    $data = random_bytes(16); // requires PHP 7+, works in PHP 8.x
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40);    // Set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80);    // Set bits 6-7 to 10
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

You could also expand further by going the „Microsoft way“, with the „com_create_guid„-function. This function will only (as far as I know) work, if you’re on a Windows based server. It will generate a UUID with prefixed and appended curly braces, hence the trim statement.

function get_guid() {
    if (function_exists('com_create_guid') === true)
        return trim(com_create_guid(), '{}');
    $data = PHP_MAJOR_VERSION < 7 ? openssl_random_pseudo_bytes(16) : random_bytes(16);
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40);    // Set version to 0100
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80);    // Set bits 6-7 to 10
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}

Generating a UUID with ramsey/uuid

Before doing your own experiments and implementing the versions of UUIDs for yourself, it’s probably better to use an existing library. Usually, I’m a fan of „doing things myself“, but when it comes to security and randomness, I would love to rely on broadly spreaded projects, that have been tested by many persons.

Of course you could have typical problems like the author abandoning the projects, etc. but in the end, you have to decide the common factors like:

• Maintainability
• Security
• Testing
• Time-savings
• ….

So let’s now take a look at an example code from the ramsey/uuid library, feel free to visit the project on Github.

Installing the library

As with the most of PHP based libraries, we will install this one with composer as well. Open a terminal in your project folder and run the following installation command:

composer require ramsey/uuid

Import and usage

After you have installed the library, you can now import the corresponding classes. Put import statement on the usual upper part, of your code file. You can then just call the static helper functions, to generate a UUID of your desire.

We will generate a UUID4 in this case:

<?php
namespace yournamespace;

// here's the important part...
use Ramsey\Uuid\Uuid;

// here's the generation of the UUID4 itself
$myUuid4 = Uuid::uuid4();

Formatting and stuff

Keep in mind, that the previous example created an instance of the following class:

Ramsey\Uuid\Rfc4122\UuidV4

If you want to do some formatting actions, you can use things – according to the documentation – like this:

<?php
namespace yournamespace;

// import
use Ramsey\Uuid\Uuid;

// creation
$uuid = Uuid::uuid4();

// output
printf(
    "UUID: %s\nVersion: %d\n",
    $uuid->toString(),
    $uuid->getFields()->getVersion()
);

Related posts

• Hacking a webshop
• WordPress loading only page specific assets

Der Beitrag PHP generate a UUID with ease in 2026 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.

VB NET Tutorial 2 – Ausgaben & mehr Datentypen

Willkommen im VB NET Tutorial 2, wo wir weiter in die Welt der Programmierung wagen.

Nachdem wir uns im letzten Tutorial mit dem Einstieg in die Variablen beschäftigt haben, geht es hier weiter.

Eigentlich wollte ich hier auch schon mit den Variablen weiter machen, aber ich glaube, das wäre dann zu viel gewesen. Daher fokussieren wir uns lieber erstmal auf die Konsole und die Verkettung von Strings. Dafür müssen wir natürlich auch noch ein neues Projekt aufsetzen, etc.

Bisher haben wir auch leider noch nicht wirklich was von unseren Daten gesehen.

Wir definierten, deklarierten und initialisierten, aber haben davon nicht viel mitbekommen.

Der Code im Visual Studio, bzw. in Programmen verläuft generell linear.

Zeilenweise wurden unsere kleinen Anweisungen wie z. B. die Folgende ausgeführt:

Dim alter As Integer = 30

Dies funktionierte natürlich auch im Hintergrund alles so wie gewollt.

Der Speicher wurde in der Größe eines „Integers“ reserviert und die Variable wurde für uns ansprechbar.

Dazu konnten wir den Namen (alter in diesem Fall) verwenden und die Variable bei Bedarf ändern.

Das ging kinderleicht mit einer zusätzlichen Zeile, also mit einer Anweisung wie Diese hier:

alter = 33

Dabei müssen wir natürlich auf den korrekten Datentyp achten, da es sonst Probleme gibt.

Wir können also keinem String plötzlich eine Zahl zuweisen:

Dim name = "RobbelRoot"
' geht nicht!!
name = 33

Wie Du siehst, siehst Du nichts – erste Ausgaben

Bisher war es leider nicht möglich, die Variablen wirklich zu verfolgen.

Wie in der Programmierung normal, laufen die Codezeilen von oben nach unten ab.

Nach dem die Ausführung des Programms beendet ist, war es das dann einfach.

Visuell bekommen wir dadurch „leider“ kein Feedback und stehen im Dunkeln.

Später werden wir uns natürlich noch mit dem „Anschauen“ der Werte innerhalb von Visual Studio beschäftigen.

Dabei handelt es sich um das sogenannte „Debugging„, wo man die Werte dann auch Schritt für Schritt verfolgen kann.

Die altbekannte Konsole/Konsolenanwendung

Im heutigen Tutorial werden wir diese visuelle Darstellung aber durch die altbekannte Konsole realisieren.

Auch wenn die Konsole im ersten Schritt ein wenig altbacken erscheint, findet Sie heutzutage durchaus Verwendung.

Besonders viele bekannte Frameworks verwenden die sogenannten CLI– (Command Line Interface) Anwendungen.

Dort stellen Sie eine Hilfe zur Generierung von Projektvorlagen, oder ähnlichen Dingen dar.

Auch viele Konfigurationen im IT-Bereich werden statt mit einer „richtigen“ GUI, mit einer Konsolenanwendung durchgeführt.

Sie sind also – auch heute noch – alles Andere als wegzudenken.

Grafische Oberflächen – noch nicht!

Ich habe mich daher auch hier dazu entschieden, eine typische grafische Oberfläche, nach hinten zu schieben.

Auch wenn ich die sogenannte GUI (graphical user interface) durchaus auch für Anfänger als spannend empfinde.

Besonders das Zusammenklicken und das „Erfahren am Tun“ ist dort hiflreich.

Man klickt einen Button und es passiert irgendwas, man hat Textboxen und kann etwas eintragen, etc.

Dennoch kann es eben auch zu Verwirrung führen, da wir dort dann von Dingen wie Steuerelementen, Ereignissen, etc. sprechen.

Ich muss zugeben, dass mich die Vorgänge an der Konsole in meiner Zeit als Lernender genervt hat.

Man konnte eben nicht viel sehen und der geschriebene Code erschien irgendwie so unnahbar.

Lasse Dich davon aber nicht abschrecken, es wird Dir nachher helfen, alles besser zu verstehen.

Visual Studio öffnen – ein neues Projekt

Nun ist es an der Zeit einmal ein neues Projekt im Visual Studio anzulegen.

Im vorherigen Tutorial waren wir ja eher mehr theoretisch veranlagt, dass wollen wir nun ändern.

Öffne also nun Visual Studio und wähle rechts den Punkt „Neues Projekt erstellen„:

Projekt-Typ wählen

Nachdem Du diesen Menüpunkt ausgewählt hast, kommst Du in den nächsten Bildschirm.

Dort kannst Du dann den Projekt-Typ auswählen:

Wähle dort den Projekt-Typ „Konsolenanwendung (Visual Basic)“.

Falls Du diesen Projekt-Typ links nicht finden kannst, verwende dafür die Suche oben rechts.

Namen für Projekt festlegen

Sobald Du den Projekttyp ausgewählt hast und weiter gegangen bist, kannst Du einen Namen festlegen.

Später gehen wir noch auf Punkte wie „Name der Projektmappe“ ein, allerdings reicht der Projektname aktuell aus.

Beachte für den Anfang sonst nur den Pfad namens „Ort„, damit Du Deine Projekte auch wiederfindest!

Wähle dann einen für Dich und für Dein Projekt sinnvollen Namen und fahre fort.

Zielframework wählen

Im nächsten Schritt wählen wir mit unserem aktuellen Stand auch einfach nur das standardmäßig ausgewählte Zielframework.

Mach es Dir also nicht schwer und nutze das schon ausgewählte Framework (in meinem Fall .NET Core 3.1).

Ein leeres „Read to go“-Projekt

Danach befinden wir uns im Bildschirm des neu angelegten, leeren Projekts.

Ich habe Dir im Bild markiert, worauf Du in den nächsten Zeilen Deine Aufmerksamkeit lenken solltest.

Alles Andere würde Dich vermutlich nur ablenken und erstmal nur unnötig verwirren, oder überfordern.

Visual Studio Projekt anlegen – In einem neuen Konsolenanwendungs-Projekt

Falls Du allerdings doch schon ein paar Zusatzinformationen haben möchtest, okeydokey!

Projektmappen-Explorer

Rechts oben siehst Du den Projektmappen-Explorer, dort können wir in einer „Mappe“, unsere Projekte organisieren.

Wie das schon suggeriert, kann ein „Projekt“, bzw. eine Projektmappe also verschiedene Projekte beinhalten.

Dabei muss es sich also nicht immer nur um 1 Projekt wie die Konsolenanwendung handeln.

Git-Änderungen

Wenn wir in der Nähe des Explorers auf das nächste Tab gehen, können wir zum Beispiel die Git-Änderungen schauen.

Das ist (für den jetzigen Stand) einfach eine Möglichkeit, die Änderungen unseres Quellcodes sinnvoll zu verwalten.

Klassenansicht

Als nächstes Tab, kommt die Klassenansicht, wo wir einfach praktisch eine andere Ansicht über die Klassen-Struktur bekommen.

Auch das wird später sehr wahrscheinlich mehr einleuchten als jetzt!

Eigenschaftsfenster

Darunter befindet sich das Eigenschafts-Fenster, Welches uns je nach vorher ausgewähltem Element gewisse Eigenschaften anzeigt.

Wähle ich zum Beispiel das Projekt im Explorer aus (in unserem Fall VBTutorial 2b), kann ich hier weitere Eigenschaften dazu sehen.

Über die anderen Bereiche, sprechen wir dann wirklich später!

Das Programm ausführen – VB NET Tutorial 2

Bevor wir nun mit dem Coden fortfahren, kannst Du Dir ja schonmal anschauen, wie man das Programm ausführt.

Damit nun ein wenig Action ins Spiel kommt, klicke mit Deiner Maus einfach mal oben in der Mitte auf den „Play„-Knopf.

Alternativ kannst Du auch den Hotkey „F5“ drücken, Welchen Du vermutlich noch sehr oft benötigen wirst.

Präge Dir den Hotkey deswegen am besten auch so schnell es geht ein!

Damit wird das Programm im „Debug„-Modus gestartet und – ups, verschwindet gleich wieder..

Wenn Deine Augen schnell sind, siehst Du vermutlich kurz ein schwarzes Fenster aufblinken.

Das ist, bzw. war dann die Konsole, Welche den Befehl tatsächlich ausgeführt hatte, eine Zeile auf Ihr auszugeben.

Lass mich Dir kurz ein wenig den Ablauf erklären..

Wenn ein Programm gestartet wird, wird nach einem Einstiegspunkt gesucht, also wo das Ganze Programm „los geht“.

In unserem Fall hier ist das die „Main“-Methode, Welche sich im „Program„-Modul befindet und nur eine Zeile enthält.

Dabei handelt es sich um eine „WriteLine“-Anweisung, Welche den gewählten Text „Hello World“ auf der Konsole ausgibt.

Nachdem die Konsole mit der Ausgabe fertig ist, gibt es keine weiteren Anweisungen mehr im Programm.

Somit wurden alle Arbeiten erledigt und das Programm, bzw. die Konsole wird wieder geschlossen.

Gleich schauen wir uns an, wie man dieses Verhalten verhindern kann.

Die erste Ausgabe auf der Konsole – VB NET Tutorial 2

Sorgen wir nun im nächsten Schritt einmal darum, dass das Programm sich nicht immer sofort beendet.

Damit haben wir dann endlich die Chance, die Ausgabe aktiv zu verfolgen, ohne „The Flash“ sein zu müssen.

Im Endeffekt ist das auch gar nicht schwer, wir müssen der Konsole nur irgendwie „Hey, warte mal“ sagen.

Dafür haben wir für den Anfang 2 einfache und sinnvolle Möglichkeiten:

• Die „Console.ReadKey“-Methode
• oder die seitens UI bekanntere „Console.ReadLine“-Methode

Die „ReadKey„-Methode liest – wie der Name vermuten lässt – einen bestimmten „Key„.

Dabei handelt es sich um einen Tastendruck = Tippen von z. B. „b„.

Die Konsole pausiert nach Start des Befehls solange, bis es einen gewissen Input von uns bekommt.

Bei Variante 1 ist es wie gesagt ein einziger „Key“ und bei der nächsten Variante bis Sie ein „Enter“ bekommt.

Code anpassen – Ausgabe

Wenn Du nun also bereits wie oben beschrieben ein Projekt angelegt hast, geht’s nun weiter.

Wir werden nun eine der genannten Methoden verwenden, um das Beenden der Konsole zu verhindern.

Passe den Code also nun so an, dass der „Console.ReadLine“-Befehl seinen Platz findet:

Module Program

    Sub Main(args As String())
        Console.WriteLine("Dies ist unsere Ausgabe!")
        Console.ReadLine()
    End Sub

End Module

Dadurch dürftest Du nun die Ausgabe des Textes „Dies ist unsere Ausgabe!“ sehen:

Programm schließen

Diese Ausgabe bleibt nun solange stehen, bis Du das Programm:

• entweder durch das „X“ oben rechts
• durch drücken einer Eingabe von z. B. „abc“ und „Enter“ beendest
• alternativ kannst Du auch den Stop-Knopf im Visual Studio benutzen

Nun bist Du natürlich herzlich eingeladen, einmal die Definitionen von Variablen aus Tutorial 1 zu wiederholen.

Diese, oder neue Definitionen, bzw. deren dahinterstehende Werte werden wir gleich einmal ausgeben.

Am einfachsten ist es am Anfang mit Strings, warum wirst Du gleich noch erfahren.

Strings definieren – Einladung & Wiederholung

Definiere daher einfach mal 2-3 Strings und dann sehen wir weiter.

Ich habe hier bewusst nochmal die 3 Möglichkeiten zur Definition verwendet.

Zur Erinnerung, die Möglichkeiten zur Definition waren:

• Deklaration (mit anschließender Zuweisung bei Bedarf)
• Initialisierung
• Initialisierung mit Typinferenz

' Variante 1
Dim vorname As String
vorname = "Robert"

' Variante 2
Dim youtubeKanal As String = "RobbelRoot"

' Variante 3
Dim befehl = "Download"

Die definierten Variablen ausgeben

Nun können wir auch einmal die definierten Variablen, statt der geschriebenen Texte ausgeben lassen.

Dafür können wir der „Console.WriteLine“-Methode einfach unsere Variablen übergeben:

Dim befehl = "Download"
Console.WriteLine(befehl)
Console.ReadLine()

Nun dürfest Du auch die „befehl“-Variable ausgegeben bekommen.

Schön wäre es auch, wenn man nun so etwas wie „Hey, in der Variable steht: <InhaltDerVariable>“ ausgeben könnte.

Das geht zum Glück auch ganz einfach mit dem verketten von Strings.

Dabei spielt es keine Rolle, ob wir diesen String selbst schreiben, also im Sinne von „Das ist ein String“ (mit Anführungszeichen).

Oder ob wir den String wie oben vorher in einer Variable gespeichert haben.

Strings miteinander verketten

Durch die Verkettung von Strings können wir beliebig viele Strings aneinander reihen.

Das funktioniert in Kombination mit dem Verkettungsoperator – in Visual Basic ist das das „&„-Zeichen.

In anderen Sprachen ist es häufig das „+„-Zeichen, nur mal so als Anmerkung.

Hier hast Du ein Beispiel für die Ausgabe und die Verkettung von 2 Strings:

Dim befehl = "Download"
Console.WriteLine("Hey, in der Variable steht: " & befehl)

Dadurch wird nun diese Ausgabe auf der Konsole zustande kommen:

Beachte hierbei wie gesagt, dass es sich hier einfach nur um 2 Strings handelt, Welche wir verkettet haben.

Links ist ein String, rechts ist ein String – ganz easy, Punkt!

Du könntest stattdessen auch 5 Strings verketten, kein Thema, wobei ich hier sogar die Variable mehrfach genutzt habe:

Dim befehl = "Download"
Console.WriteLine("Das ist ein " & befehl & ", plus ein " & befehl & " mit Strings!")

Diese Verkettung funktioniert auch nicht nur bei der Ausgabe selbst, wir können die Variable auch so neu zuweisen:

Dim befehl = "Download"
befehl = "Dies ist ein " & befehl

Falls wir die String-Variable nur „erweitern“ möchten, also einen String anfügen wollen, geht das auch kürzer:

Dim befehl = "Download"
befehl &= " erweitert um das hier!"

Das „und-gleich“ (&=) könnte man hier als „erweitere um“ übersetzen, cool oder!?

Letztendlich sind also diese beiden Anweisungen hier praktisch das Gleiche:

befehl = befehl & " erweitert um das hier!"
befehl &= " erweitert um das hier!"

So, ich denke das war es an dieser Stelle für das heutige Tutorial, sonst dürfte es zu viel werden.

Fazit

Im heutigen Tutorial haben wir uns mit der ersten Ausgabe von Daten beschäftigt.

Diese Daten waren in erster Linie Strings, Welche wir als Literale, oder als Variablen geschrieben haben.

Zur Erinnerung: Literale sind einfach gewisse Schreibweisen, von Denen man ableiten kann, was der dahinter stehende Wert ist.

Ein Beispiel wären die Anführungszeichen im Quellcode, woran man erkennt, dass es sich um einen String handelt.

Anschließend habe wir verschiedene Verkettungsoperationen durchgeführt, um die Ausgabe ein wenig dynamischer zu gestalten.

Damit das Ganze überhaupt möglich war, haben wir natürlich auch noch ein neues Visual Studio Projekt aufgesetzt.

Downloads

Weiterführende Links

• weiter zu Tutorial 3 – Eingaben verarbeiten
• VB NET Timer Beispiel
• zurück zu Tutorial 1 – Variablen

Der Beitrag VB NET Tutorial 2 – Erste Ausgaben auf der Konsole erschien zuerst auf Robert Skibbe.

Variablen – Die digitalen Schubladen der Programmierung

Willkommen zum VB NET Tutorial 1, Deinem ersten Visual Basic NET Tutorial (jedenfalls aus meiner Tutorial-Reihe)! In diesem ersten Beitrag werde ich versuchen, Dir den Einstieg in die Programmierung mit Visual Basic NET zu ebnen. Das erste Visual Basic NET (oder kurz VB.NET) Tutorial wird sich um das wohl gängigste Anfänger-Thema drehen.

Stelle sicher, dass Du die Vorbereitungen und ersten Schritte abgeschlossen hast, bevor Du durchstartest! Ich werde vermutlich außerdem an jedem Tutorial-Ende ein downloadbares Beispielprojekt bereitstellen. Das kannst Du ganz einfach mit Visual Studio öffnen und brauchst zum Probieren nicht alles abtippen. Öffne ein beliebiges Projekt, indem Du die jeweilige „.sln“-Datei innerhalb des Download-Ordners öffnest. Das jeweilige Programm kannst Du mit „F5„, oder dem „Play“-Knopf starten. Beachte, dass es sich besonders bei den ersten Programmen meistens um Konsolenanwendungen handeln wird. Diese werden dadurch ausgezeichnet, dass Sie meist ohne die typische grafische Oberfläche auskommen. Ebenso werden Sie beendet, sobald Sie alle Codezeilen linear ausgeführt haben. Daher wirst Du eventuell nicht unbedingt etwas in der Ausgabe im Fenster sehen können.

Das VB NET Tutorial 1 im Videoformat auf YouTube

Natürlich hast Du auch die Möglichkeit, dieses Tutorial auf YouTube anzusehen.

Ich denke, dass ich bald eventuell mal eine Neuauflage des Videos machen werde.

Der wesentlich überarbeitete Inhalt hier, stimmt leider nicht mehr mit dem Video überein.

Mittlerweile ist das Video immerhin ein bisschen in die Jahre gekommen, aber natürlich trotzdem noch informativ.

Bis ich das Video allerdings erneuert habe, würde ich Dir diesen Beitrag hier eher ans Herz legen!

VB NET Tutorial 1: Variablen – Ein alter Bekannter aus dem Matheunterricht, oder!?

Im ersten Teil der Visual Basic NET Tutorial-Reihe, lernst Du die Verwendung von Variablen kennen.

Variablen an sich werden Dir vermutlich bereits ein Begriff sein, da Sie schon in der Schulzeit vorkamen.

Auch deren Verwendung in der Programmierung funktioniert analog zu Jenen aus dem Matheunterricht.

Letztendlich dienen Sie als Ablage für einen gewissen Wert, Welcher dynamisch verändert werden kann.

In der Programmierung verwendet man Variablen, um darin Daten zu speichern.

Variablen können „statisch“ gesehen, wie „x = 5“ definiert werden, oder z. B. das Ergebnis gewisser Prozesse sein.

Dabei spreche ich von dem Wert, der letztendlich „hinter“ der Variable steckt.

Unterschiedliche Wert-Arten – sogenannte Datentypen

Wie Du Dir sicherlich vorstellen kannst, wäre es ziemlich schwer, in der Programmierung nur mit Zahlen auszukommen.

Daher können Variablen glücklicherweise ganz viele verschiedene Werte, speichern.

Diese Werte können von sehr unterschiedlicher Natur, bzw. sogenannten Datentypen sein.

Seien es beispielsweise Zahlen, ein Geburtsdatum, einzelne Zeichen, oder gar ganze Texte.

Wäre blöd, wenn wir dem Nutzer sonst sagen müssten:

„Nein Herr/Frau Mustermann, Sie können keine Zahlen eingeben, unser Programm unterstützt nur Wörter!

Wäre ja sonst langweilig..

Du kannst Dir die dementsprechenden Blicke der Kunden mit Sicherheit vorstellen.

Letztendlich zurecht, denn obige Situation wäre vermutlich ein Armutszeugnis an Programm.

So wäre ein CRM-Programm und dessen Funktionen natürlich unmöglich vorstellbar.

Wobei die Rechnungsstellung so vermutlich Spaß machen würde – also so nur mit Zahlen 😛!

Eine Variable ist somit also ein Hilfsmittel, Welches uns erlaubt, mit Daten zu arbeiten.

Um mit Variablen zu arbeiten, können wir Diese mit einer Art „Namen“ ansprechen.

Man muss natürlich auch irgendwie sagen können: „Hey, du bekommst den Wert..“, oder „Gib mir mal bitte deinen Wert..“.

Aber genug davon, gehen wir über zum nächsten Punkt: Konkrete Beispiele.

VB NET Variablen – Let’s Go!

Nach außen wirken die Zuweisungen von Variablen also erstmal alle gleich.

Schließlich sagt man meistens einfach nur, dass ein irgendwie benanntes „Ding„, einen gewissen Wert bekommt.

Wie oben schon erwähnt, kann es sich dabei z. B. um die typischen Zahlen aus dem Matheunterricht handeln.

Für viele Anfänger wird es jedoch neu sein, dass Variablen auch „komplexe Daten“ speichern können.

Dabei handelt es sich eventuell um so etwas wie eine Lieferung, eine Rechnung, oder gar einen Kunden.

Natürlich setzen sich diese sogenannten Objekte auch wiederum auch aus den bekannten simplen Werten wie Zeichen, etc. zusammen.

Darüber werden wir allerdings erst in einem späteren Teil dieser Tutorial-Reihe sprechen.

Konkrete Beispiele

Nehmen wir als erstes Beispiel den in Deutschland wohl bekanntesten Namen, also einen Text, wie z. B. „Max Mustermann“.

Okay, zugegebenermaßen „Müller„, etc. wäre auch passend gewesen, aber bleiben wir einmal bei Herr Mustermann.

In der Programmierung nennt man diese Zeichenfolge – also eine tatsächliche Abfolge von Zeichen – einen String.

Als nächstes Beispiel könnten wir Jahreszahlen, wie z. B. 2020, 2021, oder 2022 nehmen.

Es gibt neben den stinknormalen Ganzzahlen noch weitere Arten, ich würde Dich zu diesem Zeitpunkt aber ungern überfordern.

Wir belassen es daher an dieser Stelle einfach dabei, dass es sich hier um einen „Integer“ handelt.

Eine kleine Zusatzinformation wäre noch, dass man natürlich auch negative Zahlen wie „-5“ verwenden könnte.

Der erste Code – VB NET Tutorial 1

Kommen wir nun zu unseren ersten Codezeilen, wo wir einfach mal 2 unterschiedliche Variablen definieren.

Der Quellcode zur Festlegung zweier Variablen mit den oben genannten Werten, würde so aussehen:

Dim vollerName As String = "Max Mustermann"
Dim jahresZahl As Integer = 2022

Ich werde auch gleich noch auf die unterschiedlichen Methoden zur Definition eingehen.

Zuerst schauen wir uns einmal an, was der Code im Detail macht und was dort für „Schlüsselworte“ sind.

Grundsätzlich könnte man den obigen Code erstmal als folgendes Muster beschreiben:

• Deklaration
• Dimensionierung
• Wertzuweisung

Wenn man sich eine obige Zeile ansieht, kann es dort vor allem als Anfänger schnell zur Verwirrung kommen.

Lass Dich nicht verwirren

Die Reihenfolge die ich beschrieben habe, stimmt ggf. nicht auf den ersten Blick mit dem Code überein.

Man könnten ja meinen, dass das Schlüsselwort „Dim“ für die Dimensionierung zuständig ist.

Würde ja zumindest allgemein sprach-technisch Sinn ergeben und so war es auch mal.

Zumindest galt das damals in VB6 für „Arrays“ (deutsch auch Felder/Datenfelder genannt).

Diese müssen Dir aber natürlich zum jetzigen Zeitpunkt noch nichts sagen, daher legen wir Sie erstmal beiseite.

Um das mit dem „Dim“ zu verstehen, muss man die Geschichte von VB NET (Visual Basic .NET) betrachten.

Ein Blick zurück zu (nur) Visual Basic

Kurz erklärt, entspringt die „NET„-Variante, Welche sich auf das NET Framework bezieht, aus der vorherigen VB- (nur Visual Basic) Version.

Dort war die „Dim„-Anweisung für die Speicherreservierung (Dimensionierung) von Arrays zuständig.

In Visual Basic NET wurde dieser Befehl sozusagen recycelt und dient von nun an der Deklaration von Variablen.

Im Endeffekt kündigt es also im ersten Schritt nur an: „Hey, da kommt was, was XY heißt“ – mehr nicht!

Merke Dir also: Möchte ich eine Variable definieren, verwende ich das Schlüsselwort „Dim„.

Die Dimensionierung, also die tatsächliche Speicherreservierung findet erst statt, sobald der Datentyp klar ist.

Datentypen werden durch die sogenannte „As“-Klausel angegeben, wodurch dann Speicher reserviert werden kann.

Klar, im Endeffekt kann man ja nur für etwas reservieren, von dem man weiß, was es ist!

Übung macht den Meister!

Auch wenn Du an dieser Stelle eventuell noch nicht durchblickst, vertraue mir, das kommt noch.

Häufig – und so ging es mir auch am Anfang – werden die Sachen erst bei aktiver Verwendung klarer.

Es kommt also manchmal einfach mit der Erfahrung, die Dinge zu verstehen.

Besonders wenn gewisse Dinge erstmal ins Muskelgedächtnis übergegangen sind ist das hilfreich.

Also dann, wenn Du den Zustand erreichen konntest, über einzelne Konstrukte beim Schreiben nicht mehr nachdenken zu müssen.

Arten der Definition

Oben haben wir nun die ersten beiden Beispiele für die Definition von Variablen gesehen.

Danach gab es noch ein paar wichtige, rudimentäre Zusatzinformationen zum Hintergrund von Visual Basic NET.

Lass uns nun mal schauen, Welche weiteren Definitionsmöglichkeiten wir für Variablen haben.

Diese Definitionsmöglichkeiten müssten wir für das bessere Verständnis vermutlich aufschlüsseln.

Sicherlich wird dies zu einem späteren Zeitpunkt z. B. noch beim Thema Klassen erweitert.

Zum jetzigen Zeitpunkt belassen wir es aber bei den Variablen-Basics.

Variante 1 – Die simple Deklaration

Im obigen Text habe ich schon einmal angedeutet, dass die obige Definition der Variablen von 3 Bausteinen geprägt ist.

Es geht allerdings für eine simple sogenannte Deklaration auch einfacher.

Dies ist dann mehr oder weniger nur eine Ankündigung der Variable, ohne jegliche Wertzuweisung.

Eine Wertzuweisung während der Deklaration bezeichnet man auch leicht anders, aber gleich mehr dazu.

Eine wirklich simple Deklaration a la „Hey, es gibt da das Ding namens XY sieht“ sieht daher so aus:

Dim vorname As String

Mehr ist dafür nicht von Nöten, nur:

• Das Dim-Schlüsselwort
• Name der Variable
• As <Datentyp> Klausel

Man könnte den Code auch einfach wie folgt ins Deutsche übersetzen:

Lege eine Zeichenketten-Variable namens „vorname“ fest – Punkt.

Variante 2 – Die Initialisierung

Das nächste Beispiel wird sich durch einen wie oben bereits gezeigten Mini-Schritt unterscheiden.

Auch wenn wir mit den vorherigen Beispielen schon erfolgreich Variablen deklarieren konnten, sind dies eben nur Deklarationen.

Wenn wir die Variablen nun direkt bei der Deklaration mit Werten versehen möchten, können wir das relativ einfach erledigen.

In der Programmierung nennt man das für gewöhnlich Initialisierung.

Ich deklariere also eine Variable und weise Ihr im selben Schritt bereits einen Wert zu.

Hier siehst Du noch einmal 2 Beispiele zur Initialisierung von Variablen:

Dim youtubeKanal As String = "RobbelRoot"
Dim alter As Integer = 30

Neben dem angesprochenen „Lege .. fest als ..“ kommt nun also noch etwas hinzu.

Wieder ist dies ein alter Bekannter aus dem Matheunterricht namens „Gleichheitszeichen„.

Hinter dem Gleichheitszeichen muss dann nur noch ein zum Datentyp passender Wert folgen.

Schließlich ist eine Zahl etwas anderes als ein „b“ und auch ein Geburtsdatum unterscheidet sich zum Beispiel.

Ein Geburtsdatum wäre ja sogar eine Mischung aus Zeichen und Zahlen.

Dieser Wert wird in diesem Kontext auch gerne als sogenanntes „Literal“ bezeichnet.

Variante 3 – Die Kombination aus beiden

Die letzte Variante zur Definition von Variablen ist die Kombination der beiden vorherigen Möglichkeiten.

Dabei verwenden wir wie gewohnt die „Dim„-Anweisung, jedoch lassen wir in diesem Fall die „As„-Klausel weg:

Dim preis = 149

In diesem Fall wird der Datentyp anhand des zugewiesenen Wertes ermittelt – toll, oder!?

Die sogenannte Typinferenz

Diese „Funktionalität“ nennt man Typinferenz, da der Typ von dem zugewiesenen Wert inferiert wird.

Inferieren heißt im Endeffekt nichts anderes als: etwas mitbringen, mit etwas beitragen, logisch fordern.

Ich persönlich finde die Erfassung von Datentypen via Typinferenz sehr angenehm und effizient.

Es sei jedoch angemerkt, dass es auch einige Entwickler gibt, Welche die Typinferenz verteufeln.

Diese Entwickler sind der Meinung, dass diese non-explizite Weise der Typangabe unsauber ist.

Obwohl wir noch nicht beim Thema „verschiedene Zahlen-Datentypen“ angekommen sind, mache ich mal ein Beispiel.

Lass Dich aber nicht davon verwirren, da es vermutlich im zweiten Teil zu den Variablen angesprochen wird.

Warum manche Entwickler die Typinferenz ablehnen

Unter anderem dieses Beispiel könnte die Ablehnung mancher Entwickler gegenüber der Typinferenz erklären:

Dim unbekannteZahl = 5

Wenn Du diesen Code einmal in Deine Programmierumgebung namens Visual Studio eingibst, wirst Du folgendes sehen:

Es wird hier automatisch der Datentyp „Integer“ suggeriert, was aber nicht zwangsweise stimmen muss.

Wenn ich zum Beispiel im Programm mit Dezimalzahlen arbeiten möchte, wäre dies hier schon nicht mehr „möglich“.

Zumindest dieses kleine Problem könnte man schnell lösen, wenn man das „richtige“ Literal verwendet:

Dadurch würde ich nun die Möglichkeit haben, mit Dezimalzahlen zu arbeiten, aber da gibt es leider noch mehr..

Daher gehen wir an dieser Stelle nochmal zurück zu dem Integer, also der einfachen Ganzzahl.

Wie wir im nächsten Tutorial-Teil zu den Variablen noch lernen werden, gibt es dort Unterschiede.

Man könnte – ohne zu viel zu spoilern – sagen, dass es unterschiedliche Größen, bzw. Bereiche gibt.

Er weiß nicht sollte wissen was er tut..

Das typische „Byte„, wovon viele irgendwo mal gehört haben, kann eine weniger große Zahl, als Andere Zahlen-Datentypen speichern.

Im Vergleich dazu hätten wir auch noch die riesige Zahl namens „Long„, Welche wirklich (wirklich) große Zahlen speichern kann.

Also erneut: Mit dem obigen Beispiel des „Integers“ suggerieren wir einfach eine gewisse Größe.

Solange man das weiß ist alles gut, wenn man es eventuell übersieht, kann es blöd werden.

Ansonsten kann man dann wie erwähnt noch durch gewisse Literale nachhelfen.

Letztendlich bestimmt das entwickelnde Software-Team nachher die Konventionen.

Oft bekommt man durch die Arbeit als Entwickler auch gewisse „Schreib-Regeln“ vorgesetzt.

Dies kann durch das Team, den Chef, oder z. B. durch den Kunden geschehen.

Bäumchen wechsle dich!

In den bisherigen Beispielen haben wir uns größtenteils mit der Definition von Variablen beschäftigt.

Wer sich aber die Bezeichnung „Variable“ selbst einmal anschaut, wird etwas feststellen.

Das Nomen „Variable“ steht nicht umsonst in Verwandtschaft mit dem Adjektiv „variabel„.

Der Inhalt, bzw. der Wert hinter der Variable ist – richtig vermutet – nicht statisch.

Wir können den Wert also zur Laufzeit des Programmes dynamisch anpassen.

Weitere „Arten“ von „Variablen“

Später werden wir auch noch weitere Arten von Variablen kennenlernen.

Diese sind im Gegensatz dazu nicht variabel, sprich man kann Sie nicht ändern.

Welche Vorteile und eventuell auch Nachteile daraus entstehen können, schauen wir uns später an.

Ein kleiner Spoiler wäre, dass es sich dabei z. B. um Konstanten handelt.

Wie der Name schon vermuten lässt, sind Diese eben halt – konstant, sprich nicht veränderbar!

Zurück zur Variable, Welche eigentlich für das Wort „veränderbar“ stehen könnte.

Wert einer Variablen ändern

Initialisieren wir also wie neu gelernt eine Variable via Typinferenz.

Zur Wiederholung: Wir leiten den Ziel-Datentyp aus dem zugewiesenen Wert ab.

Dim vorname = "Robert"

Ich habe hier also das „Dim„-Schlüsselwort verwendet und anschließend einen Namen (vorname) festgelegt.

Im gleichen Schritt haben wir der Variable einen Wert zugewiesen, sprich initialisiert.

Durch die Angabe eines Strings, also einer Zeichenfolge mit dem Inhalt „Robert“, kennt die Variable ihren Datentyp.

In diesem Fall bekommt die Variable ihren Datentyp „String“ also über die Typinferenz.

Um diese Variable nun ganz einfach im nächsten Schritt zu ändern, machen wir praktisch das Gleiche nochmal.

Nur dieses Mal verwenden wir nicht das „Dim“-Schlüsselwort, da diese Variable in der nächsten Zeile bereits „bekannt“ ist.

Durch die Bezeichnung der Variable (vorname), können wir Diese nun ganz einfach ansprechen.

Dann führen wir einfach eine erneute Zuweisung eines Wertes durch.

Dim vorname = "Robert"
vorname = "Max"

Auf den richtigen Typ kommt’s an

Hierbei gilt es natürlich zu beachten, dass die Variable einen zum Deklarationstyp passenden Wert bekommt.

Ich könnte natürlich jetzt nicht hingehen und einer „String„-Variable plötzlich eine Zahl zuweisen.

Es würde verständlicherweise einen Fehler in unserer Programmierumgebung anzeigen.

Das gleiche Problem hätten wir auch bei einem eigens erstellten Datentyps wie einem „Kunden“.

Auch dazu werden wir später im Kapitel „Klassen“ noch einiges lernen!

Fazit

Am Ende des ersten VB NET Tutorials angekommen, ist es Zeit für ein kleines Fazit:

Variablen dienen uns in der Programmierung also als eine Art Zwischenspeicher für Werte.

Mit diesen Werten können wir dann in verschiedenen Situationen (namentlich angesprochen) arbeiten.

Der Wert hinter den Variablen kann zur Laufzeit des Programms dynamisch geändert werden.

Variablen werden üblicherweise mit einem gewissen Datentyp definiert, damit „man“ weiß, womit man arbeitet.

Deshalb muss man auch bei der nachträglichen Änderung des Wertes auf den Datentyp achten.

In späteren Tutorials werden wir uns natürlich auch mit dynamischen Datentypen beschäftigen.

Man weiß nicht unbedingt in jedem Moment den exakten Datentyp, daher muss oft auch ein wenig Flexibilität her.

Es gibt 3 gängige Arten Variablen zu definieren:

• Deklaration = Ankündigung mit Datentyp
• Initialisierung = Ankündigung mit Datentyp & Wertzuweisung
• Init. durch Typinferenz = Ankündigung ohne expliziten Datentyp, jedoch via Inferenz

Im nächsten Tutorial

Das nächste Tutorial wird ein zweiter Beitrag zum Thema Variablen sein.

Dort werde ich noch mehr auf die unterschiedlichen Typen, deren Verwendung und weitere Tipps eingehen.

Ebenso konnten wir bisher nicht wirklich viel von den Variablen sehen, da Sie mehr oder weniger „geschluckt“ wurden.

Daher werde ich zeigen, wie man die Variablen dann wirklich visuell darstellen, also „ausgeben“ kann.

Dadurch werden Sie für den Endnutzer und letztendlich uns sichtbar, wenn auch erstmal nicht schön.

Das haben sogenannte Konsolenanwendungen aber so an sich, gell!?

Downloads

Weiterführende Links

• weiter zu Tutorial 2 – erste Ausgaben
• VB NET Inputbox – Simple Eingaben entgegennehmen
• Timer Beispiel in VB NET

Der Beitrag VB NET Tutorial 1: Variablen erschien zuerst auf Robert Skibbe.

Hacking User & Password information from a NET Assembly

So you are interested in hacking a simple NET Application with like all the nerdy stuff!?

Then i’m glad to tell you, that you are very welcome, go ahead and let’s hack!

This example will work for C# as well, even it is presented with a Visual Basic NET Application.

In the first few lines i will write a bit about my own experience with hacking, that i experienced „on“ myself.

After that i will show you some kind of basic example application, which is like our victim.

In the last step i will explain, which tool you would need to inspect those specific files.

You will also learn how to find the information you need inside those tools.

Liking humour & videos? Heres the YouTube version

If you like watching videos and having like actual live examples – i’ve also got you covered!

Just visit my YouTube channel or click the following video to load and watch it:

Why knowing how to hack some things is important

Even if you’re not that in the dark sitting hacker person, yet knowing about hacking is very important in terms of programming.

Why – you ask? Because actively hacking has obviously something really important to do with the opposite.

Knowing how attacker actually attacks, will make you stronger in defending yourself.

So if you understand the concepts, you have a (better) chance to actually defend against them – right!?

You can see, that the old and good saying „wisdom is power“ isn’t that bad at all.

This also counts for programming or software development as well.

Sometimes learning attacking turns to defending

Defending against hackers in a possible matter, is like one of the basic essences.

I mean who wants to build application basically everyone could get like for free, or even script kiddies can crack.

Sure there are unavoidable situations or better said different aspects, where you can’t protect yourself, or your app.

I had to hardly learn myself, that those aspects aren’t the real key of importance, too!

This is where we are about to switch to my own little story behind that whole thing.

My own background and contact points of hacking

Even if i don’t really know to where like i should actually start telling you, i will try to find some starting point.

One of the things, which stuck in my mind till today – and it’s like 15 years ago – is the following thingy.

I was a little gamer bro, who was playing his current MMO called „Silkroad Online“ like insane.

Everyone who knows about the so called „china grinders“ knows what i’m talking about..

Those games are the definition of „spend all your time“, because they are so grinding based, hence the name..

A whole load of work – gone

You are essentially slaying like 5000 monsters to get almost no drops and zero exp.

As you can imagine there were like many scammers and fakers which tried to scam or hack your account.

Despite this i liked the game and i can’t exactly tell why, i think it was the chinese and dragonball like style.

You had like this whole chinese world built around the silkroad lore (and i really love „the“ asian lore).

Then there was this dragonball like aspect, where you can shoot your own „kamehameha“ which kept me for long enough.

In the end i spent hours and hours fighting those monsters for like almost nothing and even wasted some *cough* bucks.

As i always had this „hmm, i gotta find a solution for that“-mentality, i also tried to do this time.

After all the outcome wasn’t that good in the end, but well, i think that’s the price you gotta pay, huh!?

Searching for help

So i started searching for like helpers with leveling and found different leveling services, but they were mostly very expensive..

Not much time after that, i found something called „bot„, which was basically just a software.

Those were/are tools which will take the leveling aspect in their hand and basically tell your ingame character what to do – so you don’t have to.

There was a free bot which i downloaded and installed and boom – the problem happened.

It did its level job pretty well, but had like an integrated trojan aspect, which spied on my credentials and transferred my data to its owner.

So not many days after the installation, one of my accounts was gone – yeah, i had multiple…

This is the whole story why i started learning programming and hacking – i wanted to create my own bot to compensate my lost time and my lost account!

Back to the main topic – hacking a NET application!

How i started programming like logins – ew

So now the story begins, where i started programming at all and like login screens.

I think every beginner in programming did it like this at some point.

On the one side you are just making your first steps and on the other side you just want to make it work.

You don’t have much knowledge – if any at all – about this persistence thingy called database, nor the security thingy called cryptography, etc.

This makes you – especially at the beginning – think, that you can just do this thing, which is known as hardcoding.

You just put variables inside the code (or something similar) with fixed values like:

variableA = "ValueB"

Then you can go ahead and easily compare this value in terms of an authentication screen like:

user = "User"
password = "password"
if enteredUser = user and enteredPassword = password then...

So far this doesn’t seem like anything hacky, but read a few more lines and let me explain!

One big problem is, that even if you think that only „noobs“ do this, i’ve seen too many agencies and similar small firms did that as well.

I mean it’s one thing if you’re doing this on your own, local computer, for yourself with no customer data involved.

But i really think it’s something different when „companies“ do things like this, knowing that it’s totally wrong!

Especially in my work as a freelancer & teacher i learned, that small business i supported, sometimes persisted on like „nah we will do it like this, it’s okay“.

Some other excuses i hear a lot are like „It’s only a small customer, that’s okay“, or „there’s no budget left, just do it“!

Even if this involved software for other customers which got their software like delegated to freelancers.

Creating the sample application – our victim

So now let’s jump to the hacking action and see what malicous things can actually happen if you’re doing it like above yourself.

You can go ahead now and create a new windows forms application (dotnet Core 3.1 in the example above).

The first Form will be the „frmLogin„, which is – as you’ve may guessed – the form where the login will happen.

Basic login form controls

Add the usual login controls like 2 textboxes for the user and the password, as well as the button to start the login process.

Name the button – like you should always do – for example „btnLogin“ and put the following code inside the handler:

Private Sub btnLogin_Click(sender As Object, e As EventArgs) Handles btnLogin.Click
    Dim loginFailed = Not CheckLogin(tbUser.Text, tbPassword.Text)
    If loginFailed Then
        MessageBox.Show("Login failed!")
        Return
    End If
    successfullySubmitted = True
    Dim mainForm = New frmMain()
    mainForm.Show()
    Close()
End Sub

private void btnLogin_Click(object sender, EventArgs e)
{
    var loginFailed = !CheckLogin(tbUser.Text, tbPassword.Text);
    if (loginFailed)
    {
        MessageBox.Show("Login failed!");
        Return;
    }
    successfullySubmitted = true;
    var mainForm = new frmMain();
    mainForm.Show();
    Close();
}

The code will call the check „Check-Login“-function which we will declare in a second and invert the result.

We are doing this to use this „early return„-block in the next few lines, to display a short message and well – return early.

Then we are setting a flag to true, to avoid closing the form, but ignore this for now, you can see it later with the complete code.

The protected content – the main form

Next we are creating a new „frmMain“ instance and show it in the next step.

In the last step we are closing the current form, so we are basically closing the login form, to only leave the main form open.

Right now is the time to define the „CheckLogin„-function, before we continue adding the main form:

Private Function CheckLogin(user As String, password As String) As Boolean
    Dim credentialsMatching = user = "User" AndAlso password = "password"
    Return credentialsMatching
End Function

private bool CheckLogin(string user, string password)
{
    var credentialsMatching = user == "User" && password == "password";
    returnn credentialsMatching;
}

Now create an additional form and call it like „frmMain“, you can leave the form as it is.

You could add something like code to handle the closing of the app for you, but this isn’t necessary.

Maybe you want to download the complete project down below, so you can see everything in total.

Currently the app should look something like this:

Hacking our sample application

To actually start hacking our little NET application, you need a tool, which is actually provided by the NET Framework itself.

So there is no big magic, or big action like „yeah you need to download x, y, z.. blabla..“.

Everything you need, is mostly already in place, if you installed Visual Studio.

The needed tool – „ildasm“

The tool needed is called „IL-Disassembler“ or in short „ildasm“ and resides in the „C:\Program Files (x86)\Microsoft SDKs\Windows\v10.0A\bin\NETFX 4.8 Tools“ folder.

Maybe you will find the tool in a slightly different location, if you have a different version of Visual Studio, etc.

Double click the tool to open it and the following screen will appear:

Then go ahead and select your „<YourApplicationName>.dll„-file with the „File->Open“ menu item (sorry, i only have the german version).

You can find this file inside the debug folder of your app (don’t forget to start debugging at least once, so the files are created!).

Just a quick side note: This will also work for the release „.dll“-file!

Expand the nodes as shown in the screenshot, then you will find the function we are looking for.

If you finally double click that „CheckLogin“-function, a dialog will appear, where you can inspect the IL code for this function.

There you will see you hardcoded credentials – congratulations, you hacked the program!

Downloads

Related posts

• How to filter a DataGridView in VB NET
• Hacking a Webshop
• Converting DaVinci Resolve markers to YouTube chapters

Der Beitrag 🕵️ Hacking a NET Application erschien zuerst auf Robert Skibbe.

So you want to start converting DaVinci Resolve markers to YouTube chapters – fully automated?

Here you will find 2 free tools to do so 😉!

Just paste the content of the „.edl“-file into the left textbox and the magic will happen.

Alternatively, you can simply drag and drop the file into the field and save yourself opening the file.

Background to DaVinci Resolve markers & YouTube chapters

Ultimately, you can export so-called „editing decision lists“ from your DaVinci Resolve timeline.

These arise or can be created by setting „markers„, i.e. small bookmarks, in DaVinci Resolve.

It is best to imagine it like a book in which you attach small bookmarks to certain pages so that you can remember this point later.

Each of these bookmarks – called „markers“ in DaVinci Resolve slang – you can also add text, i.e. a kind of title.

It wasn’t that long ago – 2 days lol to be precise – when I faced the problem myself for the first time.

So I went there more or less usual, made my videos and set the markers in DaVinci Resolve.

As mentioned, I did this so that I could quickly find the important points while I was working on it.

Later I realized that I could just as easily use these passages for my YouTube chapters.

Of course I didn’t feel like copying everything out by hand, so I looked for a tool.

Unfortunately I couldn’t find a tool quickly, but luckily you are a programmer and can build one yourself 😎.

Extension 1 – Converting multi color markers to YouTube chapters

Supporting multiple colors

Of course, a few small ideas came to mind with this tool after it was finished.

Currently the converter can process only one marker color, which may not be sufficient for some (a few?) applications.

It doesn’t matter which colors are present in the code, as the tool always takes the color from the first „dataset“ as the main color.

In theory, it wouldn’t be really difficult to add multiple colors since I was looking for extensibility in the code as always.

However, I still have to think about how to implement this as a surface, as I want to keep it intuitive.

Extension 2 – Windows Tool for eleminating manual work

Converting EDL files on creation

Programmers are known to be lazy, creative / innovative, so I thought about something.

Especially people who upload videos every day have this recurring task in front of them.

Filming, cutting, setting DaVinci Resolve markers, exporting, etc. every day – sigh.

Then going to my * wink * homepage and use the YouTube chapter converter, so:

• Open download folder
• Visit my page/open the tab
• Drop file into webbrowser
• copy chapters
• Open the Youtube video
• Paste chapters..

Anyone who knows me knows that I’m not a big fan of recurring „monkey work“, so the following idea came up:

How about a small Windows tool, which can recognize the creation of an „.edl“ file within a folder?

You could of course make this folder configurable and thus adapt it to your needs.

One should also be able to switch off the tool without closing it, of course.

Then the tool could go there and, if it detects the creation of a file, take this file and process it directly.

After the successful processing, the YouTube chapters could be placed on the clipboard immediately – automatically!

No sooner said than done – I implemented the tool quickly and this is what it looks like (I did without an overly beautiful design, sorry ..):

Downloads

Related posts

• Hacking a NET Application
• Filtering a VB NET DataGridView
• Removing items from a ListBox

Der Beitrag Converting DaVinci Resolve markers to YouTube chapters erschien zuerst auf Robert Skibbe.

Du möchtest DaVinci Resolve Marker in YouTube-Kapitel umwandeln und hast keine Lust selbst Hand anzulegen!?

Dann findest Du hier zwei Tools – in Form eines Webinterfaces und einer kleinen App – um dies automatisiert erledigen zu lassen 😉!

Füge einfach den Inhalt der „.edl„-Datei in das linke Textfeld ein und schon passiert die Magie.

Alternativ kannst Du die Datei auch einfach via „Drag & Drop“ in das Feld ziehen und sparst Dir so das Öffnen der Datei.

Hintergrund zu DaVinci Resolve Markern & YouTube-Kapiteln

Letztendlich kannst Du sogenannte Editierentscheidungslisten aus Deiner DaVinci Resolve Timeline exportieren.

Diese entstehen, bzw. können dadurch erstellt werden, dass Du in DaVinci Resolve „Marker„, also kleine Lesezeichen setzt.

Stell‚ es Dir am besten wie ein Buch vor, in dem Du auf gewissen Seiten kleine Lesezeichen einhängst, um Dich später an diese Stelle zu erinnern.

Jedes dieser Lesezeichen – im DaVinci Resolve Slang „Marker“ genannt – kannst Du zusätzlich mit Text, also einer Art Titel versehen.

Es ist gar nicht allzu lang her – um genau zu sein 2 Tage lol – wo ich das erste Mal selbst vor dem Problem stand.

Ich ging also wie mehr oder weniger gewohnt hin, machte meine Videos und setzte die Marker in DaVinci Resolve.

Das habe ich wie erwähnt deshalb gemacht, damit ich eben während meiner Bearbeitung schnell zu den wichtigen Stellen finde.

Nachträglich habe ich dann gemerkt, dass ich diese Stellen auch ebenso gut für meine YouTube-Kapitel nutzen könnte.

Natürlich hatte ich wenig Lust alles händisch herauszukopieren, also suchte ich nach einem Hilfsmittel.

Leider habe ich kein Tool auf die Schnelle gefunden, aber zum Glück ist man ja Programmierer und kann sich selbst eins bauen 😎.

Erweiterung 1 – Mehrfarbige Marker in YouTube-Kapitel umwandeln

Unterstützung mehrerer Farben

Natürlich kamen mir auch bei diesem Tool nach der Fertigstellung noch einige kleine Ideen in den Kopf.

Aktuell kann der Konverter z. B. nur eine Marker-Farbe verarbeiten, was für einige (wenige?) Einsatzfälle vielleicht nicht ausreicht.

Aktuell ist es egal, welche Farben im Code vorhanden sind, da das Tool immer die Farbe aus dem ersten „Datensatz“ als Haupt-Farbe nimmt.

Theoretisch wäre es nicht wirklich schwer, mehrere Farben hinzuzufügen, da ich im Code wie immer auf Erweiterbarkeit geachtet habe.

Ich muss mir allerdings noch überlegen, wie ich das als Oberfläche realisiere, da ich es weiterhin intuitiv halten möchte.

Erweiterung 2 – Windows Tool zur Eliminierung manueller Arbeit

EDL-Dateien bereits beim Erstellen umwandeln

Programmierer sind ja bekanntlich faul kreativ/innovativ, also habe ich mir noch was überlegt.

Besonders Menschen die täglich Videos hochladen, haben diese immer wiederkehrende Aufgabe vor sich.

Jeden Tag Material filmen, schneiden, DaVinci Resolve Marker setzen, exportieren, etc. – seufz.

Danach auf meine *zwinker* Homepage gehen und den YouTube-Kapitel Konverter nutzen, also:

• Download-Ordner öffnen
• Meine Seite öffnen / Tab öffnen
• Datei in den Webbrowser droppen
• Kapitel kopieren
• YouTube-Video öffnen
• Kapitel einfügen..

Wer mich kennt weiß, dass ich kein großer Fan von wiederkehrender „Monkey-Work“ ist, also kam folgende Idee:

Wie wäre es mit einem kleinen Windows-Tool, Welches die Erstellung einer „.edl“-Datei innerhalb eines Ordners erkennen kann?

Diesen Ordner könnte man natürlich konfigurierbar machen und somit an seine Bedürfnisse anpassen.

Ebenso sollte man die Möglichkeit haben, dass Tool ohne schließen abzuschalten, klar..

Danach könnte das Tool hingehen und sich bei erkannter Erstellung einer Datei, diese Datei nehmen und direkt verarbeiten.

Nach der erfolgreichen Verarbeitung könnten die YouTube-Kapitel also sofort in die Zwischenablage gelegt werden – automatisch!

Gesagt, getan – habe das Tool fix umgesetzt und so sieht es aus (ich habe auf übermäßig schönes Design verzichtet, sorry..):

Downloads

Weiterführende Links

• Erstelle dein eigenes VB NET Plugin-System
• Ein alternatives Webbrowser Steuerelement
• VB NET Formulare automatisch ausfüllen

Der Beitrag DaVinci Resolve Marker in YouTube-Kapitel umwandeln erschien zuerst auf Robert Skibbe.

VB.NET data binding Tutorial

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

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

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

Drum binde sich, wer nicht ewig prüfen will

Das sagte der deutsche Immunbiologe und Aphoristiker Gerhard Uhlenbruck.

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

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

Damals war alles besser – WinForms-Zeiten

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

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

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

Eine kleine Wiederholung – VB.NET data binding Tutorial

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

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

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

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

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

Darstellungsprobleme

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

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

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

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

Datenbindung mit Benachrichtigungsmechanismus – VB.NET data binding Tutorial

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

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

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

Vorhandene Bordmittel nutzen

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

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

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

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

Voraussetzungen – VB.NET data binding Tutorial

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

Implementierung INotifyPropertyChanged-Schnittstelle

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

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

Private _textBoxtext As String

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

private string _textBoxText;

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

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

Eigenschaft definieren

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

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

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

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

Helper-Methode – VB.NET data binding Tutorial

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

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

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

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

Änderungen der Eigenschaft kommunizieren

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

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

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

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

Private _textBoxtext As String

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

private string _textBoxText;

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

Wann Änderungen kommuniziert werden

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

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

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

Weitere abhängige Eigenschaften

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

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

NotifyOfPropertyChange("<TheDependentProperty>")

WinForms Beispiele – VB.NET data binding Tutorial

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

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

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

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

TextBox Text an String binden

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

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

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

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

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

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

TextBoxText = "My New Text"

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

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

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

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

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

CheckBox an Boolean binden

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

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

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

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

ListBox an simple Auflistung binden

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

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

Public Property StringList As BindingList(Of String)

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

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

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

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

DataGridView Datenbindung mit Objekten

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

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

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

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

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

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

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

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

WPF Beispiele – VB.NET data binding Tutorial

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

TextBox und TextBlock an String binden

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

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

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

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

Auch hier kannst Du die Eigenschaft von oben verwenden.

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

CheckBox an Boolean binden

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

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

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

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

ObservableCollection an ListBox und DataGrid binden

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

Public Property Customers As ObservableCollection(Of Customer)

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

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

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

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

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

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

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

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

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

Downloads – VB.NET data binding Tutorial

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

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

Du möchtest Dein eigenes VB.NET Game entwickeln und dies sauber und mit Spaß umsetzen?

Dann bist Du mit deiner Recherche genau auf den richtigen Beitrag meiner Seite gestoßen!

Vielleicht interessieren Dich später auch noch die folgenden Beiträge: VB.NET Slot Machine, AddHandler-Anweisung, Sleep-Timer.

Vorschau auf das Spiel

Hier siehst Du im Sinne einer Vorschau ein kleines Bild von dem fertigen Spiel.

Vorwort – VB.NET Game

Ich möchte an dieser Stelle direkt anführen, dass ich dieses Beispiel hier so einfach und nachvollziehbar wie möglich gestalten möchte.

Daher werden wir hier für den Anfang bei einem simplen und jedem bekannten Spiel bleiben.

In späteren Beiträgen werde ich aber sehr sehr wahrscheinlich noch andere kleine Spiele vorstellen und erläutern.

Es wird hier also leider nicht das nächste Call of Duty erstellt 😛!

Ich werden hier ausschließlich vorhandene Steuerelemente und verwende auch kein GDI+.

Das kommt eventuell noch in einer verbesserten Version, also für eventuelle fortgeschrittenere Personen.

Ein eigenes Spiel – Der Traum vieler Entwickler

Viele Entwickler – so auch ich damals – finden ihren Weg teilweise gerade durch das Interesse am Gaming zur Softwareentwicklung.

Manchmal haben Sie dabei auch direkt eigene Pläne, vielleicht sogar schon ein konkretes Ziel: „Ich möchte mein eigenes Spiel entwickeln!“.

Häufiger Stand dabei ist leider: Keine Vorerfahrung, mangelnde Grammatik (man weiß nicht wonach man suchen muss) und vor allem so mancher Code der im Netz kreucht und fleucht.

Der Blick zurück

Mannoman, wenn ich so an meine eigenen Anfänge der .NET Entwicklung zurückdenke, dann denke ich vor allem an mein Interesse, einen eigenen Bot zu bauen.

Ich war damals zugegebenermaßen so dämlich, mir eine Fremdsoftware von einem dubiosen Anbieter herunterzuladen und zu verwenden.

Diese führte dann leider dazu, dass ich meinen Account von einem Spiel was ich zu der Zeit gespielt habe, verloren habe – ich wurde gehackt.

Bei diesem Spiel handelte es sich um ein typisches China–Grinder, sprich viele Stunden mit leveln zu verbringen und wenige bis kaum Erfolge, bzw. Level-Ups!

Die Hürden – VB.NET Game

Wie ich oben schon angesprochen habe, hat man vor allem am Anfang viele Hürden zu bekämpfen und die vielen Argumente aus Foren wie „Lerne die Basics“ will man natürlich nicht hören.

Natürlich sind diese Argumente mehr als berechtigt und durchaus sinnvoll, aber man möchte dies wie erwähnt nicht hören.

Ich selbst hatte dort schon immer einen Sturkopf und wenn ich nun einmal ein Spiel bauen wollte, dann wollte ich halt ein Spiel bauen..

Dann bekam man auch z. B. noch weitere Kritik zu hören, dass VB.NET nicht dafür geeignet sei, ein Spiel zu programmieren.

GDI+ wäre zu langsam und Prozessor-lastig und und und..

Die traurige Wahrheit ist, dass diese Aussagen erstmal soweit alle im Kern stimmen – im Kern!

Wer allerdings seine ersten Erfahrungen mit kleinen Spielen wie TicTacToe, Schiffe versenken, oder ähnlichen Spielen sammeln möchte – mein Gott, „Do It!“.

Du wirst vermutlich nur nicht das grafische Wunder schlechthin mit VB.NET, GDI+ und Co. bauen können, das muss Dir klar sein.

Los geht’s TicTacToe – VB.NET Game

Jetzt beginnen wir mit unserem kleinen TicTacToe-Game und fangen beim Begrüßungsbildschirm an.

Begrüßungsbildschirm

Wie man es aus Spielen kennt, sieht man am Anfang einen kleinen Begrüßungsbildschirm, Welchen auch wir fix einbauen werden.

Stelle zuerst in den Projekteigenschaften (Projekt->Eigenschaften->Anwendung) den Modus für das Herunterfahren auf „beim schließen des letzten Formulars„.

Form-Eigenschaften

Dafür ändern wir die Eigenschaften der aktuellen Hauptform (meist Form) auf:

• Name: frmWelcome
• DoubleBuffered: True
• StartPosition: CenterScreen
• Size: 640; 480
• FormBorderStyle: None
• BackgroundImage: bg.jpg

Das Hintergrundbild findest Du als Bestandteil des Beispielprojekts in den Downloads weiter unten.

Füge das Hintergrundbild als Ressource unter Projekt->Eigenschaften->Ressourcen durch z. B. Drag & Drop hinzu.

Danach erscheint das Bild auch im Ressourcen-Ordner im Projektmappen–Explorer.

Titel-Label

Füge als nächstes ein Label für den Titel hinzu und stelle die Eigenschaften wie es Dir passt ein, für mein Beispiel jedoch wie folgt:

• Name: lblTitle
• BackColor: Transparent
• Font: Arial Black; 48pt; style=Bold
• ForeColor: White
• Text: TicTacToe

Und positioniere das Label nach deinem Belieben auf der Form.

Buttons

Nimm im nächsten Schritt 2 Buttons zur Hand und stelle diese Eigenschaften ein:

btnStartGame

Ein Knopf zum Starten des Spiels:

• Name: btnStartGame
• BackColor: LimeGreen
• FlatAppearance: BorderColor Black, BorderSize 3
• FlatStyle: Flat
• Font: Arial; 12pt; style=Bold
• Size: 196; 55
• Text: Start Game

btnExit

Der Knopf zum Beenden des Spiels (vor Beginn).

Hat soweit die gleichen Eigenschaften wie der andere Button, nur eventuell eine andere Farbe inkl. Text.

• Name: btnExit
• BackColor: IndianRed
• Text: Exit

Die Button-Handler

Gehen wir nun z. B. durch einen Doppelklick auf die Buttons, in die Handler der Buttons und fügen folgenden Code ein:

Public Class frmWelcome

    Private Sub btnStartGame_Click(sender As Object, e As EventArgs) Handles btnStartGame.Click
        Dim frmTicTacToe = New frmTicTacToe()
        frmTicTacToe.Show()
        Close()
    End Sub

    Private Sub btnExit_Click(sender As Object, e As EventArgs) Handles btnExit.Click
        Application.Exit()
    End Sub

End Class

Beim Klicken des Start-Buttons wird die aktuelle, also die Begrüßungsform geschlossen und anschließend die andere Form angezeigt.

Denke hier an den obigen Hinweis, sonst wird sich hier das gesamte Programm schließen.

Danach wird eine neue Instanz der TicTacToe-Form erstellt und angezeigt und schon geht es los.

Der Schließen-Button macht nichts anderes als – wer hätte es gedacht – die Anwendung zu schließen.

Man könnte hier auch einfach Close allein verwenden, da wir vorher kein anderes Formular angezeigt haben.

TicTacToe VB.NET Game Formular

Nun geht es mit dem Formular für das Spiel selbst und der Logik dahinter weiter.

Füge dazu ein weiteres Formular hinzu und setze folgende Eigenschaften:

• Name: frmTicTacToe
• StartPosition: CenterScreen
• Text: TicTacToeExample
• Size: 640; 480
• FormBorderStyle: None
• DoubleBuffered: True

Danach brauchst Du ein SplitContainer, Welcher das Formular in 2 Bereiche einteilt:

• Name: splcGame
• Dock: Fill
• FixedPanel: Panel1
• IsSplitterFixed: True
• Size: 640; 480
• SplitterDistance: 156
• SplitterWidth: 1

In den rechten Bereich des SplitContainers fügst Du nun ein TableLayoutPanel hinzu:

• Name: tlpGame
• BackgroundImage: game_bg
• BackgroundImageLayout: Stretch
• ColumnCount: 3
• RowCount: 3
• Dock: Fill

Den linken Bereich des SplitContainers, also das Panel1 bekommt folgende Eigenschaften:

• BackgroundImage: sidebar

Danach füge 4 Labels und 2 Buttons hinzu, wovon 2 Labels als Anzeige dienen (Rest-Zeit und welcher Spieler dran ist) und 2 als Beschreibung dafür.

Die beiden Buttons sind letztendlich für das Schließen der Anwendung und dem Zurückkehren in das Hauptmenü zuständig.

Code des Spiels – VB.NET Game

Eigenschaften

Random

Eine Instanz der Random-Klasse um uns das zufällige Auslosen des Start-Spielers zu ermöglichen.

XImage

Ein Objekt aus den Ressourcen, einmalig abgerufen um den Vergleich und das Setzen der Bilder zu ermöglichen.

CircleImage

Analog zum Bild hier drüber..

PlayerTurn

Ein Boolean, Welcher den aktuellen an der Reihe befindlichen Spieler widerspiegelt.

IsPlayerOnesTurn

Auf PlayerTurn basierender boolischer Wert, Welcher angibt ob Spieler 1 gerade dran ist.

IsPlayerTwosTurn

Analog zum Wert hier drüber, nur für Spieler 2.

Konstruktor

new()

Der Konstruktor instanziiert die Random-Klasse und setzt einmalig die Bilder, Welche später für die Pictureboxen (Spiele-Token) verwendet werden.

Zum Schluss laden wir die Pictureboxen in einer Schleife, um nicht 9 mal das Gleiche Prozedere im Designer machen zu müssen.

Methoden

InitializePictureBoxes

Generiert alle 9 Pictureboxen und fügt Sie dem TableLayoutPanel hinzu.

CreatePictureBox

Erstellt eine Picturebox mit den gewünschten Styles und dem benötigten Klick–Ereignishandler.

PictureBox_Click

Wenn eine Picturebox geklickt wird, wird die Picturebox mit Typecasting ausgemacht.

Danach wird überprüft, ob das Bild der Picturebox schon gesetzt wurde, wenn ja, wird die Sub durch Early-Return verlassen.

Danach wird das Bild (also das X, oder der Kreis) vom jeweiligen Spieler gesetzt.

Zum Schluss wird geprüft, ob ein Spieler gewonnen hat und wenn ja, gefragt ob man noch ein Match spielen möchte.

Alternativ wird nach einem Unentschieden geschaut und zu guter Letzt die Runde ansonsten einfach an den nächsten Spieler abgegeben.

SetPlayerToken

Je nachdem welcher Spieler dran ist, wird eine weitere Hilfsmethode zum Setzen des jeweiligen Spieler–Bildes aufgerufen.

SetPlayerOneToken

Setzt das Bild des Spielers 1 in die Picturebox.

SetPlayerTwoToken

Anlog zur vorherigen Methode, nur für Spieler 2.

HasPlayerWon

Überprüft mit weiteren Hilfsmethoden, ob ein Spieler gewonnen hat.

DoPictureBoxesMatch

Sehr hilfreiche Methode, um jeweils die Pictureboxen zu überprüfen, ob Diese alle das gleiche Bild haben und bei dreien dementsprechend gewonnen wurde.

AskForRematch

Fragt den Nutzer nach einem „Rematch“ und startet das Spiel bei „Ja“ neu, oder schließt das Formular.

AskForDrawRematch

Fragt den Nutzer nach einem „Unentschieden-Rematch“ und verfährt analog der obigen Methode.

Restart

Startet ein neues Spiel, indem die Bilder zurückgesetzt werden und einen neuen zufälligen Start–Spieler wählt.

ResetImages

Setzt die Bilder zurück.

AllTokensPlaced

Funktion, Welche überprüft, ob alle Spiel-Tokens (alle Bilder) gesetzt wurden.

ChangePlayerTurn

Wechselt das „wer ist gerade dran“-Flag, updatet das Label, Welche den aktuellen Spieler darstellt und startet den Countdown neu.

UpdatePlayerTurnLabel

Setzt den Label-Text, Welcher den aktuellen Spieler anzeigt.

StartCountDown

Setzt das Countdown-Label und startet den Countdown-Timer.

frmTicTacToe_Load

Der „Form-Load“-Ereignishandler, Welcher das Spiel initial startet.

ChooseRandomStartingPlayer

Diese Sub wählt einen zufälligen Spieler, Welcher mit seinem Zug startet.

Dabei generieren wir eine neue zufällige Zahl und prüfen mit dem Modulus-Operator (Wert 2), ob Diese eine gerade Zahl ist.

Wenn die Zahl gerade ist, dann beginnt der Player 1, sonst Player 2.

Danach wird auch hier dargestellt welcher Player dran ist und der Countdown gestartet.

tmrCountDown_Tick

Der Tick-Ereignishandler des Timers, Welcher jede Sekunde nach Start tickt.

Solange der Timer noch nicht das Ende erreicht hat (größer als 0 ist) wird heruntergezählt und das Time-Label aktualisiert.

Wenn das Ende erreicht ist, dann wird der Timer gestoppt und der Spieler gewechselt inkl. Timer neugestartet.

UpdateTimeLabel

Setzt den aktuellen Zeit-Wert in das Time-Label und zeigt somit die verbleibende Zeit für die Runde.

frmTicTacToe_FormClosing

Soll den Timer sauber beenden, falls Dieser zur Zeit des „Form-Closing„-Events noch läuft.

btnBack_Click

Der Klick–Handler für den „Zurück-Button“, Welcher die Start-Form erneut anzeigt und die aktuelle Form schließt.

btnExit_Click

Beendet die Anwendung.

Kompletter Code – VB.NET Game

Public Class frmWelcome

    Private Sub btnStartGame_Click(sender As Object, e As EventArgs) Handles btnStartGame.Click
        Dim frmTicTacToe = New frmTicTacToe()
        frmTicTacToe.Show()
        Close()
    End Sub

    Private Sub btnExit_Click(sender As Object, e As EventArgs) Handles btnExit.Click
        Application.Exit()
    End Sub

End Class

Public Class frmTicTacToe

    Private Property Random As Random

    Private Property XImage As Bitmap

    Private Property CircleImage As Bitmap

    Public Property PlayerTurn As Boolean

    Public ReadOnly Property IsPlayerOnesTurn
        Get
            Return PlayerTurn
        End Get
    End Property

    Public ReadOnly Property IsPlayerTwosTurn
        Get
            Return Not PlayerTurn
        End Get
    End Property

    Sub New()
        InitializeComponent()
        Random = New Random()
        XImage = My.Resources.x
        CircleImage = My.Resources.circle
        InitializePictureBoxes()
    End Sub

    Private Sub InitializePictureBoxes()
        For i = 1 To 9
            Dim pb = CreatePictureBox()
            tlpGame.Controls.Add(pb)
        Next
    End Sub

    Private Function CreatePictureBox() As PictureBox
        Dim pb = New PictureBox()
        With pb
            .BackColor = Color.Transparent
            .Dock = DockStyle.Fill
            .Margin = New Padding(0)
            .BorderStyle = BorderStyle.FixedSingle
            AddHandler pb.Click, AddressOf PictureBox_Click
        End With
        Return pb
    End Function

    Private Sub PictureBox_Click(sender As Object, e As EventArgs)
        Dim pb = CType(sender, PictureBox)

        Dim tokenAlreadySet = pb.BackgroundImage IsNot Nothing
        If tokenAlreadySet Then
            Return
        End If

        SetPlayerToken(pb)

        If HasPlayerWon() Then
            AskForRematch()
        ElseIf AllTokensPlaced() Then
            AskForDrawRematch()
        Else
            ChangePlayerTurn()
        End If
    End Sub

    Private Sub SetPlayerToken(pb As PictureBox)
        If IsPlayerOnesTurn Then
            SetPlayerOneToken(pb)
        Else
            SetPlayerTwoToken(pb)
        End If
    End Sub

    Private Sub SetPlayerOneToken(pb As PictureBox)
        pb.BackgroundImage = XImage
    End Sub

    Private Sub SetPlayerTwoToken(pb As PictureBox)
        pb.BackgroundImage = CircleImage
    End Sub

    Private Function HasPlayerWon() As Boolean
        Dim horizontalMatch = CheckHorizontalMatch()
        If horizontalMatch Then
            Return True
        End If

        Dim verticalMatch = CheckVerticalMatch()
        If verticalMatch Then
            Return True
        End If

        Dim diagonalMatch = CheckDiagonalMatch()
        If diagonalMatch Then
            Return True
        End If

        Return False
    End Function

    Private Function CheckHorizontalMatch() As Boolean
        Return DoPictureBoxesMatch(1, 2, 3) OrElse
            DoPictureBoxesMatch(4, 5, 6) OrElse
            DoPictureBoxesMatch(7, 8, 9)
    End Function

    Private Function CheckVerticalMatch() As Boolean
        Return DoPictureBoxesMatch(1, 4, 7) OrElse
            DoPictureBoxesMatch(2, 5, 8) OrElse
            DoPictureBoxesMatch(3, 6, 9)
    End Function

    Private Function CheckDiagonalMatch() As Boolean
        Return DoPictureBoxesMatch(1, 5, 9) OrElse
            DoPictureBoxesMatch(7, 5, 3)
    End Function

    Private Function DoPictureBoxesMatch(ParamArray pictureBoxNumbers As Integer()) As Boolean
        Dim images = New List(Of PictureBox)
        For Each number In pictureBoxNumbers
            Dim pbIndex = number - 1
            Dim pb = CType(tlpGame.Controls(pbIndex), PictureBox)
            images.Add(pb)
        Next
        If IsPlayerOnesTurn Then
            Return images.All(Function(x) x.BackgroundImage Is XImage)
        Else
            Return images.All(Function(x) x.BackgroundImage Is CircleImage)
        End If
    End Function

    Private Sub AskForRematch()
        Dim playerNumber = IIf(IsPlayerOnesTurn, 1, 2)
        Dim msg = $"Player {playerNumber} won, do you want to restart?"
        Dim wantsToRestart = MessageBox.Show(msg, "Player won", MessageBoxButtons.YesNo, MessageBoxIcon.Question) = DialogResult.Yes
        If wantsToRestart Then
            Restart()
        Else
            Close()
        End If
    End Sub

    Private Sub AskForDrawRematch()
        Dim msg = $"It's a draw, do you want to restart?"
        Dim wantsToRestart = MessageBox.Show(msg, "Draw!", MessageBoxButtons.YesNo, MessageBoxIcon.Question) = DialogResult.Yes
        If wantsToRestart Then
            Restart()
        Else
            Close()
        End If
    End Sub

    Private Sub Restart()
        ResetImages()
        ChooseRandomStartingPlayer()
    End Sub

    Private Sub ResetImages()
        For Each pb In tlpGame.Controls.OfType(Of PictureBox)
            pb.BackgroundImage = Nothing
        Next
    End Sub

    Private Function AllTokensPlaced() As Boolean
        Dim countPlaced = 0
        For Each pb In tlpGame.Controls.OfType(Of PictureBox)
            Dim tokenSet = pb.BackgroundImage IsNot Nothing
            If tokenSet Then
                countPlaced += 1
            End If
        Next
        ' or with LINQ:
        ' Dim countPlaced = tlpGame.Controls.OfType(Of PictureBox).Where(Function(pb) pb.BackgroundImage IsNot Nothing)
        Return countPlaced = tlpGame.Controls.Count
    End Function

    Private Sub ChangePlayerTurn()
        PlayerTurn = Not PlayerTurn
        UpdatePlayerTurnLabel()
        StartCountDown()
    End Sub

    Private Sub UpdatePlayerTurnLabel()
        Dim playerNumber = 0
        If IsPlayerOnesTurn Then
            playerNumber = 1
        Else
            playerNumber = 2
        End If
        lblPlayerTurnValue.Text = $"Player {playerNumber}"
    End Sub

    Private Sub StartCountDown()
        lblTimeValue.Text = "10"
        tmrCountDown.Start()
    End Sub

    Private Sub frmTicTacToe_Load(sender As Object, e As EventArgs) Handles Me.Load
        ChooseRandomStartingPlayer()
    End Sub

    Private Sub ChooseRandomStartingPlayer()
        Dim rand = Random.Next(100)
        Dim isEven = rand Mod 2 = 0
        PlayerTurn = isEven
        UpdatePlayerTurnLabel()
        StartCountDown()
    End Sub

    Private Sub tmrCountDown_Tick(sender As Object, e As EventArgs) Handles tmrCountDown.Tick
        Dim time = Convert.ToByte(lblTimeValue.Text)
        If time > 0 Then
            time -= 1
            UpdateTimeLabel(time)
            Return
        End If
        tmrCountDown.Stop()
        ChangePlayerTurn()
        StartCountDown()
    End Sub

    Private Sub UpdateTimeLabel(time As Integer)
        lblTimeValue.Text = time.ToString()
    End Sub

    Private Sub frmTicTacToe_FormClosing(sender As Object, e As FormClosingEventArgs) Handles Me.FormClosing
        tmrCountDown.Stop()
    End Sub

    Private Sub btnBack_Click(sender As Object, e As EventArgs) Handles btnBack.Click
        Dim frmWelcome = New frmWelcome()
        frmWelcome.Show()
        Close()
    End Sub

    Private Sub btnExit_Click(sender As Object, e As EventArgs) Handles btnExit.Click
        Application.Exit()
    End Sub

End Class

Downloads

Der Beitrag VB.NET Game – Dein Eigenes TicTacToe Spiel erschien zuerst auf Robert Skibbe.

VB.NET Form öffnen

In VB.NET eine Form zu öffnen kann vor allem für Neulinge ziemlich doof laufen, jedoch dazu gleich mehr!

Eine zweite Form zu öffnen, oder allgemein eine versteckte Form wieder anzuzeigen gehört glaube ich heute zu den Standards in jeder Anwendung.

Wenn Du dir z. B. das konkrete Beispiel mit einer Adress–Eingabe anschauen möchtest, kannst Du auch in diesen Beitrag hier abtauchen, allerdings ist da schon viel drum herum, daher ist Dieser hier definitiv einfacher.

Wie man es nicht machen sollte!

Bevor wir jedoch in die Richtung „wie sollte man es machen“ gehen, schauen wir uns erst einmal an, wie man es eben nicht tun sollte! Viele Codes die Du online finden wirst, oder schon gefunden hast, werden ungefähr so aussehen – bitte nicht:

Public Class Form1

    Private Sub btnShowSecondFormWrong_Click(sender As Object, e As EventArgs) Handles btnShowSecondFormWrong.Click
        ' DONT DO THIS!
        Form2.Show()
    End Sub

End Class

Diese besonders für Einsteiger einfache Variante, prägt sich bei vielen .NET Entwicklern am Anfang ihrer Karriere Aufgrund der simplen Handhabung ein.

Später jedoch, stoßen Sie damit irgendwann berechtigterweise auf Kritik und eventuellen Problemen, denn rein logisch betrachtet: Wie willst Du eine Form anzeigen, die Du nie erstellt hast? In erster Linie ist es also eher ein Verständnis/Logik-Problem des Programmierers.

Lasse diesen Kritiker, bzw. Besserwisser dieses Mal mich sein 🤓, denn je eher Du dieses Code-Schnipsel vergisst, desto besser für Dich und Deine Nerven!

C# macht es richtig

Ein tolles Vorbild ist in diesem Beispiel C#, obwohl sich viele Funktionalitäten in den Sprachen ähneln, da Sie ja beide auf dem .NET Framework basieren, gibt es einige Unterschiede.

Unter anderem wird VB.NET deswegen auch so oft harsch kritisiert, aber gut das gehört hier jetzt nicht weiter hin..

In C# ist es zum Beispiel gar nicht erst möglich so einen Quatsch wie oben zu machen, denn der C#-Compiler fragt sich, welches Objekt er verwenden soll:

Warum so in VB.NET möglich?

Letztendlich könnte man sich fragen, warum das Ganze denn dann möglich ist, wenn es doch so unsauber ist.

Die Antwort liegt bei der Altlast von VB.NET, bekannt unter dem Kürzel „VB6“ und dem Namen „Visual Basic Classic„.

Eine derartige Herangehensweise funktioniert, weil VB.NET an dieser Stelle eine implizite Instanz der Klasse – wenn nötig – erstellt.

Wieso viele Entwickler es trotzdem tun 😒

Immer wieder habe ich in Vergangenheit beobachtet, wie einige meiner Schüler, aber auch Entwickler aus Unternehmen, mit denen ich kooperiert habe, es trotzdem weiterhin so gemacht haben.

Was bei Schülern, sprich am Anfang stehenden Entwicklern, meiner Meinung nach noch entschuldigt werden kann, sieht bei angestellten Entwicklern denke ich anders aus.

Besonders aus VB6 kommenden „Entwicklern“ schwören häufig nicht von dieser Methode ab, da Sie ja so einfach ist und „..es hat ja schließlich immer funktioniert„..

Code – VB.NET Form öffnen aber richtig!

Wer sich verständlicherweise nun fragt: „Nunja, wie öffne ich denn dann eine neue Form in VB.NET?“, oder „Wie zeige ich eine versteckte Form in VB.NET an?“, wird hier nun fündig.

Da es sich bei VB.NET um eine objektorientierte Sprache handelt, in der man natürlich meistens mit irgendwelchen Objekten – vorzugsweise Instanzen von Klassen – arbeitet, sieht es auch bei den Formen nicht anders aus.

Letztendlich muss man nur eine Instanz einer Form erstellen und anschließend deren Show-, bzw. ShowDialog-Methode aufrufen.

VB.NET Form öffnen

Wir nehmen also unser kleines Beispiel von vorhin und bauen es fix wie folgt um:

Public Class Form1

    Private Sub btnShowSecondForm_Click(sender As Object, e As EventArgs) Handles btnShowSecondForm.Click
        Dim instance = New Form2()
        instance.Show()
    End Sub

End Class

Achtung – Offene Formen

Beachte jedoch, dass bei mehreren Klicks, dementsprechend mehrere und somit unabhängige Instanzen der Form geöffnet werden.

Wenn Du Diese dann im zweiten Formular mit dem „Hide“-Button versteckst, bleiben Diese dennoch im Hintergrund offen – die Formen verbrauchen also Ressourcen im Hintergrund!

Um das Problem genauer darzustellen, habe ich Dir eine Debug.WriteLine-Zeile eingebaut, die dies anzeigt.

Ich denke dort liegt auch das hauptsächliche Problem von vielen Entwicklern, also das der jeweilige Entwickler noch nicht so weit ist und nicht mit dem ganzen Umfang der Materie klarkommt.

Damit meine ich die korrekte Arbeit mit verschiedenen Instanzen und das jede dieser Instanzen auch eigene Events auslösen kann, verwaltet werden möchte und auch eigene Gültigkeitsbereiche hat.

Man muss hier also darauf achten, dass Formen auch bei Bedarf wieder sauber geschlossen werden und nicht wie gezeigt im Hintergrund vor sich hin dümpeln.

Zweites Beispiel – Mit Zwischenspeicher

In diesem Teil zeige ich Dir, wie Du die Form nach Erstellung in einer formularweiten Variable/Eigenschaft cachen – also praktisch zwischenspeichern – kannst.

Das ermöglicht dir den späteren Zugriff auf die Form, z. B. wie im Sample durch weitere Buttons.

Public Class Form1

    Public WithEvents CachedInstance As Form2

    Private Sub btnShowFormAndCache_Click(sender As Object, e As EventArgs) Handles btnShowFormAndCache.Click
        CachedInstance = New Form2()
        CachedInstance.Show()
    End Sub

    Private Sub btnShowCachedForm_Click(sender As Object, e As EventArgs) Handles btnShowCachedForm.Click
        If CachedInstance IsNot Nothing Then
            CachedInstance.Show()
        End If
    End Sub

    Private Sub btnHideCachedForm_Click(sender As Object, e As EventArgs) Handles btnHideCachedForm.Click
        If CachedInstance IsNot Nothing Then
            CachedInstance.Hide()
        End If
    End Sub

    Private Sub btnCloseCachedForm_Click(sender As Object, e As EventArgs) Handles btnCloseCachedForm.Click
        If CachedInstance IsNot Nothing Then
            CachedInstance.Close()
        End If
    End Sub

End Class

Kompletter Code – VB.NET Form öffnen

Public Class Form1

    Private Sub btnShowSecondFormWrong_Click(sender As Object, e As EventArgs) Handles btnShowSecondFormWrong.Click
        Form2.Show()
    End Sub

    Private Sub btnShowSecondForm_Click(sender As Object, e As EventArgs) Handles btnShowSecondForm.Click
        Dim instance = New Form2()
        instance.Show()
    End Sub


    Public WithEvents CachedInstance As Form2

    Private Sub btnShowFormAndCache_Click(sender As Object, e As EventArgs) Handles btnShowFormAndCache.Click
        CachedInstance = New Form2()
        CachedInstance.Show()
    End Sub

    Private Sub btnShowCachedForm_Click(sender As Object, e As EventArgs) Handles btnShowCachedForm.Click
        If CachedInstance IsNot Nothing Then
            CachedInstance.Show()
        End If
    End Sub
    Private Sub btnHideCachedForm_Click(sender As Object, e As EventArgs) Handles btnHideCachedForm.Click
        If CachedInstance IsNot Nothing Then
            CachedInstance.Hide()
        End If
    End Sub

    Private Sub btnCloseCachedForm_Click(sender As Object, e As EventArgs) Handles btnCloseCachedForm.Click
        If CachedInstance IsNot Nothing Then
            CachedInstance.Close()
        End If
    End Sub

End Class

Public Class Form2

    Private Sub btnHide_Click(sender As Object, e As EventArgs) Handles btnHide.Click
        Hide()
        Debug.WriteLine(Application.OpenForms.Count, "Open")
    End Sub

    Private Sub btnClose_Click(sender As Object, e As EventArgs) Handles btnClose.Click
        Close()
    End Sub

End Class

Downloads

Der Beitrag VB.NET Form öffnen erschien zuerst auf Robert Skibbe.