To find the loaded assemblies we first need to determine the current AppDomain (it is possible for your application to have more than one AppDomain, but in that case you have created the second one yourself). Each AppDomain keeps a list of Assemblies it is using and in the following example code we query it using the GetAssemblies() method.

By calling FullName we obtain the name, version, culture and public key ID for each assembly.

using System;
using System.Text;
using System.Reflection;

namespace AssemblyListing
{
    class Program
    {
        static void Main(string[] args)
        {
            AppDomain MyDomain = AppDomain.CurrentDomain;
            Assembly[] AssembliesLoaded = MyDomain.GetAssemblies();

            foreach (Assembly MyAssembly in AssembliesLoaded)
            {
                Console.WriteLine("Loaded: {0}", MyAssembly.FullName);
            }
        }
    }
}

This is a post from Martijn's C# Coding Blog.

Measuring your process memory usage

The .NET API allows you to retrieve the total amount of memory allocated to a process through the System.Diagnostics.Process class. This variable is useful is you are interested in the total memory footprint of your process, but it is too coarse to measure how much memory a single object takes.

long Process_MemoryStart = 0;
Process MyProcess = System.Diagnostics.Process.GetCurrentProcess();
Process_MemoryStart = MyProcess.PrivateMemorySize64;

This will return the total amount of memory uniquely allocated to your process in bytes (not shared with other processes).This measure of memory includes everything from code, libraries, the execution environment, stack, variables etc. If you try to measure the creation of a new object in memory using this variable it is likely to show no change.  It is very likely that the difference shown is zero as some memory for new objects is pre-allocated.

Using the garbage collector to gain insights into memory allocation

If you are building a multi threaded application the following code won’t work as expected, other threads might be too busy creating new objects and destroying to gain a clear insight into how much memory an object uses.We make use of the fact that the Garbage collector can report how much allocated memory it is aware off. As the Garbage collector manages just the objects we create for our application — we can use it to measure an objects size.

By calling System.GC.GetTotalMemory() we can obtain a measure of how much memory the Garbage collector is managing. If we call this function again after we allocated our object, we can calculate the difference.

// Measure starting point memory use
GC_MemoryStart = System.GC.GetTotalMemory(true);

// Allocate a new byte array of 20000 elements (about 20000 bytes)
MyByteArray = new byte[20000];

// Obtain measurements after creating the new byte[]
GC_MemoryEnd = System.GC.GetTotalMemory(true);

// Ensure that the Array stays in memory and doesn't get optimized away
MyByteArray[1] = 20;

By calling System.GC.GetTotalMemory with “true” as a parameter we ensure that the Garbage collector makes at least an efford to clean up before reporting the amount of memory under its management. To avoid any compiler optimizations that would shift code around, we need to make sure that our newly created byte array is accessed again after we make the second GetTotalMemory() call.

The code listed at the end of this post reports something similar to the following when run:

Memory Use reported by GC: 20480
Memory Use reported by Process: 65536
Memory allocated by the Garbage collector: 135168 bytes
Memory allocated by the process: 2641920 bytes

As you can see, allocating a 20,000 element byte array takes up about 20Kb (with some additional overhead). Apparently the garbage collector decided to increase the applications total memory by 64Kb as the total process size increased by that much.You mileage may vary depending on your run. The final two figures show how much memory is under management by the Garbage collector for our simple application (about 135Kb) and the how much the Operating system needed to allocate it the whole application (2 Megabyte).

using System;
using System.Diagnostics;

namespace ProfileTest
{
	class MainClass
	{
		public static void Main(string[] args)
		{
	      long GC_MemoryStart = 0;
    	  long GC_MemoryEnd = 0;
		  long Process_MemoryStart = 0;
		  long Process_MemoryEnd = 0;
		  byte[] MyByteArray;

		  Process MyProcess = System.Diagnostics.Process.GetCurrentProcess();

		  // Measure starting point memory use
      	  GC_MemoryStart = System.GC.GetTotalMemory(true);
		  Process_MemoryStart = MyProcess.PrivateMemorySize64;

		  // Allocate a new byte array of 20000 elements (about 20000 bytes)
		  MyByteArray = new byte[20000];

		  // Obtain measurements after creating the new byte[]
		  GC_MemoryEnd = System.GC.GetTotalMemory(true);
		  Process_MemoryEnd = MyProcess.PrivateMemorySize64;

		  // Ensure that the Array stays in memory and doesn't get optimized away
		  MyByteArray[1] = 20;

		  // Show the difference after allocating the memory
		  Console.WriteLine("Memory Use reported by GC: {0}" , GC_MemoryEnd - GC_MemoryStart );
		  Console.WriteLine("Memory Use reported by Process: {0}" , Process_MemoryEnd - Process_MemoryStart );

		  // Show how much memory was allocated by the process, and how much by the GC
		  Console.WriteLine("Memory allocated by the Garbage collector: {0} bytes", GC_MemoryEnd);
		  Console.WriteLine("Memory allocated by the process: {0} bytes", Process_MemoryEnd);
		}
	}
}

