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.

How to format a String in C#?

There are many situations where you need properly formatted strings. Imagine having an invoice, where the value would be like „14“. At first you could say: „Well, fourteen of what?“ and usually you would like it to have two decimal points. But even things like displaying a list of persons inside a WPF ListView will touch the string formatting topic.

The different approaches of formatting strings

When it comes to formatting strings in C#, there are 3 main approaches:

• concatenating strings manually
• using a function of the string class
• making use of the new string interpolation feature

Concatenation means joining multiple strings into one. I think the easiest example for this will be the one in the next section, which covers concatenating two name parts into a full name.

Formatting a String by manual concatenation

Look at the first method of formatting a string from above, we can see the basic concatenation. As already explained, this will form a brandnew string by concatenating multiple ones. Thankfully, you aren’t limitied to a specific count of strings here.

Let’s now take a look at the first little example of creating the mentioned full name string from name parts. We will create two basic variables for this in the first step, then we will combine them.

string firstName = "John";
string lastName = "Doe";

After creating those variables, we can now concatenate them into a complete new string. Keep in mind that C# strings are immutable and the common operators and functions will always create a new string.

string fullName = firstName + " " + lastName;

You can now say, that this was the actual most basic formatting of a string you could do, but what if it has to be a bit more complicated? What if you are in the actual need of giving a user the change to specify his own format style?

How to format a String in C# „the old way“?

The example from the section above was pretty common and there basically is no customization chance for the user. If someone uses your program and wants to like change the way this input data is ordered, he would have to swap the first and the last name. I mean sure, sometimes it isn’t necessary/wanted, but just sayin‘!

Now let’s look at a little helper function from the NET frameworks string class, which is simply called „Format“. As the name already suggests it helps with – you guessed it – formatting strings. We will now use this function to replicate the same full name string from above.

To be able to do this, we should take a look at the function parameters first. There are different overloads, but we will focus the one having a string as the first parameter and an object parameter array as the second parameter. The first parameter wants to have some kind of formatting „formula“ to do the actual formatting. The second one wants a list of objects to actually put them in the specified places. This is done by using curly braces containing the specific index of the corresponding object.

Dynamically formatting a String

We can pass any objects (currently being two strings) by separating each one through a comma. In the next example, I will pass the two name parts. Our first name variable will then have the index 0 and the last name will be at index 1.

string firstName = "John";
string lastName= "Doe";
string fullName = string.Format("{0} {1}", firstName, lastName);

Now you could actually let your user input some kind of format of his desire (if needed). In the next example I just switched out the order of names as mentioned above. This will create a new string with the contents: „Doe John“ instead of „John Doe“.

// take this from like a TextBox, etc.
string userWantedFormat = "{1} {0}";
string firstName = "John";
string lastName= "Doe";
string fullName = string.Format(format, firstName, lastName);

For sure you could also control those passed in names by adding and removing (even omitting) items to a list dynamically. Then you could also pass that list as a parameter, as the function is able to work with a list of any kind of objects as well.

How to do a C# String Format with interpolation?

I pretty much love the approach of formatting strings in C# the „modern“ way, called „string interpolation“. This way, you can basically put the strings you want at the position of your desire – directly! Let’s now construct the above example by using the string interpolation technique.

Next to specifying the exact position, it’s pretty much easier to actually know what to put where. In the above example we could only say like „put string with index 0 here or there“, but what if the actual index changed? Will you still remember the correct position?

Here’s the example from above, but now with string interpolation. For this, we need to put a dollar sign in front of the string itself, then we can just put in those variable names by surrounding them with curly braces. In my opinion, this is much easier and clearer than all previous examples.

Like this, we can also forget about those stupid opening and closing tags of strings. With the omittance of the no longer needed „+“-signs, it’s even easier and less verbose.

string firstName = "John";
string lastName = "Doe";
string fullName = $"{firstName} {lastName}";

How to format numbers and currencies?

After only working on the basic first and last name example, we will go a step further right now. I mean, formatting strings to strings isn’t that hard at all, but let’s see, how it would look with more complex types. The first more complex (but still easy) type is a usual number, just like the invoice sum from the top of this post (being 14).

Usually – at least for me in germany here – you display the total sum of an invoice with two decimals. Next to those decimal points, you also use for example the Euro sign. Let’s try to use the basic representation of that number 14 displayed in the image above.

To do so, we can use one of the shown methods mentioned above:

• manual formatting
• string class method called format
• interpolating a string

Formatting with „ToString“ object base function

First, I will provide an example of doing this „manually“, by using the typical „ToString“ function being inherited from the base class object. We will use the overload, where we can specify a format as string and the format will be „N2“. This stands for format a number „into“ a string, but with two decimal points.

decimal totalNet = 14.95M;
string displayValue = totalNet.ToString("N2");
// will result in displayValue being "14.95" in an en-US system setup

Using string.format or interpolation

The same results from above can be achieved with the same functionality from further above. I will use both other techniques here, as they are pretty much equal.

decimal totalNet = 14.95M;
// using string.Format
string displayValue = string.Format(totalNet, "{0:N2}");
// using string interpolation
string displayValue = $"{totalNet:N2}";

Specifying a particular culture / language / locale

As you can see in my comment, you will get some value for „displayValue“ like „14.95“. Keep in mind, that this will be dependent on your language setting. You could also tell him, to use like the german language setting with another parameter called „FormatProvider“.

// dont forget the import!
// using System.Globalization;
// use either this
CultureInfo deDeCulture = new CultureInfo("de-DE");
// or this
CultureInfo enUsCulture = new CultureInfo("en-US");
decimal totalNet = 14.95M;
// provided as second parameter here
string displayValue = totalNet.ToString("N2", deDeCulture);
// and look at the changed displayValue variable en-US = 14.95, de-DE = 14,95

To use string interpolation with a culture, you could create a „FormattableString“ and use this instead of a normal one.

decimal totalNet = 14.95M;
// this magically creates a FormattableString!
FormattableString displayValue = $"The total price is {totalNet:N2}.";
CultureInfo enUsCulture = new CultureInfo("en-US");
string message = displayValue.ToString(enUsCulture );
// en-US = 14.95, de-DE = 14,95

Setting the culture globally, not for each call

In the next step, you could make it even „easier“ – depending on the use case – by setting this „CultureInfo“ more globally. Like this, you would override the system specific default setting by just providing another one. Take a look at the following snippet:

// dont forget to import
// using System.Threading;
CultureInfo deDeCulture = new CultureInfo("de-DE");
CultureInfo enUsCulture = new CultureInfo("en-US");
// overriding the system default to a specific value
Thread.CurrentThread.CurrentCulture = enUsCulture;

All subsequent calls to formatting specific functions like „ToString“ will now use the „enUsCulture“ as default (overriding the system defaults).

Ouputting currency-formatted strings

After talking about the usual number style formatting, we can now try to display a simple currency aware number. This works pretty much the same by just changing one single letter. I changed „N2“ (which stands for number with 2 decimals) to „C2“ (which means currency with 2 decimals).

// take a look at the previous examples for string.format and manual things as well
FormattableString displayValue = $"The total price is {totalNet:C2}.";
CultureInfo enUsCulture = new CultureInfo("en-US");
string message = displayValue.ToString(enUsCulture );

How to format DateTimes or more complex objects?

In the next section we will take a closer look at formatting more comples objects instead of those simple numbers and stuff. I’m for example talking about the „DateTime“ and other (maybe) custom classes you made yourself.

What if you have this customer which can be a private or a business customer and you want to use a C# String Format to display „him“? Are you going to display his business name, or his private first and last name? How do interpolate a string using this information?

Formatting DateTimes

Let’s first do some examples formatting an instance of the C# DateTime class. I will stay at using the string interpolation, but for sure, you can use the other techniques from above as well. After displaying a simple date string, we will also go ahead with some month-ish and time-ish strings.

// using the current date and time for example
DateTime now = DateTime.Now;
// displaying a typical german date - 30.03.2023 for example
string displayValue = $"{now:dd.MM.yyyy}";
// displaying typical english date - care for escaping the backslashes, you could also
// omit the double backslashes and use the normal @ prefix like @$
string displayValue = $"{now:MM\\dd\\yyyy}";
// working with a time
string displayTimeValue = @$"{now:HH:mm}";

Formatting custom objects like a customer class instance

In this last section we will take a look at formatting our custom made customer class. For sure, this will be a pretty simple class with like only a few properties – for displaying purposes. We will create two „types“ of customers (which I would normally do otherwise, but now..): Business customers and private customers. The business customer will only have its company set, the private one will have a first and a last name.

