Workshop 02

Workshop 02 - C# .Net

← Home →

Some general aspects

Add a new class named TstClass to the UPBDotNet project
Implement a public Id int property

internal class TstClass
{
	public int Id { get; set; }
}

Test the newly created class using, for example, a command button:

object tst = new TstClass();
var tstToString = tst.ToString();

One could notice that:
- The class could be instantiated even though no constructor was defined. A default constructor without parameters is automatically created.
- It is possible to assign a TstClass instance to an object variable, as all classes are by default inheriting the object class (polymorphism)
- object obj = 5 is also allowed. However, this is not polymorphism, but BOXING!
- Even not defined in TstClass, one could call ToString() as it is a virtual method defined in the object base class. For changing the implicit behavior of ToString(), override it in the derived class.
- var is not a type! It is used for type inferences. Thus, tstToString is a string variable.

public override string ToString()
{
	return $"TestClass({Id})";
}

- As result of binary -> decimal conversions, in the below example, the doubleResult variable is very small, but not 0, as opposed to the decimalResult variable, which value is 0:

double doubleDotOne = .1;
double double10XDotOne = 10 * doubleDotOne;
double doubleDotOnePlus10Times = doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne + doubleDotOne;

var doubleResult = double10XDotOne - doubleDotOnePlus10Times;

decimal decimalDotOne = .1m;
decimal decimal10XDotOne = 10m * decimalDotOne;
decimal decimalDotOnePlus10Times = decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne + decimalDotOne;

var decimalResult = decimal10XDotOne - decimalDotOnePlus10Times;

Reflection (Runtime Type Information)

For obtaining type information at runtime, use System.Reflection:

public static void GetTypePropertiesExample()
{
	var typeTstClass = typeof(TstClass);    
	foreach (var property in typeTstClass.GetProperties())
	{
		Console.WriteLine(property.Name);
	}
}

As an example, it is often necessary to copy an instance (e.g. an entity) to a different class instance (e.g. a DTO = data transformation object). A reflection-based mechanism will save a lot of repetitive work.
Important to notice: reflection is violating the encapsulation principle!
Classes and methods could be "decorated" with attributes. For example, one could mark a function as obsolete:

[Obsolete("Use the new method!")]
static void OldMethod()
{
	Console.WriteLine("Old");
}

It is also possible to define custom attributes, by inheriting the Attribute base class:

public class AllowDynamicCallsAttribute : Attribute
{
}

[AllowDynamicCalls]
public void f()
{
}

Custom attributes could be dynamically identified and treated in function of specific needs:

var typ = typeof(TstClass);
foreach (var method in typ.GetMethods()) 
{
	var attributes = method.GetCustomAttributes(false);
	if (attributes.Any(attr => attr is AllowDynamicCallsAttribute))
	{
		Console.WriteLine($"{method.Name}");
	}
}

Considering the high flexibility introduced by reflection, an important attention should be paid to security (e.g. malicious code injection)!

Value vs Reference Types

As opposed to a struct, which is value type, in .Net a class is reference type!
Carefully analyze and test the following code:

var x = new TstClass();
x.Id = 1;
var y = x;
x.Id = 2;
// y.Id is not 1 now, but 2 as TstClass is a reference type

For comparing the data (not the addresses) of 2 instances, override the Equals virtual method:

public override bool Equals(object? obj)
{
	var tst = obj as TstClass;
	if(tst == null) return false;
	return tst.Id == this.Id;
}

Together with Equals, it is highly recommended to override also GetHashCode accordingly. The hash code is useful, for example, when the type is used as key in a generic Dictionary.

public override int GetHashCode()
{
	return this.Id.GetHashCode();
}

For creating a copy of the current instance, implement the "Clone" method:

public TstClass Clone()
{
	var clone = this.MemberwiseClone() as TstClass;
	return clone;
}

Strings are immutable reference type => string concatenation may result in performance issues.

var x = "a";
var y = x; // y points to the same address as x
x = "b" // <=> x = new string() !
// y points to the old address => y still has the value "a"

It is important to notice storing secrets in strings should be treated with caution (heap inspection vulnerability)!
Observation! An immutable class could be implemented by providing a public read-only property (that could be assigned only via constructor) and by overloading the == operator. Thus, it will be impossible to assign a different value to an existing instance, but it will be possible to assign a different value to new instances.

			
public class ImmutableReference
{
	private readonly int _value;

	public ImmutableReference(int value)
	{
		_value = value;
	}

	public int Value
	{
		get
		{
			return _value;
		}
	}

	public override string ToString()
	{
		return Value.ToString();
	}

	public override bool Equals(object obj)
	{
		var immutableReference = obj as ImmutableReference;
		if (immutableReference == null) return false;
		return Value == immutableReference.Value;
	}

	public override int GetHashCode()
	{
		return Value.GetHashCode();
	}

