Review of NDepend: A Swiss army knife for .NET developers

Some time ago, I had the privilege of being contacted by Patrick Smacchia, CEO and lead developer at NDepend to try out NDepend v2023.

Having never used NDepend before, my curiosity was naturally piqued. In my daily role as Senior Software Engineer, we extensively employ static code analysis tools as part of our Azure DevOps build pipelines. While running them on our machines isn’t mandatory, so why not first perform this kind of static analysis directly on your PC without having to wait?

Okay, I’ve given a good introduction, but what is NDepend, and what does it do?

What is NDepend?

NDepend is a powerful .NET Code Quality Tool that seamlessly integrates with Visual Studio and other DevOps platforms, supporting the latest technologies. It prioritizes quality in recent changes, offering a seamless PASS/FAIL Quality Gate and smart technical debt estimation.

Continue reading

Single Responsibility Principle (SRP) in C#

In my previous article I wrote about what they are and why to use Solid Principles in C#.

In this article, I am going to show you when and how to use the Single Responsibility Principle in C# with an example project. You can find the repository on GitHub.

The master branch shows the initial code used in the example.  There are separate tags and branches for each of the all solid principles that you can review or download as well. Here are links you can use to jump to these tagged versions in your browser:

What is the Single Responsibility Principle (SRP) in C#?

The Single Responsibility Principle is one of the SOLID design principles. We can reuse the definition from Wikipedia. The single-responsibility principle (SRP) is a computer-programming principle that states that every module, class or function in a computer program should have responsibility over a single part of that program’s functionality, and it should encapsulate that part. Robert C. Martin defines a responsibility as a reason to change, and concludes that a class or module should have one, and only one, reason to be changed.

To better understand it, we need to divide the definition into two parts:

  • Single Responsibility A class/method/function should have only a single responsibility.
  • A reason to change A class or method should have only one reason to change. About the “reason” Martin clarified that this principle is about people/role. It is people who request changes.

Why should you use the Single Responsibility Principle (SRP)?

  • Reduction in complexity of a code. A code is based on its responsibility and functionality. So, it reduces the code complexity.
  • Increased readability, extensibility and maintenance. As each method has a single functionality so it is easy to read and maintain.
  • Reusability and reduced error. As code separates based functionality so you can reuse the code somewhere else in an application.
  • Reduced coupling. It reduced the dependency code. A method’s code doesn’t depend on other methods.
  • Better testability. In the maintenance, when a functionality changes then we don’t need to test the entire model.

Continue reading

Type Conversion in C#

Type Conversion

The process of converting one type to another is called type conversion. In C#, you can perform the following kinds of conversions:

  • Implicit conversions
  • Explicit conversions
  • User-defined conversions
  • Conversion with a helper class

To go more in detail about Implicit and Explicit conversions read my previous article Boxing and Unboxing in C#.

Implicit conversions

An implicit conversion doesn’t need any special syntax, it can be executed because the compiler knows that the conversion is allowed and that it’s safe to convert.

A value type such as int can be stored as a double because an int can fit inside a double without losing any precision or from a reference type to one of its base types.

In this example, num is int and will be converted to double and no data will be lost.

int num = 123456;
double bigNum = num;
Console.WriteLine("bigNum: {0}", bigNum); 
/* Output:
    bigNum: 123456
*/

Also for reference types, no special syntax is necessary because a derived class always contains all the members of a base class. In these cases, the cast is done implicitly by the compiler.

Rectangle rectangle = new Rectangle();
Shape shape = rectangle;

Continue reading

Boxing and Unboxing in C#

C# is, for the most part, a statically typed language, this means that the compiler will check the type of every expression and you sometimes have to convert between types. The concept of boxing and unboxing is the starting point in C# type system in which a value of any type can be treated as an object.

As mentioned in my previous article C# Difference between Struct and Class, the important difference between a value type and a reference type is that the value type stores its value directly. A reference type stores a reference that points to an object on the heap that contains the value.

Boxing and Unboxing in C#

Boxing

Boxing is the process of taking a value type, putting it inside a new object on the heap and storing a reference to it on the stack. Boxing is an implicit conversion.