public class Customer
{

  public string Company { get; set; }

  public string FirstName { get; set; }

  public string LastName { get; set; }

  public Customer(string company)
  {
    Company = company;
  }

  public Customer(string firstName, string lastName)
  {
    FirstName = firstName;
    LastName = lastName;
  }

}

We could then create a private and a business customer like this:

Customer privateCustomer = new Customer("John", "Doe");
Customer businessCustomer = new Customer("Doe Max Profit ltd.");

If you now try to format them like this, you will get some gibberish like „Customer: ProjectName.ClassName“. This is basically how objects without overriding of the „ToString“ function will look alike.

// will contain like Customer: ProjectName.Customer
string text = $"Customer: {privateCustomer}";

So as mentioned as above, we only need to override the „ToString“ function to make it easier for us. For sure, you could also just display some other properties/values. In this example, I will just prioritize the company name and if not provided, I will return the full name. If you need to iterate over multiple customers, see C# ForEach.

public class Customer
{

  // ...
  // the the other stuff from above
  // ...

  public override ToString()
  {
    if (string.IsNullOrEmpty(Company)) {
      return Company;
    }
    return $"{FirstName} {LastName}";
  }
}

Now take a look of the results of the following code lines:

Customer privateCustomer = new Customer("John", "Doe");
Customer businessCustomer = new Customer("Doe Max Profit ltd.");
// will contain Customer: John Doe
string text = $"Customer: {privateCustomer}";
// will contain Customer: Doe Max Profit ltd.
string text = $"Customer: {businessCustomer}";

As seen in the comments, we will now be able to see some different and better looking results.

FAQ

Wrapping up

C# offers three ways to format strings: manual concatenation, String.Format, and string interpolation. For new code, prefer interpolation as it is the most readable. Use CultureInfo when your application needs to support multiple locales. For another practical C# example, check out C# LINQ Sum.

Der Beitrag C# String Format – Interpolation, Numbers, Dates (2026) erschien zuerst auf Robert Skibbe.

C# MD5 hashing nowadays

Being in the need of creating a C# MD5 hash for one of my projects has been a while now. Due to one of my recent customer projects I got back to it and I noticed, that I don’t have a matching blog post. Well, so I just decided to create today’s blog post – enjoy 😀. As I don’t creating „half things“ I will also go through some basics and FYI: We won’t use any kind of external library here.

💡 No time for blabla? No problem! If you prefer quick code snippets on creating C# MD5 hashes, just go to the quick examples section.

Back to the basics – „data“?

When trying to understand hashes we have to first go back some steps to the basic knowledge of storing data in general. Right away, we could begin with something like a simple string as „computer“. For sure there could be other data types, but a string or even a simple number is the perfect fight for the start, I think.

How data is stored?

Everyone’s talking about those things called „big data“, „data analyst“ and whatsoever, but what actually is data? How is it being represented inside a modern day computer? In terms of a modern computer, data is actually stored as so called „bytes“. A single „byte“ is actually the the smallest addressable unit of memory inside a computers context.

A byte actually consists of different single so called „bits“, in total 8 of them. The are „connected“ and you can imagine it like in the following illustration:

So in the image you can see, that there are 8 single bits acting together as one byte. Each single bit can be in one of two states: It can either be 1 (on), or otherwise it’s 0 (off). Any bits state change, will also change the overall value which is being represented by the byte.

Some data examples

At this point, I will try to provide some basic examples to help forming the basic knowledge. Please keep in mind, that I can’t go into this topic too deep. Of course you can go ahead and skip this part, if you are already thinking: „Nah, that’s only for babies, I already know everything there“.

The first data example – the number 42

In our first data example, we will take a look at the simple and basic number 42. Let’s see, how the data structure called byte – and therefore the bits – will represent this number.

If you take a look at this binary / bitwise example from above, you can see, that there’s a mix of zeros and ones. Don’t think, that those bits are some kind of random, they follow a specific order and specific „values“ being on or off. In the case of our number 42, the binary representation would be „00101010“.

A basic & quick explanation

I will try to explain this basically like so: Each bit represents a single (and own) value itself, for example the outer right one being a 1. The next one – again, from the right side – is a 2 and then the chain continues. You could say: Start from right, being a 1 and double the value for each bit till you are on the left end.

We will talk more about this in just a few seconds, let’s now just focus on the „is on“, or „is off“ at first. So when calculating the final value of that byte, you only take those „bit values“ into account being on. In our example, this would sound like this:

• The bit on the outer right, being bit with value 1 is off, so just ignore it
• Going to the second bit from the right, it’s on -> take it’s value being 2
• Next, the bit with value 4, is off, ignore again
• And finally, the bit with value 32 is on -> again, take it!

Finally, we are having the following values (taking the „active“ ones): 2, 8 and the 32. If you sum this up, you will have our desired number called 42 🎉! Here’s another image making it – hopefully – even clearer:

How about a string – „MyPassword123“

So after exploring the easy „one simple number only“ example, we will now continue with a more complex string. Even though strings being more difficult on the first glimpse, they follow analog rules when being „stored“.

Right now, there would be the right place to start talking about something called character encodings. For now I will take a bit of a shortcut not going into those to deep, at this moment you should only take not of one thing: We are going to use the ASCI table. Next, let’s try to use the table for decoding our displayed number into a string representation.

Looking at the ASCII table and more specific at for example the letter „M“, you can see, that it has the code „077“. Just for fun right now, use your keyboard and hold down the „alt“ key. Type the just found code and release your „alt“ key again. Now you should notice an appearing „M“ letter 😎 – nice!

Looking at the M’s bitwise equivalent

Now we are going to look at how the letter „M“ is actually stored in its binary form. For this, we will check, how the number 77 would be displayed as binary number string.

Using the little rulebook / algorithm learned from above, we will repeat it for this number / binary representation. Again, start from the right side having the value 1 for the first bit, then double it 7 times going to the left. In the end, check which bits are actually active and sum their values:

• Bit 1 -> on = 1
• Bit 3 -> on = 4
• Bit 4 -> on = 8
• Bit 7 -> on = 64

After listing those up, just sum those numbers and voila, we have our number „77“. Now I will actually save you from watching me repeat this process for each letter inside our string. Here is the complete string being represented as binary format:

01001101 01111001 01010000 01100001 01110011 01110011 01110111 01101111 01110010 01100100 00110001 00110010 00110011

What actually is a hash?

After we now know (or knew before), how data is stored inside the computers memory, we will now go further. I think the most basic and easy explanation for a hash is as follows: „Take some value, put it into the hashing algorithm, get an output“. One important point is, that the same values being input, will result in the same output values.

Take at look at the following example hashes, before we continue:

• 0cc175b9c0f1b6a831c399e269772661
• 973d98ac221d7e433fd7c417aa41027a
• 7618ca3b69910d35e18dd998d4b2830b

Now I will show you same basic and important rules about hashing in general.

The source is unknown

The values from above seem to be a whole mess of nonsense, right? Actually, they aren’t, honestly you know at least two of those three values. This brings us to the second important point about hashes: You don’t know the origin / the source. A bit later, we will see, why this will be very important in some contexts.

The output length is fixed

Even though the first hash from above is only a small letter called „a“, it still seems pretty big. Looking at the second one – which was our password – it became a bit longer as well. The real interesting one is the last hash, where we actually computed a hash for a whole image file.

An MD5 is always 128 bits and therefore 32 hex digits long (means using the hexadecimal notation). The hex notation only needs 4 bits for each character, where you can easily calculate yourself: 128 / 4 = 32. Knowing this, you can store MD5 hashes in your database as char(64) field.

It only goes in one direction

The last important thing to note is, that hashes are irreversible, so you can hash, but can’t go back to source. Later, we will see why this could actually be a nice advantage instead of a problem. So now it’s time to step into the next sub-topic being „the why“.

Why computing hashes?

After digging into the basic things, you could now ask yourself: „Why should I sometimes compute hashes in the first place?“. Theres one important example where get in touch with it almost everytime.

Registration, signing in, etc.

When thinking about hashing, my mind basically automatically switches to the topic of application logins. I think everyday we are going through plenty of authenticatino processes, where some hashing algorithm is in play (at least behind the scenes).

Imagine visiting your well known app login screen, you enter your credentials just as usual like the username „robert“ and the password from above „MyPassword123“. When pressing the login button, it will mostly send a request to the server backend system. The code running on the server side will then try to find a corresponding user for the provided username. If no user could be found, then we will just get a typical matching error.

Time for hashes