This is a post from Martijn's C# Coding Blog.

The complete source code is listed below, but lets have a little look at how it works first.

The problem

I want to take a string, and then encrypt it using a password. The result should be a Base64 encoded string that I can store somewhere relatively safe.

            // The message to encrypt.
            string Msg = "This world is round, not flat, don't believe them!";
            string Password = "secret";

            string EncryptedString = EncryptString(Msg, Password);
            string DecryptedString = DecryptString(EncryptedString, Password);

            Console.WriteLine("Message: {0}",Msg);
            Console.WriteLine("Password: {0}",Password);
            Console.WriteLine("Encrypted string: {0}",EncryptedString);
            Console.WriteLine("Decrypted string: {0}",DecryptedString);

In the EncryptString function we apply the TripleDES algorithm with a 128 bit key. But first we need to turn the above passphrase (’secret’) into a 128 bit key. One useful coincidence is that the MD5 hash algorithm accepts a set of bytes of any length and turns them into a 128 bit hash. So by running the password through the MD5 hashing algorithm we create our key.

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

The TripleDES algorithm itself turns a byte array into an encrypted byte array. So we first need to convert our C# message string (which is Unicode encoded) into a byte array through the System.Text.UTF8Encoding encoder.

The key is used to initialize the TripleDES algorithm. In addition we need to specify that we will only encode something once (CipherMode.ECB) and because its unlikely that our source string fits into a single TripleDES block we need to specify how we want to pad any remaining bytes (PaddingMode.PKCS7).

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the encoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

The encrypted byte array is finally converted into a Base64 encoded string for easy storage. The DecryptString function is very similar to the encryption function, except that it turns the Base64 encoded encrypted message back into the original UTF8 string.

Drawbacks to the above method

To keep the code above straightforward we made use of the fact that an MD5 hash is exactly 128 bits in length. The C# TripleDES code accepts three possible key lengths: 64 bit, 128 bit and 192 bit. Only 192 bit keys are truly TripleDES, the 128 bit key length we obtain from the MD5 hash is only sufficient for Double DES. According to Wikipedia, that would make its real key strength only equivalent to 80 bits.

The Source code

using System;
using System.Text;
using System.Security.Cryptography;

namespace EncryptStringSample
{
    class MainClass
    {

        public static string EncryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the encoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

            // Step 4. Convert the input string to a byte[]
            byte[] DataToEncrypt = UTF8.GetBytes(Message);

            // Step 5. Attempt to encrypt the string
            try
            {
                ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
                Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
            }
            finally
            {
                // Clear the TripleDes and Hashprovider services of any sensitive information
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }

            // Step 6. Return the encrypted string as a base64 encoded string
            return Convert.ToBase64String(Results);
        }

        public static string DecryptString(string Message, string Passphrase)
        {
            byte[] Results;
            System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();

            // Step 1. We hash the passphrase using MD5
            // We use the MD5 hash generator as the result is a 128 bit byte array
            // which is a valid length for the TripleDES encoder we use below

            MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
            byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));

            // Step 2. Create a new TripleDESCryptoServiceProvider object
            TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();

            // Step 3. Setup the decoder
            TDESAlgorithm.Key = TDESKey;
            TDESAlgorithm.Mode = CipherMode.ECB;
            TDESAlgorithm.Padding = PaddingMode.PKCS7;

            // Step 4. Convert the input string to a byte[]
            byte[] DataToDecrypt = Convert.FromBase64String(Message);

            // Step 5. Attempt to decrypt the string
            try
            {
                ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
                Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
            }
            finally
            {
                // Clear the TripleDes and Hashprovider services of any sensitive information
                TDESAlgorithm.Clear();
                HashProvider.Clear();
            }

            // Step 6. Return the decrypted string in UTF8 format
            return UTF8.GetString( Results );
        }

        public static void Main(string[] args)
        {
            // The message to encrypt.
            string Msg = "This world is round, not flat, don't believe them!";
            string Password = "secret";

            string EncryptedString = EncryptString(Msg, Password);
            string DecryptedString = DecryptString(EncryptedString, Password);

            Console.WriteLine("Message: {0}",Msg);
            Console.WriteLine("Password: {0}",Password);
            Console.WriteLine("Encrypted string: {0}",EncryptedString);
            Console.WriteLine("Decrypted string: {0}",DecryptedString);
        }
    }
}

