Like most teams, we have been working from home a lot more over the last year, and looking at ways to protect our work devices whilst away from the office. One of our recent upgrades is the home router, which we have just updated to use the UniFi Dream Machine. Our aim was to to help improve security by creating dedicated networks through separate VLANs and Wi-Fi connections. The Dream Machine also includes additional helpful security and monitoring features that we will aim to look at shortly.
The feature we were most pleasantly surprised to see on a router was…
A common question when working with C# is whether to use
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.
First, let’s summarize both types:
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.
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.
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.
“If two or more things coalesce, they come or grow together to form one thing or system”
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.
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:
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.
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();
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!
For the basic example there are only three lines of code involved:
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. …