A common question when working with C# is whether to use String or string. C# supports both versions as the language provides keywords that alias all of the .NET types :string:String, int:Int32, bool:Boolean etc..

The guidance has changed over the years so we are going to take a brief look at whether there is more to the decision than just stylistic preference. For the purpose of this article we’ll be focusing on Strings but the guidance applies to all the in-built types.

Overview

First, let’s summarize both types:

• String is an ordinary identifier that refers to the .NET System.String data type…

When programming with C# you don’t usually need to worry about the underlying target platform. There are however a few cases when the Application and OS architecture can affect program logic, change functionality and cause unexpected exceptions. In this article we’re going to look into how .NET handles x64 vs x86 systems and provide some C# examples to help out.

Compilation

Unlike a Native C or C++ binary, which is built to a specific architecture, a .NET application is compiled to platform independent Intermediate Language (IL). In spite of this, a .NET project contains a “Platform Target” build configuration:

Thousands of passwords and API keys are accidently uploaded to GitHub every day, putting users and businesses at risk. Managing sensitive data during the development process is clearly a difficult problem and can easily go very wrong. There is however, a great solution when developing with .NET!

In this article we’re going to cover the .NET Secret Manager which provides a simple method of storing sensitive data while developing your .NET Core Applications.

Overview

The Secret Manager, introduced in .NET Core SDK 3.0.100, provides a safe way of storing sensitive data. …

It is a common misconception that because TCP guarantees packet order your messages will be delivered individually, this is not always the case. We’re going to look at why this happens and some common solutions.

coalesce -
“If two or more things coalesce, they come or grow together to form one thing or system”

The ‘Small Packet Problem’

Nagle’s algorithm works behind the scenes to improve the efficiency of TCP. Unfortunately it is also associated with impacting the performance of sensitive applications and causing unexpected behaviour during development.

One of the key functions of Nagle’s algorithm is to combine smaller packets and transmit them…

The next evolution of .NET is just around the corner and there are many reasons to get excited. In this article we are going look at why this version is an important next step and how it is set to unify the .NET platform after nearly 20 years.

Where are we now?

Since the first release in 2002 .NET has had to constantly adapt to support different technologies. The platform has split into several different versions causing fragmentation. Just a few examples are:

• Compact Framework for early mobile / embedded devices 📟
• Silverlight for cross-browser development 🌐
• Windows Phone for Windows Phone 8 📱

…

C# provides several different ways to represent variable types. This article explores the differences between var, dynamic and object and takes a deeper look at what’s happening behind the scenes.

System.Object

The System.Object (aka object) is the base Type for all other types in C#. An object can store any value and any other Type can be implicitly converted to it:

object type_object_1 = “hello”;
object type_object_2 = 3; // Value type 
object type_object_3 = true; // Value type
object type_object_4 = new MyCustomClass();

Implicit conversions: No special syntax is required because the conversion is type safe and no data will…

Using reflection to find and invoke methods at runtime is simple in C#. This article provides a basic example to get going and some common pitfalls to look out for. Let’s get started!

Three Simple Steps

For the basic example there are only three lines of code involved:

1. Find the required method
2. Create an instance of the Type (if the method isn’t static)
3. Invoke it

Finding the Desired Method

Now we have a type initiated we can simply lookup our method using Type.GetMethod(). This call allows us to specify advanced filter parameters to ensure we find the correct method. …