This is a post from Martijn's C# Coding Blog.

When I finally had MonoDevelop compiled and installed — the promised debugging didn’t actually work. Bummer. I gave up, and went back to coding the old way (with ticker tape). This morning I checked out the latest SVN, installed it and ran it, just for laughs.

And behold as shown below — debugging actually worked. I can step and trace through the code, and set watches making MonoDevelop suddenly that much more useful to me.

The best thing? The Mono C# libraries are not black boxes but open source — you can step and trace directly into the Mono libraries themselves and find out what Mono is doing as you call library functions.

The problem with installing MonoDevelop 2.0alpha 2 is that the guides online don’t actually produce a working MonoDevelop installation. If you run MonoDevelop under Ubuntu like I do, the number of dependencies and sub-dependencies you need to resolve is large and I ended up compiling, re-compiling and changing version numbers of modules multiple times to find combinations that worked. In addition I had to change, add and resolve many missing library conflicts within Ubuntu as well.

Concluding: Yes, it is possible. Just do not expect a quick and easy install of MonoDevelop 2.0 alpha 2 on your Ubuntu installation.

This is fun only if you have plenty of spare time.

Some hints — this does not produce a working Mono Develop installation

• Remove Mono 1.9, MonoDevelop 1.0, and any and all other mono related things from your ubuntu installation before attempting to compile MonoDevelop 2.0 Alpha 2 to avoid conflicts down the road.
• Install mono 2.3, the debugger and mono develop from SVN, not from the packages provided on the website (they do not work)
• $ svn co svn://anonsvn.mono-project.com/source/trunk/mono
  $ svn co svn://anonsvn.mono-project.com/source/trunk/mcs
  $ svn co svn://anonsvn.mono-project.com/source/trunk/debugger
  $ svn co svn://anonsvn.mono-project.com/source/trunk/mono-addins
  $ svn co svn://anonsvn.mono-project.com/source/trunk/olive
  $ svn co svn://anonsvn.mono-project.com/source/trunk/monodevelop
• I installed gtk-sharp-2.12.5, gnome-sharp-2.20.0 and libglade-2.0.1 as support libraries
• Compile and install monodevelop last of all

Mono JIT compiler version 2.3 (/trunk/mono r121276 Thu Dec 11 13:04:53 CST 2008)
Copyright (C) 2002-2008 Novell, Inc and Contributors. www.mono-project.com

This is a post from Martijn's C# Coding Blog.

This article will go into how to create a hash of your passwords and how salting them makes them more secure.

What is a hash?

A hash function turns “Hello World” into “3964322768″. And it does that every time you run that same string through the hash function. How it does that depends on the hash algorithm, and so does the “3964322768″ result.

Different hash function return different results, but given the same data the same function always returns the same result.

Now imagine transferring a block of 2Kb of data across the Internet — at the end of it you include an extra hash. The receiver can check if the data received was all transferred correctly, if a bit had fallen over the data block would have generated a different hash.

On collisions

In the “old days” CRC16 was used to ensure that data was being transmitted correctly over telephone and serial lines. As modems became faster and the data send increased collisions became more frequent, leading to corrupted transfers. The CRC-16 was a 16-bit value, so it could only generate 2^16 = 65535 unique values.

By making the hash longer the chance that two sets of data share the same hash value (a collision) decreases. It is important to realize that this chance will never reach zero! It is entirely (though often unlikely) possible that your program will have two strings that generate the same hash.

Using hashes to store passwords

Hashes are useful as a one-way method to store passwords. In a typical scenario a user types his password and the system generates the hash and compares this with a hash stored on file.

It is not possible to reverse the password from a hash. Thus if someone gets hold of the password file they cannot reverse the original passwords.

Salting the hash

Hashes however are still open to one of the oldest attacks: the dictionary attack. Your system will likely lock out a users after several failed password attempts. If however through a security breach an attacker obtains your hashed password file (or part thereof) it is possible to apply one of many standard dictionaries against the found hashes:

1. Obtain hashed passwords (through online snooping, hacking)
2. Use dictionary software which contains pre-computed hash values for common passwords
3. See if the result matches , if so : password found
4. The hacker can now login and impersonate the user

The dictionary attack can be blunted. By adding a unique salt to each hash the attacker needs to re-calculate the dictionary for each users password, greatly increasing the attack time.

A salt is a random set of bytes which are added to the data set before calculating the hash.

1. User enters password for the first time
2. The system adds a salt to the password (for example 4 bytes of random data)
3. The system generates and stores the hash together with the salt

When the user returns for another login the system does the following:

1. The users enters the password
2. The system looks up the stored hash + salt
3. The system tries if a new hash of the given password + salt matches the stored hash
4. If they match the user can login