After the steps above, the interesting part with hashes will happen next, so after an actual matching user could be found in the database. The system now hashes the provided (sent) password with the configured hashing algorithm. Then it will compare the just computed hash with the hash being fetched from the database – which is obviously stored there.

Now, go a step back and think about my argument saying: „Hashes can’t be reversed“, this is the time where this comes into play. Through the last years you will probably have heard about those typical news headlines like „200.000 user datasets have been stolen from blabla database leak“.

Taking the data protection considered things apart, there’s one more point being horrific here: „What the F – who has my password now 😭?“. Well, if done right – means with a proper hashing algorithm – nobody will have your password. Nobody will therefore be able to easily login with your leaked email and password in for example PayPal.

Conclusion

In my opinion, the core concept of using hashes is providing additional value in security based contexts. The three core attributes of a hash are basically: „It works in one way only“, „The output length is fixed“ and „the source is unknown“. This beautifully adds more security when storing userdata inside your database like a password or something a pin code, because if someone steals it, they won’t be able to use it.

Does that mean hashing is encryption? Be careful when using MD5 nowadays!

Oh lord, this is one of the basic misconceptions when talking with some unexperienced developers for sure. Many people still think, that hashing actually means encrypting something. Especially as a freelance developer and therefore seeing so many different developers and companies, I made some experiences in this direction. To quickly say it beforehand: Hashing is not encrypting & decrypting.

When taking a look at one basic argument you will quickly find out why, again, remember my argument: „Hashing only goes in one direction“. But if you now think about encryption, there is some input being encrypted and there is a possibility to legimately decode it back.

A dangerous problem especially with MD5 – collisions

If you have spend quite some years in the world of programming, you may already have heard of it: MD5 isn’t considered cryptographically secure anymore. Honestly I don’t know how long out of my head at the moment, but it has already been some years. Just a few days ago, I saw one of my tunesian customers actually still using the Message Digest Algorithm 5 (through freelancers work).

I personally think, that you can actually use MD5 in some cases, but please (for god’s sake), please avoid it considering security based contexts. Another problem next to collisions is MD5 being to fast which enables too easy guessing.

Adding more security using salts

Being around in the world of programming you might have already heard of a thing called a „salt“. If so, this would actually pretty good, because it’s one additional gotcha considering security aspects. Think about your hash being a nice food being cooked. Adding a yummy bit of salt you could actually improve the taste of your food (being the hash algorithm).

After hearing that metaphor from above, you can basically say that hashes are „something being added“ to the source input being hashed. One nice aspect is, that if two users choose the same password, you won’t be able to see it. Otherwise you could kinda guess by „Oh, those users have the same hash“.

Even though I pretty much love rainbows, there is one additional thing, where salted hashes can help against as well. I’m talking about the common hacking method called / using „rainbow tables“. A rainbow table is a premade table of hashed values, where you can try matching records. The future me will eventually go a bit deeper into that, for now that’s enough to know here.

Got the salt – and now?

When first learning about salts, I can guarantee you, that you are totally not alone with that question. If you have successfully generated your random salt, you will ask yourself: „Nice, but how am I supposed to let it come into play on the next login attempt?“. Let me tell you, that you can just store the salt alongside in the database, this way you can use it on login check.

What about file hashes?

Me – at the time of writing this post being 30 – I still enjoy playing games, on PC and as well and consoles. If you have a similar bias, then you will most likey came across some site advertising downloads of games, etc. Sometimes there is a hash being displayed on this download page – for the corresponding download.

When downloading files, there are some things that can go wrong or even revealing themselves as a security problem. Sure there can be less and more problematic things, but think of getting not the actual game client / rom you wanted? You basically enter your login details which then could be send to the malicious producer of this software – while you are still thinking: „Yes, I got the right game“.

Don’t trust, validate!

This basic rule went deep into many persons brains, when the bitcoin slowly settled into peoples memory. It is actually a great saying, which essentially explains, what these file hashes are all about. With those, I – as a manufacturer / developer can tell you the follwing. „This is the original and correct state of the software I’m providing to you“.

After downloading my software or game, you could create a hash to check the file yourself. This would make sure, that you actually got the right one. This ensures that no corruption has happended during the download due to like an instable connection. But most importantly this means: No sneaky hacker has given you a little trojan which he could use to spy on your actitivies and credentials with. This is especially essential when downloading your software through some sort of sharing network.

Modifying your favourite game

Another example could be like one of your favourite nostalgic games put into a ROM. Some developer might brought the game back to life by making a nice mod for it. To actually install that ROM, the developers patching program mostly needs the same starting point. Therefore a hash could express: „This is the exact version my patcher needs“.

Quick examples – C# MD5 hashing

So, if you have no time for more blabla, then just take a look at those quick examples on „how to create an MD5 hash in C#“. Finally I can stop talking and start coding for you, haha 🤓!

The older but still OK-working way

In the first step, we create an instance by the MD5 classes create factory method. Then we are getting the bytes of the actual text by calling GetBytes on our desired encoding. After that, we are computing the actual hash bytes and store them into the corresponding variable. Then, we create a basic StringBuilder to save up on resources building the final string. In the last step, we are adding the hex representation of each byte to the stringbuilder with the format being „x2“. This version should work somewhere up to .NET 4.8, something like that.

    public static string MD5(string clearText)
    {
        using var md5 = System.Security.Cryptography.MD5.Create();
        var bytes = System.Text.Encoding.UTF8.GetBytes(clearText);
        var hash = md5.ComputeHash(bytes);
        var sb = new System.Text.StringBuilder();
        foreach (var byt in hash)
            sb.Append(byt.ToString("x2"));
        return sb.ToString();
    }

The newer version

In this version we can actually use the factory method of the HashAlgorithm base class, dynamically creating our hash algorithm instance. Then we can also avoid using a stringbuilder, because the Convert class just has a method we can use now. Keep in mind that I’m expecting „algo“ not to be null, therefore the „!“.

    public static string MD5(string clearText)
    {
        var sb = new StringBuilder();
        var bytes = Encoding.UTF8.GetBytes(clearText);
        using var algo = HashAlgorithm.Create(nameof(MD5));
        var hash = algo!.ComputeHash(bytes);
        return Convert.ToHexString(hash);
    }

Hashing a whole file – the last example

In this last example I will show you, how you can create a C# MD5 hash from an actual file. Watch out, in this example I’m not using the „nameof“ expression, cause the name of the function changed.

    public static string MD5FileHash(string filePath)
    {
        var algo = HashAlgorithm.Create("MD5");
        using var filestream = new FileStream(filePath, FileMode.Open);
        // should be zero by default anyways..
        // filestream.Position = 0;
        var hashValue = algo.ComputeHash(filestream);
        var hash = BitConverter.ToString(hashValue).Replace("-", "");
        return hash;
    }

Related posts

• C# Bluetooth example – listing devices
• Creating a C# SHA256 hash
• Hacking a NET application

Der Beitrag C# MD5 hashing in 2024 erschien zuerst auf Robert Skibbe.

Creating a C# SHA256 hash

Creating a C# SHA256 hash as changed a little bit – pardon me for not knowing the exact timestamp though. At least this is the thing I’ve stumbled upon a few days ago, when I needed it in my customer project. So, in today’s post we will talk about the essential basics of hashing and how to create a SHA256 hash in the context the C# language. By the way – we won’t use any third party library here.

💡 No time for blabla? No problem! If you prefer quick code snippets on creating C# SHA256 hashes, just go to the quick examples section.

Some basics about „data“?

If we want to find out what hashes actually are, we first need to step back a moment, to see how data is stored. In the first example we could start with a simple string like „MyPassword123“ (no I won’t use Hello World 🤮). After seeing hundreds of bad passwords, I want to explicitely call out: „Don’t use such a bad password“ – just sayin‘.

Data basics

So when talking about „data“ in general – while being in a computational context –, we actually talk about something called „bytes“. In its singular form – a „byte“ – it’s the smallest addressable unit of memory inside a modern computer. Diving even deeper, a byte consists of 8 bits, that are basically „connected“ together. Take a look at the following illustration:

So as you can see in the image, there are 8 – more or less – independent bits, still acting together as one byte. Each one of these bits, can be in one of two states: Either on, or off. Depending on those on/off states, the byte changes it’s representing value. This is why it’s called binary – either, your computer works, or it doesn’t #clownoff 😉! Next, we are going to look at some concrete data examples.

Example data

Please understand, that I won’t go into this too deep, but I think some basic examples are required to at least have some basic knowledge. Of course you can skip this section, if this is baby stuff for you 😋! Let’s take a look at two examples now: One number, and one string.

A number – let’s say 42

