csharp on Mature Pessimizations - A programming blog by Theodoros Chatzigiannakis

Generics as super-functions

Sun, 03 Mar 2019 20:00:00 +0300

This post is the beginning of a series in which we will look at generics more closely, we will consider their implementation details across various languages, and we will explore their potential in solving problems we have today (with static analysis in mind).

As usual, we will use C# as for our examples because its generics syntax will be self-explanatory to developers familiar with C++, Java, Rust, etc. Also, for the purposes of this post we will use the terms “function” and “method” interchangeably.

A look at NDepend

Mon, 24 Sep 2018 20:00:00 +0300

Earlier this year, the developers of NDepend were kind enough to grant me free of charge a license for their tool. They invited me to try it and consider writing something about it.

So this post will be a brief pause from the usual content of my blog, as we will be taking a quick look at some of the functionality of this software. I’ve also opted to include a few screenshots from the NDepend site, because I preferred them to the ones I took myself.

Changing an object's type at runtime in C#

Mon, 21 Aug 2017 20:00:00 +0300

In most statically typed languages, an object’s type is set in stone once the object has been completely constructed. While the object can subsequently be cast to various types, it can never change its runtime type — many aspects of type systems and features (such as virtual dispatch) depend on this.

In this post, we will see how we can use unsafe code in C# to bypass the type system and change a .NET object’s runtime type. Then, we will see an unusual case where it would be neat to have this. Needless to say, don’t try this in real code.

Creating a ref alternative in C#

Mon, 02 Jan 2017 20:00:00 +0300

C# has two keywords called ref and out. They are not exactly the same, but they both offer the ability to pass a reference to a local variable or a field. At the binary level, what is passed is essentially a pointer.

This feature is useful, but it has certain technical limitations. We will explore the possibility of constructing an alternative that does not suffer from the same limitations.

Using the new() constraint is a symptom of the XY problem

Mon, 26 Dec 2016 20:00:00 +0300

C# allows you to write generic code with a few constraints that can’t be expressed through the type hierarchy alone. For example, you can require that a generic type parameter only accepts types that are structs, or reference types, or non-abstract types that have a public default constructor:

public void M<T1, T2, T3>()
    where T1 : struct
    where T2 : class
    where T3 : new()
{
    /* code */
}

That last case is what we’re interested in for this post.