A Salted Hash implementation in C#

The following implementation demonstrates how you can implement a Salted Hash in C#. The class defaults to using SHA256Managed hash algorithm, and a salt size of 32 bits. You can however call the class with any other HashAlgorithm derived class (such as for example: SHA1Managed,SHA256Managed, SHA384Managed, SHA512Managed and MD5CryptoServiceProvider) and specify a salt size of any length.

The SaltedHash class provides two routines that do all the leg work:

void GetHashAndSalt(byte[] Data, out byte[] Hash, out byte[] Salt)

This routine generates the hash and a random salt for a given set of bytes.

bool VerifyHash(byte[] Data, byte[] Hash, byte[] Salt)

This routine checks if the data passed, together with the stored salt will generate the same hash as we had earlier calculated.

For convenience two more functions allow us to work with strings directly instead of byte arrays:

public void GetHashAndSaltString(string Data, out string Hash, out string Salt)

This routine takes a C# hash string and returns both the Hash and Salt as Base-64 encoded string.

public bool VerifyHashString(string Data, string Hash, string Salt)

The counterpart to the GetHashAndSaltString function, this routine allows us to use verify whether a string returns the same hash with the given salt.

using System;
using System.Security.Cryptography;
using System.Text;

namespace SaltedHash
{
    class SaltedHash
    {
        HashAlgorithm HashProvider;
        int SalthLength;

        /// <summary>
        /// The constructor takes a HashAlgorithm as a parameter.
        /// </summary>
        /// <param name="HashAlgorithm">
        /// A <see cref="HashAlgorithm"/> HashAlgorihm which is derived from HashAlgorithm. C# provides
        /// the following classes: SHA1Managed,SHA256Managed, SHA384Managed, SHA512Managed and MD5CryptoServiceProvider
        /// </param>

        public SaltedHash(HashAlgorithm HashAlgorithm, int theSaltLength)
        {
            HashProvider = HashAlgorithm;
            SalthLength = theSaltLength;
        }

        /// <summary>
        /// Default constructor which initialises the SaltedHash with the SHA256Managed algorithm
        /// and a Salt of 4 bytes ( or 4*8 = 32 bits)
        /// </summary>

        public SaltedHash() : this(new SHA256Managed(), 4)
        {
        }

        /// <summary>
        /// The actual hash calculation is shared by both GetHashAndSalt and the VerifyHash functions
        /// </summary>
        /// <param name="Data">A byte array of the Data to Hash</param>
        /// <param name="Salt">A byte array of the Salt to add to the Hash</param>
        /// <returns>A byte array with the calculated hash</returns>

        private byte[] ComputeHash(byte[] Data, byte[] Salt)
        {
            // Allocate memory to store both the Data and Salt together
            byte[] DataAndSalt = new byte[Data.Length + SalthLength];

            // Copy both the data and salt into the new array
            Array.Copy(Data, DataAndSalt, Data.Length);
            Array.Copy(Salt, 0, DataAndSalt, Data.Length, SalthLength);

            // Calculate the hash
            // Compute hash value of our plain text with appended salt.
            return HashProvider.ComputeHash(DataAndSalt);
        }

        /// <summary>
        /// Given a data block this routine returns both a Hash and a Salt
        /// </summary>
        /// <param name="Data">
        /// A <see cref="System.Byte"/>byte array containing the data from which to derive the salt
        /// </param>
        /// <param name="Hash">
        /// A <see cref="System.Byte"/>byte array which will contain the hash calculated
        /// </param>
        /// <param name="Salt">
        /// A <see cref="System.Byte"/>byte array which will contain the salt generated
        /// </param>

        public void GetHashAndSalt(byte[] Data, out byte[] Hash, out byte[] Salt)
        {
            // Allocate memory for the salt
            Salt = new byte[SalthLength];

            // Strong runtime pseudo-random number generator, on Windows uses CryptAPI
            // on Unix /dev/urandom
            RNGCryptoServiceProvider random = new RNGCryptoServiceProvider();

            // Create a random salt
            random.GetNonZeroBytes(Salt);

            // Compute hash value of our data with the salt.
            Hash = ComputeHash(Data, Salt);
        }

        /// <summary>
        /// The routine provides a wrapper around the GetHashAndSalt function providing conversion
        /// from the required byte arrays to strings. Both the Hash and Salt are returned as Base-64 encoded strings.
        /// </summary>
        /// <param name="Data">
        /// A <see cref="System.String"/> string containing the data to hash
        /// </param>
        /// <param name="Hash">
        /// A <see cref="System.String"/> base64 encoded string containing the generated hash
        /// </param>
        /// <param name="Salt">
        /// A <see cref="System.String"/> base64 encoded string containing the generated salt
        /// </param>