Let’s now take a look at some basic number being represented by those bits inside the byte, for example „42“. After taking that sneak peek, I will explain it in more detail.

So as you can see, the binary representation (in form of a byte) of the number „42“ is basically „00101010“. As I’ve already mentioned, each one of those bytes can either be „on“, or „off“. This is represented by the corresponding numbers being „0“ for „off“ and „1“ for „on“.

With my (german biased) english wording skills, I would explain it like this:

Each one of the single digits represent a „value“ being doubled after each step. Important note: You start on the right side, with the value „1“. Then you basically look at each byte (again, from the right side) and remember the active values:

• The „1“ bit -> is off, so don’t take it into account = 0
• The „2“ bit -> it’s on, take its value = 2
• The „4“ bit is off, ignore..
• The „8“ bit is on, take it!

So, if we continue like this we will have the following active values at the end: 2, 8 and 32. Now guess what this makes up, if we sum it together – correct, 42 🎉!

A string being „MyPassword123“

After taking a look at this rather easy and basic „number only“ example, we will now go ahead and check out the mentioned string „MyPassword123“. Allthough strings being more complex, they are basically following the same rules. Being a Zelda fan since good old kiddie-times – therefore loving to open chests – I don’t like opening another one here.

I’m talking about a topic called character encodings – seriously, I will take a shortcute here. For now, just keep in mind, that we are using the basic ASCII table for „decoding“ our letters. Let’s now go ahead and start decoding our string beginning with the character „M“.

Taking a look at the ASCII table – mentioned and linked above – we can see, that the big „M“ has an ASCII value / code of „077“. You can even try typing that code manually by using your numpad on the left (if you have one). Hold the „alt“ key and type the code: „077“, after releasing „alt“ then, you should notice an appeared „M“ letter 😎.

What is M’s binary representation?

Now let’s find out how the letter „M“ is represented in a binary form – having the info it’s ASCII code is „077“. Take a look how the number 77 would be displayed in a bitwise manner:

Now we can just repeat the algorithm already explained a few steps above. Start from the right side, with value 1. Double it’s value 7 times – which get’s you to the final „128“ value. Then check whether the bit is „active“ and take its value into the sum:

• Bit 1 -> checked = 1
• Bit 3 -> checked = 4
• Bit 4 -> checked = 8
• Bit 7 -> checked = 64

Summing it up alltogether, we now have our target value, which is „77“. I will save your time repeating it for each and every other letter inside our target string 😁! If you still want to see the whole binary representation of our string, here it comes:

01001101 01111001 01010000 01100001 01110011 01110011 01110111 01101111 01110010 01100100 00110001 00110010 00110011

What is a hash in the first place?

After taking a look into the basics of storing data inside the computers memory, we can now go a bit further (pun intended). I think the most basic explanation goes like this: „You provide some value, apply some algorithm to it and get an output value“. One more thing to mention is: „The same input will result in the same output“.

Before we continue with blabla 😅, I would like to show you like 3 examples:

• ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb
• bc7b8851671f2fda237a53f5057a0376037b6d062e65f965c62aa1d047498759
• befc3e74171cfac5f713b41512ded54cee67aa10aec174659f99ac19fb2f2974

First important point – „unknown“ source

Pretty much nonsense, huh? But well, not really, actually you know at least two of those thing. Here you can already see one of the important points of hashing. Using hashes basically hides the origin, so you don’t really know the „source“ of the hash. Further down, we will explore why / when this could be really helpful.

Fixed output length – the second point

The first hash from above is – surprisingly – just a small letter called „a“, weird – right!? The second one is our password string we used as an example from above. Especially the third one is pretty interesting, it’s actually one of the image files I’ve used in this post.

A SHA256 hash is 256 bits long – always – and it is being represented using hexadecimal notation. As the hexadecimal notation is only in the need of 4 bits for each character, you can actually have 256 / 4 = 64 characters. Therefore you could for example store it with a char(64) field inside a typical mySQL database.

Third point – it’s a one-way train

The third and another important point is, that a hash is actually irreversible, once you go forwards, you can’t go back. It might sound, or like a disadvantage, but it can be a real benefit in some situations. We will dive deeper into the „where is it good“ or „why“ in a few seconds.

Why do I need to hash „things“?

Well, after seeing all these basics and stuff, you could ask yourself: „But why is hashing used at all?“. For sure this is a really good question. There’s one special use case, which comes into my mind pretty fast.

Users, Login and stuff

The first use case I got strictly paired with hashing in my mind is something what almost every app needs: A login / authentication of a user. We all used it hundreds of times a login screen, but how does it actually work in the background?

When a user confirms his entered credentials like „robert“ as username and „MyPassword123“, it gets send to the server side of our app. Then the server app will go ahead and try to pull the matching user record for the specified username. If it has not been able to find a matching username record, well then we usually get a corresponding error.

Hashing comes into play

The interesting part happens next, when the user could actually be found using the provided username. Then the controlling part will mostly try to hash the entered password with the configured hash algorithm. Having the hashed user password in the hand, it will compare the hashed password with the password from the database – which is stored as hash as well.

If you remember that one important point where I said that „hashes are irreversible“, then this is, where the actual power is here. I think everyone has heard of that typical „breaking IT news“, that someones database got stolen. There are similar news where the headlines are like „xy thousand user datasets“ has been leaked.

Now imagine what would happen if you could just read everyones password in clear text like: „Oh yeah, Robert’s password is like ‚MyPassword123′“. Someone could try to use this password in the same application or in other important apps like PayPal. I mean there are many persons using their email as login ident, so.. And with that databases getting leaked, you have them anyways – hacky-boy jackpot.

Conclusion

So the primary aspect of hashing has its roots – in my opinion – in the context of security. The 3 core aspects of hashes are: „Being one way only“, „Having a fixed length“ and most important „The source is unknown“. That enables storing and comparing passwords, pins, etc. in a secured matter making it less critical if they get leaked.

So hashing means encrypting – no?

Well this is one of the most common misconceptions, even in more advanced developer circles. I came across wordings like „yeah, let’s encrypt it with SHA256“ in my business context more often than you might think. You should remember one thing: Hashing isn’t encrypting & decrypting.

As I already mentioned above, hashing only goes in one direction: You input something, it does its magical mathematical work and in the hand you have your output. Encryption means something different, it indicates that you are able to encode something and decode it back again.

But what is the catch – talking about collisions

If you are already in the universe of programming for some time, you might have heard of some hashing algorithm called „MD5“. Just a few days ago, when I worked for a tunesian customer, the Message-Digest Algorithm 5 was actually being used. Considering the security context, let me tell you one thing: Don’t use it in a problematic context nowadays!

When I was talking about „hashes are irreversible“, then that was actually the – more or less – full truth. But there is one thing called „collisions“ which can occur, when using bad / outdated hashing algorithms. The Message-Digest Algorithm 5 is one of those you should therefore avoid.

Salts – The right seasoning?

You might have heard about a thing called „salt / salts“ in the context of hashing algorithms. Actually it is pretty good if so, because it’s an additional thing for more security. If you think of your hash algorithm being some kind of dinner being cooked, then a salt can add more flavour to your algo.

How does it theoretically work?

Salting is „something additional“ being added to the password before being stored into the database. This will ensure, that even if two users choose the same password, the hashed output will still be different. If some user gets hacked you can’t guess like „ah, this other user has the same hash, therefore he has the same password“.

Another nice security thing about salts is adding protection against the rainbow table hacking method. A rainbow table attack is basically a hacking attempt, where you have some kind of premade / precached table of hashed values. Maybe this is a topic for another post, I think this one is already long enough 😂.

But where does the salt go?

This is a question I (any many more guys) have asked myself when I first got in contact with salting hashes. I though like: „Well, if I randomly and uniquely generate that salt on like registration, how am I supposed to ever find it back?“. Adding to this: „And how am I then to ever be able to check the password on a login attempt?“.

The answer is pretty easy: You just store the salt alongside with the password inside the database.

I’ve seen file hashes as well?

As a passionate hobby-gamer (yes, even with 30 and will be with 80) I have seen those many times as well. Those little „hey, this file has a hash of xyz“ hints, mostly located at some download pages. And here its a security aspect as well, who would’ve thought that, huh!?

When downloading files, there are some things that can go wrong or even revealing themselves as a security problem. Sure there can be less and more problematic things, but think of getting not the actual game client / rom you wanted? You basically enter your login details which then could be send to the malicious producer of this software – while you are still thinking: „Yes, I got the right game“.

Don’t trust, validate!