	public static bool operator==(ImmutableReference x, ImmutableReference y)
	{
		// (object) => avoid a recursive call of the overloaded == operator
		if ((object)x == null && (object)y == null) return true;
		if ((object)x == null || (object)y == null) return false;
		return x.Equals(y);
	}

	public static bool operator !=(ImmutableReference x, ImmutableReference y)
	{
		return !(x == y);
	}

	public static void Test()
	{
		var immutableA = new ImmutableReference(1);
		var immutableB = immutableA;
		// the following commented statement is invalid:
		// immutableA.Value = 2;
		immutableA = new ImmutableReference(2);
		bool equals = (immutableA == immutableB);
	}
}

Pointers

Pointers are variables that are storing addresses.
Although not very frequently used in .Net, they are very useful in some particular scenarios.
For example, in one image analysis software it was necessary to convert byte arrays into arrays of shorts. Thus, instead of copying elements one by one => O(n), one could use pointers => O(1):

byte[] row = ...
unsafe 
{
	fixed (byte* pRow = row)
	{
		short* pShort = (short*)pRow;
		...
	}
}

Deterministic vs Non-Deterministic destruction

Implement a destructor:

~TstClass() 
{
	MessageBox.Show("The TstClass destructor was called !");
}

It is important to notice that objects are non-deterministically destroyed in .Net. For example, the destructor is not called when a variable goes out of scope. However, one can force garbage collection (unrecommended).

void f()
{
	var x = new TstClass();
}

void g()
{
	f();
	GC.Collect(); // unrecommended (used only for exemplification)
}

When deterministic destruction is needed (e.g. closing a file) one could use the Dispose method provided by the IDisposable interface.

internal class DisposableObject : IDisposable
{
	public void Dispose()
	{
		// e.g. closing a file or a DB connection
	}
}

It is very important to call Dispose even when exceptions are thrown => use try / catch / finally (the using construction could be employed for simplifying the below syntax):

public void f()
{
	var obj = new DisposableObject();
	try
	{

	}
	catch (Exception ex)
	{

	}
	finally
	{
		obj.Dispose();
	}
}

An interesting exercise

Observation! In .Net it is possible to use generics (classes in which one or more types are specified as parameters), e.g.: var list = new List<TstClass>();
Carefully analyze the following code using breakpoints:

public IEnumerable<int> f()
{
	yield return 1;
	yield return 2;
	yield return 3;
}

public void g()
{
	foreach(var x in f())
	{
		Console.WriteLine(x);
	}
}

Write a program for computing the following sum:
S = 1! + 2! + ... + n!
One could choose a structured solution:

public long Factorial(long n)
{
	long fact = 1L;
	for (long i = 1; i <= n; i++)
	{
		fact *= i;
	}
	return fact;
}

public long Sum(long n)
{
	long sum = 0;
	for (long i = 1; i <= n; i++)
	{
		sum += Factorial(i);
	}
	return sum;
}

The structured solution is O(n²). A possible optimization could be observed:

public long SumFact(long n)
{
	long fact = 1L
	long sum = 0;
	for (long i = 1; i<=n ; i++)
	{
		fact *= i;
		sum += fact;
	}
	return sum;
}

Would it be possible to provide a structured solution at O(n)?

public IEnumerable<long> Factorial(long n)
{
	long factorial = 1L;
	for (long i = 1; i <= n; i++)
	{
		factorial = factorial * i;
		yield return factorial;
	}
}

public long Sum(long n)
{
	long sum = 0;
	foreach (var factorial in Factorial(n))
	{
		sum += factorial;
	}
	return sum;
}

LINQ

Let's try implementing a "filter" => a method named "Where" that will provide only the elements with Id > 10. Of course, we can use yield return. We'll implement it in a static class named LinqTest:

internal static class LinqTest
{
	public static IEnumerable<TstClass> Where(List<TstClass> list)
	{
		foreach (var x in list)
		{
			if (x.Id > 10)
			{
				yield return x;
			}
		}
	}
}

A code calling it will look something like this:

	
var list = new List<TstClass>();
var result = LinqTest.Where(list);

In .Net it is possible to simplify the syntax, by implementing class extensions.

internal static class LinqTest
{
	public static IEnumerable<TstClass> Where(this List<TstClass> list)
	{
		foreach (var x in list)
		{
			if (x.Id > 10)
			{
				yield return x;
			}
		}
	}
}

Now, the Where method should not be prefixed any more by the class name when it is called. We can call it as if it was a method of the List class (even if it is not!):
var result = list.Where();
I would also like to have more flexibility: pass the filter criterion as a parameter. For this, I will need a delegate (a function pointer), that accepts a TstClass as input parameter and returns a Boolean:

public static IEnumerable<TstClass> Where(List<TstClass> list, Func<TstClass, bool> fn)
{
	foreach (var x in list)
	{
		if (fn(x))
		{
			yield return x;
		}
	}
}