        public void GetHashAndSaltString(string Data, out string Hash, out string Salt)
        {
            byte[] HashOut;
            byte[] SaltOut;

            // Obtain the Hash and Salt for the given string
            GetHashAndSalt(Encoding.UTF8.GetBytes(Data), out HashOut, out SaltOut);

            // Transform the byte[] to Base-64 encoded strings
            Hash = Convert.ToBase64String(HashOut);
            Salt = Convert.ToBase64String(SaltOut);
        }

        /// <summary>
        /// This routine verifies whether the data generates the same hash as we had stored previously
        /// </summary>
        /// <param name="Data">The data to verify </param>
        /// <param name="Hash">The hash we had stored previously</param>
        /// <param name="Salt">The salt we had stored previously</param>
        /// <returns>True on a succesfull match</returns>

        public bool VerifyHash(byte[] Data, byte[] Hash, byte[] Salt)
        {
            byte[] NewHash = ComputeHash(Data, Salt);

            //  No easy array comparison in C# -- we do the legwork
            if (NewHash.Length != Hash.Length) return false;

            for (int Lp = 0; Lp < Hash.Length; Lp++ )
                if (!Hash[Lp].Equals(NewHash[Lp]))
                    return false;

            return true;
        }

        /// <summary>
        /// This routine provides a wrapper around VerifyHash converting the strings containing the
        /// data, hash and salt into byte arrays before calling VerifyHash.
        /// </summary>
        /// <param name="Data">A UTF-8 encoded string containing the data to verify</param>
        /// <param name="Hash">A base-64 encoded string containing the previously stored hash</param>
        /// <param name="Salt">A base-64 encoded string containing the previously stored salt</param>
        /// <returns></returns>

        public bool VerifyHashString(string Data, string Hash, string Salt)
        {
            byte[] HashToVerify = Convert.FromBase64String(Hash);
            byte[] SaltToVerify = Convert.FromBase64String(Salt);
            byte[] DataToVerify = Encoding.UTF8.GetBytes(Data);
            return VerifyHash(DataToVerify, HashToVerify, SaltToVerify);
        }

    }

    /// <summary>
    /// This little demo code shows how to encode a users password.
    /// </summary>

    class SaltedHashDemo
    {
        public static void Main(string[] args)
        {
            // We use the default SHA-256 & 4 byte length
            SaltedHash demo = new SaltedHash();

            // We have a password, which will generate a Hash and Salt
            string Password = "MyGlook234";
            string Hash;
            string Salt;

            demo.GetHashAndSaltString(Password, out Hash, out Salt);
            Console.WriteLine("Password = {0} , Hash = {1} , Salt = {2}", Password, Hash, Salt);

            // Password validation
            //
            // We need to pass both the earlier calculated Hash and Salt (we need to store this somewhere safe between sessions)

            // First check if a wrong password passes
            string WrongPassword = "OopsOops";
            Console.WriteLine("Verifying {0} = {1}", WrongPassword, demo.VerifyHashString(WrongPassword, Hash, Salt));

            // Check if the correct password passes
            Console.WriteLine("Verifying {0} = {1}", Password, demo.VerifyHashString(Password, Hash, Salt));

        }
    }

}

Image credit: Looking Glass

This is a post from Martijn's C# Coding Blog.

Unit testing helps you verify that each individual part of your code is working as expected and keeps doing that as you change your software. You do this by adding small bits of testing code and have the unit testing frame work execute them in order. I am currently writing some code that needs to have a basic unit testing framework and wanted to install the NUnit framework. This post is about how you can install NUnit, use it and run it with / install it for Visual Studio C# 2008 Express. I will leave the nuts and bolts of unit testing to a future post but this post should get you up and running.

Installing NUnit itself is straightforward and only requires a few steps:

• Download the NUnit framework from the NUnit website (download NUnit-2.4.8-net-2.0.msi)
• Install the software on your Windows XP / Vista machine

Creating your first NUnit test

Now we need to create a new project to test if this works, and we need to add a reference to NUnit to be able to use the code.

Click “Project > Add Reference…”

Select “Browse” and navigate to “C:\Program Files\NUnit 2.4.8\bin” and select the nunit.framework.dll.

This allows you to use NUnit.Framework in your programs.

Testing the NUnit Demo code

Below I have included a little bit of demo code that tests if this works properly. The code is mostly borrowed from the NUnit website demo, I have just for the sake of it included a class containing “Main” so that the code actually compiles and runs.

using System;
using NUnit.Framework;

namespace bank
{
    public class Account
    {
        private float balance;
        public void Deposit(float amount)
        {
            balance += amount;
        }