So there is this nice basic rule which settled in many minds when the bitcoin first came into peoples memory: „Don’t trust, validate!“. This is actually one great thing, which essentially explains, what these file hashes are all about. The official vendor can tell you like „This is the original and correct state of the software I’m providing to you“.

After downloading the software you could create the hashed version of the file yourself making sure, that you actually got the right one. This means: No corruption has happended during download and everything should be working fine. And this also means: No sneaky hacker has given you a little trojan which he could use to spy on your actitivies and credentials with. This is especially essential when downloading your software through some sort of sharing network.

Patching your favourite game

Another example is for example when you have some old ROM for your favourite nostalgia game. There could be some developer, who made a nice romhack (extending / changing the original for more fun). He would most likely need the same origin / starting point of a software, being able to patch it exactly like he needs to.

Quick examples – C# SHA256 hashing

No time for blabla? Just take a look at the different quick examples listed below. Finally I can write some code for you to create some C# SHA256 hash 🤓!

The old, outdated way

In the outdated version (where the SHA256Managed class even get’s marked by Visual Studio) we have a basic StringBuilder. Then we create an instance of the hash algorithm with the factory method called „create“. Take care for me using the newer „using“-syntax in one line = without curly braces.

Next we are getting the UTF8 bytes of the „clearText“ string variable and passing them to the „ComputeHash“ function of our hash algorithm class instance. Then we are iterating the byte array called result formatting each one into its hex representation. At the end, we are finally returning the hashed string.

public static string SHA256Outdated(string clearText)
{
  var sb = new StringBuilder();
  using var hash = SHA256Managed.Create();
  var result = hash.ComputeHash(Encoding.UTF8.GetBytes(clearText));
  foreach (var b in result)
    sb.Append($"{b:x2}");
  return sb.ToString();
}

The new version

The newer version works similar to the above one, except that we are using the „create“ factory method of the „HashAlgorithm“ class. There we provide the name of the hash algorithm we want to use. I love using the „nameof“ expression, but feel free to just provide „SHA256“ as string. Next we are doing pretty much the same as above as well.

using System.Text;
using System.Security.Cryptography;

private static string SHA256(string clearText)
{
  var sb = new StringBuilder();
  var bytes = Encoding.UTF8.GetBytes(clearText);
  var algo = HashAlgorithm.Create(nameof(SHA256));
  var hash = algo!.ComputeHash(bytes);
  foreach (var byt in hash)
    sb.Append(byt.ToString("x2"));
  return sb.ToString();
}

Hashing a file

This is an example of hashing an actual file like we have talked about further above.

    public static string SHA256FileHash(string filePath)
    {
        var algo = HashAlgorithm.Create("SHA256");
        using var filestream = new FileStream(filePath, FileMode.Open);
        // should be zero by default anyways..
        // filestream.Position = 0;
        var hashValue = algo.ComputeHash(filestream);
        var hash = BitConverter.ToString(hashValue).Replace("-", "");
        return hash;
    }

++ .NET 5 Update – Static Algorithm Methods ++

So a user just commented like „this is wrong“, well okay, what a neat description / criticism.. I thought I should write an update, with my thought process about this. I’m pretty open for any based criticism and arguments, so go ahead, if you have other suggestions.

The back story of his argument could be: In the „code analysis“ – id „CA1850“ – there is written, that you should actually use the static methods of the corresponding hash algorithm, called „HashData„. As there’s written, those are only aliases to the static methods, so you basically can avoid instantiating an algorithm each time. But who says you need to?

In my opinion I want to be able to switch out different hash algorithms as easy as possible. Further, I would do this by just injecting the right algorithm instance by dependency injection – once. Like this, I can mantain a nice, loosely coupled infrastructure and I’m not over-creating instances.

Just my opinion: So, in the end, you can decide yourself, if you want to listen to the code analysis CA1850, or if you just want to like use DI and inject an actual instance of a hash algorithm. On the other hand, if „switching out“ isn’t necessary for you – like when you always need one specific algorithm, always – you can just go with the static methods.

Related posts

• C# Bluetooth example – Listing devices
• The For Each Loop in C# – Objective iteration

Der Beitrag C# SHA256 hashing in 2024 erschien zuerst auf Robert Skibbe.

VB.NET Formulare automatisch ausfüllen!

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

Wie es meistens ist..

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

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

Monkey Work – ney, Automatisierung – yay!

Dort sieht es dann entgegengesetzt jeglicher Automatisierung eher so aus:

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

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

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

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

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

An die Zukunft denken

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

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

Herangehensweise – VB NET Formular automatisch ausfüllen

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

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

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

Konkreter Ablauf

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

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

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

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

oder..

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

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

Code – VB NET Formular automatisch ausfüllen

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

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

Das Modul

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

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

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

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

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

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

Imports System.Runtime.CompilerServices

Module modExtensions

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

End Module

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

Das geht relativ einfach, also wie folgt:

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

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

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

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

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

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

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

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

Kompletter Code

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

Imports System.Runtime.CompilerServices

Module modExtensions

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

        For Each tb In textBoxes

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

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

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

End Module

using System;
using System.Windows.Forms;

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

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

Weiterführende Links

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

Downloads

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

VBS Replace

Du möchtest mit der VBS Replace Funktion Teile von Zeichenfolgen ersetzen und benötigst es z. B. für Platzhalter aus einem Email–Template?

Starte jetzt mit diesem Post durch und lerne wie man unter anderem dazu die VBS Replace Funktion verwenden kann.

Ggf. sind auch noch andere Beiträge von Interesse für Dich: VBScript If-Else, InStr, MsgBox.

Unverzichtbar

Falls Du nicht schon durch einen konkreten Grund selbst auf die Funktion gestoßen bist, bist Du bestimmt durch andere Suchvoränge zum Replace-Befehl gekommen.

Eventuell bist Du während deiner Recherche über Suchbegriffe, wie das Ersetzen von Platzhaltern, auf die VBS Replace Funktion gestoßen.

Mit großer Wahrscheinlichkeit hast Du auch schon Emails bekommen, wo Platzhalter nicht korrekt verarbeitet wurden.

Die Emails waren dann vermutlich mit kryptische Zeichen wie Diese hier versehen: „Hallo lieber {%firstName%}..“.

Allgemeine Erklärung

So kann z. B. eine dieser Emails aussehen, Welche man bei der erfolgreichen Registrierung auf einer Seite durch das System geschickt bekommt:

<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>{% SUBJECT %}</title>
</head>
<body>
  <div class="content">
    <h1>Thanks for joining {% PRODUCT_NAME %}</h1>
    <h2>Your right way of ...</h2>
    <p>
      Thanks for joining {% SALUTATION %} {% LAST_NAME %},
      click here to start {% APP_LINK %}
    </p>
  </div>
</body>
</html>

Dabei stellen die durch die „{%“, bzw. „%}“ eingeschlossenen Wörter wie „SUBJECT“ so etwas wie Variablen dar.

Final – also nach der Verarbeitung – könnte der Text, bzw. der HTML-Code dann wie folgt aussehen:

<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Your registration</title>
</head>
<body>
  <div class="content">
    <h1>Thanks for joining RobbelRoot.de</h1>
    <h2>Your right way of ...</h2>
    <p>
      Thanks for joining Mr. Skibbe,
      click here to start https://robbelroot.de
    </p>
  </div>
</body>
</html>

Dort sehen wir dann die eigentlichen Daten, Welche sich hinter den Platzhaltern versteckt haben.

Vielleicht wird nun ein wenig verständlicher, warum, bzw. wann solche Platzhalter übrig bleiben.

Neben Email-Templates werden ähnliche Dinge auch in vielen Bekannten „Sprachen“ wie z. B. VueJS verwendet.

Dies macht man z. B., damit der Parser der Sprache anschließend weiß, was er – vor allem nach eventueller Arbeit – wo hin setzen muss.

Im Endeffekt sieht dies fast gleich zu oben aus, mit dem einen Unterschied, dass die verarbeitenden Werkzeuge damit anders umgehen.

Hier kannst Du so ein kleines Vue Code-Schnipselchen sehen:

          <div class="col-3">
            <div class="column">
              <div class="text-subtitle2 text-center">
                {{ $t("statistics.yearlyGoalSubtitle") }}
              </div>
              <div class="text-subtitle1 text-center">
                {{ yearlyProfit.toFixed(2) + " / " + yearlyGoal }}
              </div>
            </div>
          </div>

In dem Vue-Beispiel passiert allerdings wie schon erwähnt ein wenig mehr, als die bloße Ersetzung von „A“ durch „B“.

Neben dem Funktions-Aufruf findet hier auch noch die Verkettung eines Strings, also einer Zeichenkette statt.