Func is a generic delegate => a type safe function pointer. So, only addresses of functions with the expected signature will be accepted.
Now, the criterion could be dynamically provided either by specifying a function address, or by using a lambda expression (anonymous functions that could be used inline):

static Boolean Criterion(TstClass obj)
{
	return obj.Id < 5;
}

static void Tst()
{
	var list = new List<TstClass>();
	var result1 = list.Where(Criterion);
	var result2 = list.Where(x => x.Id >= 5);
}

There's one more step left: make the Where function generic and change the parameter type from generic List to the, more general, IEnumerable interface:

public static IEnumerable<T> Where<T>(IEnumerable<T> list, Func<T, bool> fn)
{
	foreach (var x in list)
	{
		if (fn(x))
		{
			yield return x;
		}
	}
}

Thus, one could consider chains of such extension methods calls:

static void Tst()
{
	var list = new List<TstClass>();
	var result = list
		.Where(x => x.Id > 10)
		.Where(x => x.Id < 20);
}

The System.Linq namespace provides a set of such very useful generic extensions.

Parallel programming

One LINQ extension example is Sum(). It is important to notice LINQ supports parallelization: Parallel LINQ (PLINQ):

int[] vector = {1, 2, 3, 4, 5 };
int threads = 2; 
var sum = vector
	.AsParallel()
	.WithDegreeOfParallelism(threads)
	.Sum();

Consider below an example of implementing the same Sum functionality using the Task class:

public class Parameters
{
	public int TaskIndex { get; set; }
	public int StartIndex { get; set; }
	public int EndIndex { get; set; }
}

public static class Test
{
	private static long[] _partialSum;

	private static void ExtSum(this long[] vector, Parameters parameters)
	{
		long result = 0;
		for (int index = parameters.StartIndex; index <= parameters.EndIndex; index++)
		{
			result += vector[index];
		}
		_partialSum[parameters.TaskIndex] = result;
	}


	public static long ExtSum(this long[] vector, int threads)
	{
		var tasks = new Task[threads];
		_partialSum = new long[threads];
		var partialIndex = new long[threads];
		var n = vector.Length;
		int size = n / threads;
		for (int thread = 1; thread <= threads; thread++)
		{
			var startIndex = (thread - 1) * size;
			var endIndex = startIndex + size - 1;
			if (thread == threads) endIndex = n - 1;
			var parameters = new Parameters
			{
				TaskIndex = thread - 1,
				StartIndex = startIndex,
				EndIndex = endIndex
			};
			tasks[thread - 1] = Task.Factory
				.StartNew(() => vector.ExtSum(parameters));
		}
		Task.WaitAll(tasks);
		return _partialSum.Sum();
	}
}

For testing the previous function, one could use the following code:

var n = 300000000L;
var threads = 4;
var vector = new long[n];
for (int i = 0; i < n; i++)
	vector[i] = i + 1;
var stopwatch = new Stopwatch();
stopwatch.Start();
var result = Test.ExtSum(vector, threads);
stopwatch.Stop();
var elapsed = stopwatch.Elapsed;
var expectedResult =  n * (n + 1) / 2L;
var success = result == expectedResult;
MessageBox.Show($"Success: {success}, Elapsed: {elapsed}(threads={threads})");

When writing parallel algorithms, an important attention should be granted to concurrent access.

Async-Await

Async-Await is usually used for awaiting I/O operations => the thread is not interrupted, but is notified (event-driven mechanism) by OS! when the operation is completed.
In the test example presented below, Task.Run will however result in creating a new thread.
Test the below program using breakpoints. Notice that, in WinForm, async-await could be used for avoiding GUI freezing.
Without await, the Console.WriteLine("Done!"); statement will be executed immediately (without waiting for the loop to finish).

public static async Task<string> GetAsync()
{
	await Task.Run(() =>
		{
			var startDate = DateTime.Now;
			while ((DateTime.Now.Subtract(startDate).TotalSeconds < 30))
			{

			}
		}
	);
	Console.WriteLine("Done!");
	return "ok";
}

// GUI not blocked
private async void buttonOk_Click(object sender, EventArgs e)
{
	var r = await GetAsync();
}

// GUI blocked
private void buttonOk_Click(object sender, EventArgs e)
{
	var startDate = DateTime.Now;
	while ((DateTime.Now.Subtract(startDate).TotalSeconds < 30))
	{
	}
}

Async-await will break the method in 2 parts and will use the one containing the code which follows await as a "callback".

public static void FirstMethod(Action callback)
{
	var startDate = DateTime.Now;
	while ((DateTime.Now.Subtract(startDate).TotalSeconds < 30))
	{
	}
	callback();
}

public static void SecondMethod()
{
	Console.WriteLine("Done!");
}

private void buttonOk_Click(object sender, EventArgs e)
{
	// FirstMethod receives as parameter the address of the "callback" method
	FirstMethod(SecondMethod);
}

References:

Microsoft C# language documentation
Implement a Dispose method

← Home →