        public void Withdraw(float amount)
        {
            balance -= amount;
        }

        public void TransferFunds(Account destination, float amount)
        {
        }

        public float Balance
        {
            get { return balance; }
        }
    }
}

namespace bank
{
    [TestFixture]
    public class AccountTest
    {
        [Test]
        public void TransferFunds()
        {
            Account source = new Account();
            source.Deposit(200.00F);
            Account destination = new Account();
            destination.Deposit(150.00F);

            source.TransferFunds(destination, 100.00F);
            Assert.AreEqual(250.00F, destination.Balance);
            Assert.AreEqual(100.00F, source.Balance);

        }

        [Test]
        public void DepositFunds()
        {
            Account source = new Account();
            source.Deposit(200.00F);
            Assert.AreEqual(200.00F, source.Balance);
        }

    }
}

namespace UnitTestDemo
{
    public class MyAccountingSoftware
    {

        public static void Main()
        {
            bank.Account DemoAccount = new bank.Account();
            DemoAccount.Deposit(1000.00F);
            DemoAccount.Withdraw(500.50F);
            Console.WriteLine("Our account balance is {0}", DemoAccount.Balance);
        }

    }
}

In the above code the actual unit testing is done by the “AccountTest” class, for simplicity we keep this in the same file but usually you would keep a separate directory with all of your unit tests, separate from the actual code.

Note that because the “WithDraw” function in the code above is poorly implemented (eg. its empty) the Unit test will hopefully (!!) fail. The second unit test in DepositFunds should succeed.

How to run the NUnit GUI runner from within Visual Studio C# Express 2008

We can run NUnit from the Menu option it installed under [Start/Programs/NUnit] but it is more convenient to do so from Visual Studio Express itself.

Visual Studio C# Express allows you to define outside “Tools” which can be run from the menu. This is exactly what we would like to do with the NUnit GUI Runner. The GUI Runner is a tool which loads our program and executes all the unit tests it finds and reports the results in a seperate window.

Click on “Tools > External Tools…” to add NUnit’s GUI Runner.

The following definition allows us to run the tests in our current project:

To run the unit test, simply click “NUnit” from the Tools Menu.

[Click the picture for a larger image]

If everything went correctly you should see NUnit run 2 tests, one of which will fail.

This is a post from Martijn's C# Coding Blog.

Multi-tasking / multi-threaded applications have always been a bit of a nightmare to create. Different operating systems and sometimes even different compilers and class libraries tends to have their own implementations. Fortunately the .NET / C# implementation of threading is extremely straightforward and makes it simple to create a multi threaded application. In this article we look at building some very simple threaded applications. We go into how to create them, synchronize them and how we can ensure that things such as shared variables are properly protected.

But what are threads anyway? Threading provides the ability for a program to split itself into smaller segments. For example, one thread takes care of the user interface while another task re-calculates data in the background. Because each thread has access to all the variables and memory of the running program there is a need to ensure that they play together nicely. This is solved by adding inter thread communication and synchronization.

To create a new thread, we need to include System.Threading which provides the Thread class. From there on creating a new thread involves only a few steps:

1. Create a new instance of Thread [new Thread()]
2. Pass the code starting point point of the thread in its creation [myThread = new Thread( new ThreadStart( myObj.EntryPoint ) )]
3. Start the Thread [myThread.Start()]

The ThreadStart object mentioned in the Thread constructor is actually a delegate. It defines the format that the entry point function should follow : a function returning “void” that takes no parameters. (Alternatively there is also ParameterizedThreadStart which allows you pass a parameter).

C# makes it possible to name every Thread Object and we use this to give a name to each of the Threads we create.

Each thread is then started and asked to print its name. In total there will be three messages printed: by the main thread and the two threads we create in the example. Also notice that Thread.CurrentThread provides a reference to the currently executing thread.

using System;
using System.Threading;

namespace TheadingDemo1
{

    class ThreadExample
    {

        static void ShowThreadName()
        {
            Console.WriteLine("Current Thread: {0}",Thread.CurrentThread.Name);
        }

        public void ThreadStartPoint()
        {
            ShowThreadName();
        }

        public static void Main()
        {
            // As we enter the program with this thread -- lets call it "main"
            Thread.CurrentThread.Name = "Main";

            // Create two new instances of the current class
            ThreadExample instance1 = new ThreadExample();
            ThreadExample instance2 = new ThreadExample();

            // We need to setup their starting points, which is the same for both
            Thread thread1 = new Thread( new ThreadStart( instance1.ThreadStartPoint ));
            Thread thread2 = new Thread( new ThreadStart( instance2.ThreadStartPoint ));

            // Name each thread
            thread1.Name = "Instance1";
            thread2.Name = "Instance2";

            // Start both threads
            thread1.Start();
            thread2.Start();

            // Display the name of the current (main) thread
            ShowThreadName();           

            Console.WriteLine("Ending Main Tread");
        }

    }

}