Ich denke allerdings, dass dies zum aktuellen Zeitpunkt für die Erklärung ausreicht und den ein oder anderen sonst verwirren könnte.

VBS Replace Funktion

Ehe wir mit fiktiven Beispielen starten, schauen wir uns die Details der Funktion selbst an:

Parameter

string

Dieser Parameter gibt den String an, worin gesucht werden soll.

find

Hiermit geben wir den String an, nach Welchem wir letztendlich suchen.

replacewith

Dieser String bestimmt, wodurch der gefundene String ersetzt werden soll.

start [optional]

Definiert die Position ab wo das Ersetzen beginnt.

Achtung: Entfernt alle vorherigen Zeichenfolgen.

count [optional]

Standardmäßig auf -1 werden alle Vorkommnisse ersetzt, allerdings kann man durch diesen Parameter auch eine Art Begrenzungsmöglichkeit setzen.

compare [optional]

Konfiguriert die Vergleichs-Methode, wo wir 2 Möglichkeiten haben: vbBinaryCompare, vbTextCompare.

Die erste Option verwendet den binären Vergleich, wobei die Strings im Vergleich eine exakte Übereinstimmung haben müssen.

Die zweite Option gibt an, dass der Vergleich eine groß– und kleinschreibungs-unabhängige Methode an.

Code – VBS Replace

In diesem Abschnitt kannst Du nun ein oder mehrere Beispiele zur Funktion sehen:

Einfaches Beispiel

Im ersten Beispiel deklariere ich die „msg„-Variable, mit anschließendem Wert „This is a beautiful day!“.

Im nächsten Schritt ersetze ich das „beautiful“ durch „perfect“ und es kommt diese Nachricht zu Stande:

Dim msg
msg = "This is a beautiful day!"
msg = Replace(msg, "beautiful", "perfect")
MsgBox(msg)

Der Beitrag VBS Replace erschien zuerst auf Robert Skibbe.

VBS InStr

Du willst mit der VBS InStr Funktion überprüfen, ob ein String sich innerhalb eines Anderen befindet?

Dann freut es mich, Dir in diesem Beitrag die passende InStr-Funktion vorzustellen!

Eventuell hast Du zu einem späteren Zeitpunkt auch Interesse an einem der folgenden Beiträge: VBScript Array, MsgBox.

Hintergrund – VBS InStr

Zu gut kennt man es als Softwareentwickler, überprüfen zu müssen, ob ein String ein Teil eines anderen Strings ist.

Je nach Aufgabenstellung ist es auch von Bedeutung, an welcher exakten Position dieser andere String ist, bzw. ab wo Er startet.

Eine vergleichbare Funktion finden wir im .NET-Umfeld, die Contains-Funktion, Welche uns leider in VBScript nicht zur Verfügung steht.

Mach dir jedoch keine Sorgen, denn auch in VBScript haben wir die Möglichkeit eine ähnliche Methode zu verwenden.

Die Nadel im Heuhaufen – String durchsuchen

Die Möglichkeit die uns VBS (Visual Basic Script) hier bietet, ist die InStr Funktion.

„InStr“ ermittelt für uns in einem angegebenen String die Position eines Such-Strings.

Wenn der Such-String nicht innerhalb des Ziel-Strings gefunden wird, wird von der Funktion eine 0 zurückgegeben.

Wir haben sogar die Möglichkeit den Modus für den Vergleich zu bestimmen, wozu wir sofort kommen werden.

Die InStr-Funktion aus VBS

Schauen wir uns nun die Signatur der InStr-Funktion an:

Parameter

[Optional] start [Integer]

Der erste Parameter der Funktion gibt die Start-Position der Suche an.

Wenn die Start-Position ausgelassen wird, beginnt die Suche automatisch am Anfang.

string1 [String]

Hierbei handelt es sich um den zu durchsuchenden String.

string2 [String]

Dieser String gibt an, wonach im ersten String gesucht werden soll.

[Optional] compare [Integer]

Hiermit legen wir die Art des Vergleichs aus folgender Tabelle fest:

Falls man diese Option auslässt, wird ein binärer Vergleich genutzt.

Die beiden für uns bedeutsamen Arten sind Diese: vbBinaryCompare und vbTextCompare.

Mit der Option „vbBinaryCompare“ wird binär verglichen, dass heißt, dass die Zeichenfolgen eine exakte Übereinstimmung haben müssen.

Die vbTextCompare-Option gibt bereits bei einer textlichen Übereinstimmung – ohne Groß– und Kleinschreibung – positives Feedback.

Code – VBS InStr

Hier möchte ich Dir ein paar Beispielcodes zeigen:

Dim str
str = "Hello my world"
Dim search
search = "my"
Dim res
res = InStr(1, str, search)
MsgBox(res)

In diesem Beispiel wird der String als „str“ deklariert und danach mit dem Wert „Hello my world“ befüllt.

Anschließend deklarieren wir einen zusätzlichen String namens „search“, wonach wir suchen werden, Ihm weisen wir den Wert „my“ zu.

Im vorletzten Schritt deklarieren wir die Variable namens „res“, Welche den Rückgabewert unseres „InStr“-Aufrufs zwischenspeichern wird.

In diesem Beispiel bekommen wir den Rückgabewert 7, da das Wort „my“ ab der 7. Position startet.

Der Beitrag VBS InStr erschien zuerst auf Robert Skibbe.

VB String Array

Du bist bei deiner „VB String Array„-Recherche auf meine Seite gestoßen und möchtest wissen, wie man ein String–Array in Visual Basic erstellen kann?

Eventuell weißt Du auch bereits, wie man ein String–Array erstellt, Dir fehlt aber vielleicht der Feinschliff, oder Du hättest gerne mehr Tipps?

Vielleicht interessierst Du Dich noch für die folgenden Beiträge: Arrays allgemein.

Wiederholung Arrays

Wie Du ggf. schon in meinem anderen Beitrag, oder durch Dein Vorwissen weißt, speichern Arrays mehrere Daten auf einmal.

Vergleichbar ist das Array mit einer Art Liste, Welche gezählt, wie eine Variable veränderbar und auch iterierbar ist.

Schon in meinem anderen Beitrag habe ich auch darauf hingewiesen, dass es einige Kniffe wie z. B. in der Deklarationsweise gibt.

Mögliche Szenarien

Wenn man an ein String-Array denkt, bzw. die Notwendigkeit dazu hat, verbindet man das eventuell mit folgenden Szenarien:

• Man könnte z. B. Rechnungsnummern (Welche durchaus auch Buchstaben enthalten können) durchlaufen wollen
• Es ist die Notwendigkeit einer Auflistung von Namen vorhanden
• Ein String soll zum Beispiel in seine Bestandteile zerlegt und in einem Array gespeichert werden
• uvm.

Auflistung von Namen – VB String Array

Schauen wir uns für das Beispiel mal ein konkretes Szenario an, dazu speichern wir verschiedene Vornamen in ein String-Array.

Zuerst sehen wir uns dazu die Deklaration, bzw. die Initialisierung eines String-Arrays in Visual Basic an.

Anschließend gehen wir weitere Operationen am Array wie das Hinzufügen weiterer Vornamen an.

Deklaration eines String-Arrays

Wie gleich folgend, könnte die Deklaration eines String-Arrays aussehen.

Das bedeutet, dass das Array nicht bereits von vornherein seine Speicherkapazität festgelegt bekommt.

Übersetzen könnte man die Zeile als: „Lege die Variable firstNames als String-Array fest.“

Dim firstNames As String()

Initialisierung eines String-Arrays

Nun folgt die Initialisierung eines String-Arrays.

Das bedeutet, wir deklarieren ebenfalls die Variable „firstNames“ und weisen Ihr initial Werte zu.

Der höchste Index des Arrays ist nun somit der Eintrag namens „Cathrine“ mit dem Wert 2.

Dim firstNames As String() = {"John", "Max", "Cathrine"}

Hinzufügen eines Elements in VB String Array

Nachdem das Array vorher entweder mit dem einem, oder dem Anderen Weg definiert wurde, kommt man vermutlich auch an den Punkt, weitere Elemente hinzufügen zu wollen.

Dafür müssen wir dem Array, was andernfalls einen Index-Fehler werfen würde sagen, dass dessen Kapazität mit Hilfe der ReDim-Anweisung neu definiert wird.

Zusätzlich verwenden wir das „Preserve„-Schlüsselwort, um die vorherigen Einträge zu behalten.

ReDim Preserve firstNames(3)