public class Program
{
    public static void Main(string[] args)
    {
        int total = 1976;
        object obj = total; // Boxing

        total = 2020;  

        System.Console.WriteLine("The value-type value = {0}", total); 
        System.Console.WriteLine("The reference-type value = {0}", obj); 
    } 
} 
/* Output: 
    The value-type value = 2020 
    The reference-type value = 1976 
*/

Unboxing

Unboxing is the exact opposite, it takes the item from the heap and returns a value type that contains the value from the heap. Unboxing is an explicit conversion. Attempting to unbox null or to unbox a reference to an incompatible value type causes an Exception.

public class Program
{
    public static void Main(string[] args)
    {
        int total = 1976;
        object obj = total;  // Boxing
        
        total = (int)obj; // Unboxing
        System.Console.WriteLine("The value-type value = {0}", total); 
        System.Console.WriteLine("The reference-type value = {0}", obj); 
    } 
} 
/* Output: 
    The value-type value = 1976 
    The reference-type value = 1976 
*/

Performance

There are some performance implications and memory requirements with each box and unboxing operation. When using the non-generic collections to store a value type, the boxing and unboxing operations can hurt performance.

Thanks for reading! 🌟

Difference between Struct and Class in C#

A good understanding of the differences in the behaviour of a Class and a Struct is crucial in creating a good software and developing in csharp.

Struct

A Struct is a value type that is typically used to encapsulate small groups of related variables and it is suitable for representing lightweight objects.

public struct Point 
{ 
    public int x;
    public int y; 
}

Class

A class is a reference type that enables to create your own custom types by grouping together variables of other types, methods and events. It defines the data and behaviour of a type.

public class Person 
{ 
    public string name;
    public Person() 
    { 
        name = "Steve"; 
    }
}

In .NET there are two locations in which a type can be stored in memory:

  • Stack;
  • Heap;

Stack

Value types are stored in the stack.

In this example, we create a variable int a = 3, after a variable int b = 4. On the stack, each variable is stored in the order it was created. In the end, we create a variable int c = b with the same value of b. So they both have 4 as value. For value types, each variable stores its own data.

Heap

The value of a reference type is stored on the heap and the address to this value is stored on the stack.

In this example, we create a class Student with a field name. Then we create an instance of the class Student called a and we set the value name to Alex. In the stack we store variable a and its value Alex on the heap. In the Stack, we store a pointer to the data. After we create another instance of the class Student called and we set the value name to Steve. In the Stack, we store variable b and its value Steve on the heap. Then we create another object called c and we set to b, in the stack we store variable c but its address is the same of b. If we change c name to Robert we are also changing the value of b that now is Robert and not Steve.

Memory

The benefit of storing data on the stack is that it’s faster, smaller, and doesn’t need the attention of the garbage collector, required for the heap. Value types are on the stack most of the time and are freed when the current method ends.

Reference types are on the heap and managed by the garbage collector. When a value type is on the stack, it takes up less memory than it would on the heap.

Difference

These are the main difference between Struct and Class in C#:

Difference between Struct and Class in C#

Tips

Microsoft suggests using a Struct instead of a Class if :

Instances of the type are small and commonly short-lived.

and to avoid Struct if:

It will have to be boxed frequently.

It isn’t immutable.

It has not an instance size under 16 bytes.

It logically doesn’t represent a single value, similar to primitive types.

Thanks for reading! 🌟

.NET Framework

Microsoft .NET Framework

Microsoft .NET Framework

Microsoft .NET is a free, cross-platform, open source developer platform for building many different types of applications.

With .NET, you can use multiple languages, editors, and libraries to build for web, mobile, desktop, gaming and IoT.

You can write .NET apps in C#, F#, or Visual Basic.

.NET Framework is Cross-Platform

  • .NET Core is a cross-platform .NET implementation for websites, servers, and console apps on macOS, Windows, and Linux.
  • .NET Framework supports websites, services, desktop apps, and more on Windows.
  • Xamarin/Mono is a .NET implementation for running apps on all the major mobile operating systems.

The first version was released in 2002 and the current version is 4.7.1.

Dot Net History

Continue reading