The above example will print something similar to the following:

Current Thread: Main
Current Thread: Instance2
Ending Main Tread
Current Thread: Instance1

Note that in this case Instance1 kept on running although the program had already ended. That is because C# makes a distinction between two different kinds of tasks: background tasks and foreground tasks. Foreground threads (the default) will keep the main thread from ending as long as there is still at least one other thread active. Background tasks die when the programs main thread ends.

To see this effect , modify the above code by adding below line 35:

thread1.IsBackground = true;
thread2.IsBackground = true;

Many hands make light work

In the above example we needed to create every task separately, but that becomes tedious if we need to create many. Using the ThreadPool class we only have to queue the actual work, which it will then allocate this to available tasks as required.

A simple example: we have a busy web server and as requests come in we need to serve them. But each request will probably take some time to complete as each thread will need to wait for disk IO and calculations to complete. The ThreadPool class will find an idle task for each new request and if it runs out of idle tasks the ThreadPool will simply create more threads.

Broken down in steps:

1. We create 1000 instances of WebRequest
2. Each is passed to the ReceiveRequest method
3. The main thread starts waiting until everything has completed
4. ReceiveRequest uses ThreadPool.QueueUserWorkItem to queue each request
5. ThreadPool goes over each queue item, allocates it to a task which then calls “HandleRequest” for each
6. The main thread is woken up

We do some more things to smooth communication but first have a look at the code example:

namespace TheadingPool1
{
    // WebRequest
    //
    // This is a simple class that pretends to be a request received from the internet
    // Here it only need to carry a unique number so that we can identify it.

    class WebRequest
    {
        public int id;
        public WebRequest(int id)
        {
            this.id = id;
        }
    }

    // WebServer
    //
    // Our little webserver "receives" requests from the internet, and then queues them
    // The ThreadPool mechanism will allocate a new thread to

    class WebServer
    {
        public int QueueLength;
        ManualResetEvent WaitEvent;
        bool       WaitForComplete;

        public WebServer()
        {
            this.QueueLength = 0;
            this.WaitForComplete = false;
        }

        public void WaitForCompleted()
        {
            // We lock the class to ensure that nobody modifies the QueueLength
            // while we are inspecting it.
            lock(this)
            {
                if (this.QueueLength==0) return;
                WaitEvent = new ManualResetEvent(false);
                WaitForComplete = true;
            }
            // Outside the lock block as we need to free the lock!
            WaitEvent.WaitOne();
        }

        // ReceiveRequest
        //
        // Our webserver has received a request, we use the ThreadPool.QueueWorkItem
        // to find / create a thread that will handle this request.
        //
        // Actual handling of the request is done by the "HandleRequest" function

        public void ReceiveRequest(WebRequest req)
        {
            // This is very simple, there is no need to define the thread pool.
            // We just add work
            ThreadPool.QueueUserWorkItem(new WaitCallback(HandleRequest), req);
            this.QueueLength++;
        }

        public void HandleRequest(Object obj)
        {
            // Notes:
            //
            // 1. Thread.CurrentThread.GetHasCode provides a unique identifies for each thread
            // 2. We need to cast the generic object parameter to our web request

            Console.WriteLine("Thread {0} handles request {1}",
                              Thread.CurrentThread.GetHashCode(),
                              ((WebRequest) obj).id);

            // 3. We add sleep to simulate a task taking some time, otherwise its likely that
            //    a single task is able to handle all our requests in order.

            Thread.Sleep(100);

            // 4. Finished, we reduce one item from the queue. If the queue is empty we need
            //    to free the main program

            lock(this)
            {
                this.QueueLength--;
                if (this.QueueLength == 0 && this.WaitForComplete)
                {
                    this.WaitEvent.Set();
                }
            }
        }

        public static void Main()
        {
            WebServer server = new WebServer();

            // "Receive" 1000 requests from the internet and queue them
            for (int Lp = 0; Lp < 1000; Lp ++)
                server.ReceiveRequest( new WebRequest( Lp ));

            // We wait until the queue has emptied
            server.WaitForCompleted();

            Console.WriteLine("Main Thread has completed");
        }
    }
}

So how do we know if the work has been completed?

The Webserver class keeps track of the number of outstanding tasks and as soon as this reaches zero the task completing the last work item frees the main task from its wait.

This is done by using a ManualResetEvent.