Beachte hierbei, dass die Zahl in der Klammer – also die Dimension / Kapazität – auch hier in der Form eines Indexes (also beginnend bei 0) angegeben werden muss.

Danach können wir einen, oder mehrere weitere Namen in das String-Array hinzufügen:

firstNames(3) = "Michael"

Entfernen des letzten Elements

Um bei diesem String-Array z. B. den letzten Eintrag wieder entfernen zu können, können wir ebenfalls die „ReDim & Preserve“-Kombination verwenden.

Hier zeige ich kurz eine Variante, wo ich die Zahl praktisch fest in den Code schreibe, nicht so prickelnd, aber funktionierend.

ReDim Preserve firstNames(2)

Etwas besser wäre es natürlich, wenn das Ganze dynamisch funktionieren würde, dazu können wir die Obergrenze einfach ausmachen und 1 davon abziehen.

ReDim Preserve firstNames(UBound(firstNames) - 1)

Beachte hier, dass Du ggf. mit einer If-Abfrage abfangen musst, dass nicht nachher -1 bei der Berechnung rumkommt.

Entfernen des ersten Elements

Hier noch ein kleines Beispiel, wie man statt dem letzten, das erste Element des String-Arrays entfernen kann.

For i = 1 To UBound(firstNames)
  firstNames(i - 1) = firstNames(i)
Next i
ReDim Preserve firstNames(UBound(firstNames) - 1)

Zuerst iterieren wir dafür beginnend bei 1 zum „Upper-Bound„, also der oberen „Index-Grenze“ des Arrays.

In jedem Durchlauf der For-Schleife setzen wir an die jeweilige Index-Position „i-1“, den Wert der hinter des aktuellen i-Indexes steckt.

Anschließend korrigieren wir die Kapazität des Arrays durch die bekannte ReDim-Preserve Variante mit der UBound–Funktion.

Der Beitrag VB String Array erschien zuerst auf Robert Skibbe.

VB.NET Anführungszeichen in String

Du möchtest in VB.NET Anführungszeichen in einem String darstellen, bzw. haben?

Das ist kein Problem, lerne in diesem einfachen kleinen Beitrag, wie Du Anführungszeichen innerhalb eines Visual Basic .NET Strings darstellen kannst.

Vielleicht interessierst Du Dich auch noch für folgende Beiträge: Erstes Zeichen aus String entfernen, letztes Zeichen aus String entfernen oder String zerlegen.

Beispiel-Dialog

Vielleicht kommt Dir ein ähnlicher Dialog (MessageBox) wie Dieser hier bekannt vor:

Hier wurde z. B. nach einem Template namens „Default“ gesucht, Welches dann aber nicht gefunden wurde.

Wenn man statt des obigen Textes beispielsweise so etwas demonstriert bekommen würde, würde man sich sicher wundern:

Das dürfte dann daran liegen, dass man meint, das „Default“ Wort würde zum Satz selbst gehören und es sieht – nicht vorgehoben – irgendwie komisch aus.

Erster Versuch – VB.NET Anführungszeichen in String

Sobald Du also in eine ähnliche Situation gerätst – und ich denke an diesem Punkt bist Du gerade, da Du meinen Beitrag gefunden hast – könntest Du es wie folgt probiert haben:

Allerdings würdest Du auf diese Weise einen „end of-Anweisung erwartet“-Fehler bekommen.

Lass Dich hier durch das verwendete Dollar-Zeichen am Anfang des Strings und den geschweiften Klammern nicht verunsichern.

Diese „Technik“ nennt sich Zeichenfolgeninterpolation und ist seit Visual Basic .NET 14 verfügbar.

Seitdem nutze ich Diese ausgiebig und sehr gerne, da die Interpolation viel vereinfacht und verkürzt.

Code-Frickeleien aus dem Netz

Wie so oft beim Coding, findet man im Netz viele Code–Frickeleien wie z. B. Diese hier:

Dim exampleMessage = $"Could not find template {Chr(34)}{templateName}{Chr(34)} inside the folder"

You shall not parse, bzw. leider doch..

Man versucht hier durch die „Chr“-Funktion, das dem Char-Code jeweilig zugrunde liegende Zeichen zu bekommen, was bei der Zahl 34 das Anführungszeichen wäre.

Genau da finde ich fängt die Misere schon an, denn wer weiß nach einem vergangenen halben Jahr bitte noch, was die Zahl 34 repräsentieren sollte.

Auch wenn man jetzt die Zahl 34 durch eine passende Konstante ersetzen würde, wäre es suboptimal.

Public Const QUOTATION_MARK_CHAR_CODE = 34

Die bessere Variante

Ich persönlich bevorzuge normalerweise sprachunabhängige Hilfsmittel, daher würde ich definitiv auf die „Chr“-Funktion verzichten und einen anderen Weg suchen.

Die „Chr“-Funktion befindet sich im Microsoft.VisualBasic-Namespace und benötigt einen Verweis auf die Microsoft.VisualBasic.Core.dll

In diesem konkreten Fall benutzen wir für die finale Lösung einfach einen Escape-Character für die Anführungszeichen im String.

Ein Escape-Character

Bei einem Anführungszeichen in einem String benötigen wir dafür einfach ein weiteres Mal ein Anführungszeichen.

Das mag zwar verwirrend klingen, aber schau Dir diese Code-Zeile hier einfach mal an:

Dim message = ""This" stands between quotation marks"

In dieser Code-Zeile steht das Wort „This“ (wie auch hier) zwischen Anführungszeichen.

Kompletter Code – VB.NET Anführungszeichen in String

