5 (Surgical) Tips to Program More Efficiently in C#💉
Tags: csharp, dotnet, tutorial, beginners
Published: 2022-06-09 09:05:00

Writing efficient code isn't always easy, but it can be done. Here are five ways to **program more efficiently in C#**, no matter what your preferred programming environment is. Whether you use Microsoft Visual Studio or another IDE, this advice will help you quickly, easily, and efficiently improve your programming skills.

At first they may seem like very basic and absurd tips and advice but I know that many C# developers do not put them into practice and end up wasting much more time than expected just reading and trying to understand the code (and if that time has not come, it will come soon).

Most of all, though, these tips will help you save time and minimize errors along the way. In order to succeed at your job as a programmer, you need to make the most of your time - and these tips will help you do just that!

---

## Take advantage of the record types

A very simple way to simplify your C# code when programming is to use `record` types. These provide a very easy to read way to create objects, especially in the immutable representation.

**Bad way:**

```csharp
//A lot of code lines
public class ApplicationInfo
{
    public string Name { get; init; }
    public string Path { get; init; }
public ApplicationInfo(string name, string path)
    {
        Name = name;
        Path = path;
    }
}
```

**Good way:**
 
```csharp
//Only one line with record types
public record ApplicationInfo(string name, string path);
```

This way you will save many lines of code and make it easier to read. If by chance in a few months you or another developer reads that code, you will understand it much easier.

📚Check out the Microsoft article to learn more: **[Create record types](https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/tutorials/records)**

---

## Avoid poor object initialization

This is another practice that many developers overlook. If properties are not defined between braces, **reading that code becomes difficult** and this can lead to a longer time to understand that code.

**Bad way:**

```csharp
//Poor code format for reading
Dotnetsafer securityManger = new Dotnetsafer();
securityManger.FindVulnerabilities = true;
securityManger.AppName = "Shield.exe";
```

**Good way:**

```csharp
//Better code format for reading
var securityManger = new Dotnetsafer { 
	FindVulnerabilities = true,
	AppName = "Shield.exe"
};
```

In this case, as you can see, the solution is simple. **Use object and collection initializers** to allow a better reading of the code.

📚Check out the Microsoft article to learn more: **[Object and Collection Initializers](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers)**

---

## Get used to using Var to define variables

Developers often complicate ourselves by using types that are too specific when defining variables. This can only lead to confusion when it comes to understanding the code.

**Bad way:**

```csharp
//Difficult to read
List<Repository.Shield.SecureDependencies> listOfSecureRefs = _repo.Shield.LastDependenciesAnalyzed();
```

**Good way:**

```csharp
//Easier to read
var listOfSecureRefs = _repo.Shield.LastDependenciesAnalyzed();
```

To solve this bad practice, it is as easy as **using `var` keyword**. This way the final code will be cleaner and much faster to read.

📚Check out the Microsoft article to learn more: **[Implicitly typed local variables](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/implicitly-typed-local-variables)**

---

## String interpolation "$" instead string.Format()

`String.Format()` is a common method of inserting values from one string into another but it is not the cleanest or the best if we focus on clean code.

**Bad way:**

```csharp
//using string.Format()
var date = DateTime.Now;
string greetings = string.Format("Today is {0}, the time is {1:HH:mm} now.", date.DayOfWeek, date);
```

**Good way:**

```csharp
//using string interpolation
var date = DateTime.Now;
string greetings = $"Today is {date.DayOfWeek}, the time is {date:HH:mm} now.");
```

We see that by using string interpolation the resulting **code is much more readable**. This is an example with a very simple code. In much more complex real life cases, you will appreciate having the code organized and clean.

📚Check out the Microsoft article to learn more: **[$ - string interpolation](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated)**

---

## Null coalescing (??) instead if-else

At first glance, using nested `if-else` seems to be the simplest option for null checking. Although it is a simple option, it is not the best one.

**Bad way:**

```csharp
if (application != null)
{
    if (application.protected != null)
    {
        return application.protected.shieldLastRun;
    }
    else 
    {
        return string.empty;
    }
}
else
{
    return string.empty;
}
```

**Good way:**

```csharp
return application?.protected?.shieldLastRun ?? string.empty;
```

By using the null coalescing operator `??` we can **greatly reduce the number of lines** of code and make it easier to read.

📚Check out the Microsoft article to learn more: **[?? and ??= operators](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-coalescing-operator)**