Any task which calls WaitOne() on a ManualResetEvent will be suspended until another task frees it by calling Set(). It is possible for more tasks to wait for the same ManualResetEvent, but in our example only the main task needs to wait.

When our HandleRequest method discovers that it has handled the last outstanding request it calls Set() freeing the main task to end the program.

We need to avoid interruption

As multiple tasks are executing the code at the same time several critical sections might be updated by more than one task at the same time.

In our example the critical code is the code which maintains the QueueLength variable. Every time a task is completed it reduces QueueLength by one, and every time a task is added QueueLength is increased. But what happens if a task reduces the QueueLength while another one is checking if its zero?

There are several things that could go unexpectedly wrong, which is something called a “race condition”.

We would like to ensure that these statements are executed in order and without interruption — as an essentially atomic operation.

C# allows you to synchronize tasks by exclusively locking a code segment with the lock() statement. Only one task can enter this segment of the code. All others tasks reaching it will be suspended until the first task has completed it.

lock(this)
{
   // The code between these brackets can only be entered by one task modifying this instance
   // of the class
}

In the example above we have protected each critical section that modifies QueueLength by placing it in an exclusive block.

This is the ABC of building a threaded application in C#. In another article I hope to go further into the details of inter thread and inter process communication.

Image credit: chefranden

This is a post from Martijn's C# Coding Blog.

Version 2 of C# introduced something called a “generic”. In this article we will look into what a generic is, and why you would want to use them. Generics are similar to a concept frequently used in C++ Templates. They allow you to better re-use your code while at the same time providing more information to the compiler on what should be allowed, and what shouldn’t.

The code below give an example on how generics can improve the compilers knowledge of what it should accept. A very basic vector array class is defined to accept only strings.

This code is just for illustration of the Generics concept. Normally you would just use the build in C# Array type to obtain the same Array functionality.

    class Vector
    {
        string[] elements;

        public Vector(int maximum_elements)
        {
            elements = new string[maximum_elements];
        }

        public string this[int i]
        {
            get {return elements[i];}
            set {elements[i] = value;}
        }
    }

    class MainClass
    {
        public static void Main(string[] args)
        {
            Vector test = new Vector(20);

            test[1] = "42";
            // The compiler catches this, we cannot convert an integer to string
            // test[2] = 123;
            string theAnswer = test[1];
            Console.WriteLine("The answer is {0}" , theAnswer );
        }
    }

The above vector array code can only be used for storing strings,limiting our re-use of the code. What to do if we would like to store integers instead?

We can improve the code by making it more abstract by replacing the int definitions with the more general object tag.

It is now possible to store all kinds of elements (not just integers) in the Vector. But because the compiler no longer knows what type is stored in the Vector, it allows all kinds. Worse, we now need to cast all return values to our main type (string) as the compiler cannot implicitly convert objects to strings.

    class Vector
    {
        object[] elements;

        public Vector(int maximum_elements)
        {
            elements = new object[maximum_elements];
        }

        public object this[int i]
        {
            get {return elements[i];}
            set {elements[i] = value;}
        }
    }

    class MainClass
    {
        public static void Main(string[] args)
        {
            Vector test = new Vector(20);

            test[1] = "42"; // The Vector doesn't know about our type
            test[2] = 123;// So both strings and numbers are OK, allowing for mistakes
            string theAnswer = (string) test[1];// We are also forced to cast (object) to (string)
            Console.WriteLine("The answer is {0}" , theAnswer );
        }
    }

Generics help out by allowing us to define our Vector as an abstract type. Note the <T> given in the class definition of the Vector. It replaces all instances where we would have said “string”, “int” or “object” previously.

    class Vector<T>
    {
        T[] elements;

        public Vector(int maximum_elements)
        {
            elements = new T[maximum_elements];
        }

        public T this[int i]
        {
            get {return elements[i];}
            set {elements[i] = value;}
        }
    }

    class MainClass

    {
        public static void Main(string[] args)
        {
            Vector<string> test= new Vector<string>(20);

            test[1] = "42";
            // The compiler catches this, we cannot convert an integer to string
            // test[2] = 123;
            string theAnswer = test[1];
            Console.WriteLine("The answer is {0}" , theAnswer );
        }
    }

The above example removes the need to typecast any returned value, the compiler is already aware of the correct type (”string” in our example). The code is also type-safe as it is no longer possible to assign the wrong type to an element in the Vector and finally, the above Vector code can be re-used to hold any kind of variable.

We could re-use the final code to create any kind of container; suitable for holding only a single type.

Vector<int>    test1 = new Vector<int>(20);
Vector<string> test2 = new Vector<string>(20);
Vector<float>  test3 = new Vector<float>(20);

Image credit: bucklava

This is a post from Martijn's C# Coding Blog.