Public Class Form1

    Private Sub btnShowQuotationMarkInString_Click(sender As Object, e As EventArgs) Handles btnShowQuotationMarkInString.Click
        Dim templateName = tbTemplateName.Text.Trim()
        If String.IsNullOrEmpty(templateName) Then
            MessageBox.Show("Please enter a template name", "Template search", MessageBoxButtons.OK, MessageBoxIcon.Warning)
            Return
        End If

        Dim exampleMessage = $"Could not find template ""{templateName}"" inside the folder"

        ' or without string interpolation
        ' Dim exampleMessage = $"Could not find template """ & templateName & """ inside the folder"

        ' DONT
        ' Dim exampleMessage = $"Could not find template {Chr(34)}{templateName}{Chr(34)} inside the folder"

        MessageBox.Show(exampleMessage, "Template not found", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End Sub

End Class

Downloads

Der Beitrag VB.NET Anführungszeichen in String erschien zuerst auf Robert Skibbe.

Willst du stattdessen eine Textdatei einlesen? → VB.NET Textdatei einlesen.

Code – VB.NET Textdatei schreiben

Gestalte Dir für den folgenden Schritt am besten eine ähnliche Oberfläche wie die hier drunter und im Anschluss legen wir mit dem Code los:

Datei schreiben

Erforderliche Klassen und Methoden

Die Möglichkeit zur Erstellung, bzw. Schreiben, Lesen und anderen dateibezogene Operationen finden wir in der File-Klasse. Wenn man in der .NET Framework Dokumentation nach unserem benötigten Begriff „write“ sucht, findet man folgende aktuell wichtige Methoden:

WriteAllText(filepath, contents)

Diese Methode schreibt die übergebenen Zeichen in eine Textdatei in den angegebenen Dateipfad. Wenn die Datei nicht schon existiert, wird sie erstellt und andernfalls überschrieben.

WriteAllText(filepath, contents, encoding)

Hier passiert alles analog zur Methode oben, allerdings wird in diesem Fall das Encoding ausdrücklich angegeben.

WriteAllTextAsync(filepath, contents, cancellationToken)

Diese Methode ist noch relativ neu und steht erst in eurem Projekt ab dem .NET 5 Framework zur Verfügung. Besonders bei großen, bzw. größeren Dateien zeigt diese Methode ihre Vorteile durch den asynchronen Dateizugriff.

Los geht’s

Gehe nun z. B. über den Form-Designer und einem Doppelklick auf den Button in den Ereignishandler für das Button Klick-Ereignis.

Die Datei können wir dann wie folgt in unserem Handler erstellen, bzw. schreiben:

    Private Sub btnWriteFile_Click(sender As Object, e As EventArgs) Handles btnWriteFile.Click
        Dim filepath = tbFilepath.Text.Trim()
        Dim content = tbContent.Text

        WriteFileSync(filepath, content)
        ' WriteFileWithEncodingSync(filepath, content)
        ' WriteFileAsync(filepath, content)
    End Sub

Im ersten Schritt hole ich mir den Dateipfad für die geplante Datei und entferne eventuelle Leerzeichen am Anfang und Ende. Den Inhalt der zu erstellenden Datei legen wir in die Variable „content“, der dem Text der „tbContent“-Textbox entspringt. Im letzten Schritt beginne ich dann mit dem Schreiben der Textdatei, dazu habe ich verschiedene weitere Methoden angelegt.

WriteFileSync(filepath, content)

Hier findet die wohl simpelste Variante statt, Text in eine Textdatei zu schreiben. Wir führen die „WriteAllText„-Methode der File-Klasse mit passenden Parameter wie den Dateipfad und den zu schreibenden Zeichen, sprich dem Inhalt aus. Den Schreibvorgang selbst habe ich mit einem „Try Catch“-Block zum Abfangen globaler Fehler verziert.

WriteFileWithEncodingSync(filepath, content)

Neben unserer Angabe eines expliziten Encodings passiert hier nichts anderes als im Beispiel hier drüber.

WriteFileAsync(filepath, content)

Dies ist die oben bereits angesprochene neue Variante, eine Datei zu schreiben, ansonsten identisch mit der ersten Methode „WriteFileSync“.

Anwendungsbeispiele

Ein praktisches Anwendungsbeispiel: das Speichern und Laden von Konfigurationsdateien im .ini-Format.

Konfigurationsdateien speichern/laden

Ini-Dateien (.ini) sind ein einfaches Format zum Speichern von Schlüssel-Wert-Paaren und eignen sich gut als leichtgewichtige Konfiguration für Desktop-Anwendungen.

IniFile-Klasse

Im ersten Schritt erstellen wir uns eine sehr einfache und rudimentäre IniFile-Klasse. Diese dient der Veranschaulichung, wie man im Ini-Format eine Textdatei schreibt und wieder ausliest. Neben dem Dateinamen, dem Verzeichnis und dem daraus resultierenden Dateipfad besitzt das Ini-File auch einen Namen.

Für Verbesserungen würde mir unter anderem die Verwendung verschiedener Encodings und Serializer einfallen.

Imports System.IO

Public Class IniFile

    ''' <summary>
    ''' Gets or Sets the path to the directory, containing the file
    ''' </summary>
    Public Property Directory As String

    ''' <summary>
    ''' Gets or Sets the filename of the file
    ''' </summary>
    Public Property FileName As String

    ''' <summary>
    ''' Returns the complete path to the ini file
    ''' </summary>
    Public ReadOnly Property FilePath As String
        Get
            Return Path.Combine(Directory, FileName)
        End Get
    End Property

    Public Property Sections As List(Of IniFileSection)

    Sub New()
        Sections = New List(Of IniFileSection)
    End Sub

    Public Async Function Save() As Task
        Dim contents = ToIniFileString()
        Await File.WriteAllTextAsync(FilePath, contents)
    End Function

    Public Shared Async Function Load(filePath As String) As Task(Of IniFile)
        Dim fileParts = filePath.Split("\")
        Dim iniFile = New IniFile()
        iniFile.Directory = String.Join("\", fileParts.Take(fileParts.Length - 1))
        iniFile.FileName = fileParts.Last()
        Dim contents = Await File.ReadAllTextAsync(filePath)
        Dim nonEmptyLines = contents.Split(Environment.NewLine).Where(Function(x) Not String.IsNullOrWhiteSpace(x))

        ' = nothing is a worarkound for "could be nothing" warning - #irony
        Dim currentSection As IniFileSection = Nothing
        For Each line In nonEmptyLines
            Dim isNewSection = line.StartsWith("[") AndAlso line.EndsWith("]")
            If isNewSection Then
                Dim sectionName = line.Replace("[", "]").Replace("]", "")
                currentSection = New IniFileSection(sectionName)
                iniFile.Sections.Add(currentSection)
                Continue For
            End If

            Dim isNewEntry = line.Contains("=")
            If isNewEntry Then
                Dim entryParts = line.Split("=")
                Dim key = entryParts(0)
                Dim value = entryParts(1)
                Dim entry = New IniFileSectionEntry(key, value)
                currentSection.Entries.Add(entry)
                Continue For
            End If
        Next
        Return iniFile
    End Function

    Public Function ToIniFileString() As String
        Dim sectionStrings = New List(Of String)
        For Each section In Sections
            sectionStrings.Add(section.ToIniFileString())
        Next
        Return String.Join(Environment.NewLine, sectionStrings)
    End Function

    Public Overrides Function ToString() As String
        Return $"IniFile: {FilePath}"
    End Function

End Class

IniFileSection-Klasse

Als nächstes kommt die IniFileSection-Klasse, die neben dem Namen der Sektion auch dessen Einträge beinhaltet.

Die gesamten Daten können wir dann mit Hilfe der kleinen Helper-Methode namens „ToIniFileString“ bekommen.

Public Class IniFileSection

    Public Property Name As String

    Public Property Entries As List(Of IniFileSectionEntry)

    Sub New(name As String)
        Me.Name = name
        Entries = New List(Of IniFileSectionEntry)
    End Sub

    Public Function ToIniFileString() As String
        Dim str = $"[{Name}]"
        For Each entry In Entries
            str &= $"{Environment.NewLine}{entry.ToIniFileString()}"
        Next
        Return str
    End Function

    Public Overrides Function ToString() As String
        Return $"IniFileSection: {Name}"
    End Function

End Class

IniFileSectionEntry-Klasse

Zum Schluss kommt die IniFileSectionEntry-Klasse, die den Schlüssel und den dahinter stehenden Wert beinhaltet. Sie hat die gleichnamige Helper-Funktion, um den Eintrag ini-konform umzuwandeln.

Public Class IniFileSectionEntry

    Public Property Key As String

    Public Property Value As String

    Sub New()
        Key = ""
        Value = ""
    End Sub

    Sub New(key As String, value As String)
        Me.Key = key
        Me.Value = value
    End Sub

    Public Function ToIniFileString() As String
        Return $"{Key}={Value}"
    End Function

    Public Overrides Function ToString() As String
        Return $"IniFileSectionEntry: {Key}={Value}"
    End Function

End Class

Verwendungsbeispiel in einer Konsolenanwendung

Zu guter Letzt kommt das Modul für die Konsole, worin wir 1-2 Beispiel-Aufrufe durchführen. Lade Dir bei Bedarf eines des Beispielprojekte herunter, dann kannst Du Dir das Ganze im Detail ansehen.

Module Program

    Sub Main(args As String())
        Console.Title = "TextFileCreateIniFile"
        DoExampleReadWrite()
    End Sub

    Public Async Sub DoExampleReadWrite()
        ' A
        ' put the config file into the same directory as the exe file
        ' or change the path
        Dim ini = Await IniFile.Load(".\example-config.ini")
        Console.WriteLine("Press Enter to overwrite the first sections, first entries value with TEST")
        Console.ReadLine()
        ini.Sections(0).Entries(0).Value = "TEST"
        Console.WriteLine("Press Enter to save the changes to file")
        Console.ReadLine()
        Await ini.Save()
        Console.WriteLine("File saved, press enter to leave")
        Console.ReadLine()
    End Sub

End Module

Kompletter Code – VB.NET Textdatei schreiben

Imports System.IO

Public Class Form1

    Private Sub btnWriteFile_Click(sender As Object, e As EventArgs) Handles btnWriteFile.Click
        Dim filepath = tbFilepath.Text.Trim()
        Dim content = tbContent.Text

        WriteFileSync(filepath, content)
        ' WriteFileWithEncodingSync(filepath, content)
        ' WriteFileAsync(filepath, content)
    End Sub

    Private Sub WriteFileSync(filepath As String, content As String)
        Try
            File.WriteAllText(filepath, content)
        Catch ex As Exception
            MessageBox.Show("Couldn't write file sync: " & ex.Message)
        End Try
    End Sub

    Private Sub WriteFileWithEncodingSync(filepath As String, content As String)
        Dim encoding = System.Text.Encoding.UTF8
        Try
            File.WriteAllText(filepath, content, encoding)
        Catch ex As Exception
            MessageBox.Show("Couldn't write file sync with encoding: " & ex.Message)
        End Try
    End Sub

    ' only available with .NET 5
    ' not in .NET Framework Apps
    'Private Sub WriteFileAsync(filepath As String, content As String)
    '    Try
    '        File.WriteAllTextAsync(filepath, content)
    '    Catch ex As Exception
    '        MessageBox.Show("Couldn't write file async: " & ex.Message)
    '    End Try
    'End Sub

End Class

Downloads

Der Beitrag VB.NET Textdatei schreiben – WriteAllText, Encoding (2026) erschien zuerst auf Robert Skibbe.