Code Contract

Normally we use Debug.Assert() for code contracts. To stop the Debug.Assert() statements from activating during unit tests, add the following to te unit tests application config file ("App.Config"):

  <?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.diagnostics>
        <assert assertuienabled="false"/> <!-- Disable Debug.Assert() when running unit tests in debug mode. -->
    </system.diagnostics>
</configuration>

Following is a code contract type class that can make code assertions without throwing an Assert dialog during an NUnit test. Also the code contracts will be logged in release. A potential product failure in the field could be traced back to a code contract failure.

using System;
using System.Diagnostics;
using System.Runtime.CompilerServices;

namespace Common.CodeContracts
{
    /// <summary>
    /// A simple code contract class to replace Debug.Assert(). It can be used in release 
    /// and will log code contract failures to the Trace output window.
    /// </summary>
    public static class RuntimeCodeContract
    {
        // Switch on the Debugger.Break when required
        public static bool DebuggerBreakOnFailure { get; set; } = false;

        public static void Requires(bool condition,
                string message,
                [CallerFilePath] string file = "",
                [CallerMemberName] string member = "",
                [CallerLineNumber] int line = 0)
        {
            if (!condition)
            {
                var msg = $"Code contract failure detected: \"{message}\" in member \"{member}\" on line {line} in file \"{file}\"";
                Trace.TraceError(msg);
                if (DebuggerBreakOnFailure)
                {
                    Debugger.Break(); // Use the call stack window to find the invoker location
                }

                //throw new InvalidOperationException(msg);
            }
        }

        public static void RequiresArgument(bool condition,
                string paramName,
                string message = "",
                [CallerFilePath] string file = "",
                [CallerMemberName] string member = "",
                [CallerLineNumber] int line = 0)
        {
            if (!condition)
            {
                var msg = $"Argument requirement failure detected: {message} \"{paramName}\" in member \"{member}\" on line {line} in file \"{file}\"";
                Trace.TraceError(msg);
                if (DebuggerBreakOnFailure)
                {
                    Debugger.Break(); // Use the call stack window to find the invoker location
                }

                //throw new ArgumentException(message, paramName);
            }
        }

        public static void RequiresArgumentNotNull(object parameter,
                string paramName,
                [CallerFilePath] string file = "",
                [CallerMemberName] string member = "",
                [CallerLineNumber] int line = 0)
        {
            if (parameter == null)
            {
                var msg = $"Argument {paramName} was null in member {member} on line {line} in file {file}";
                Trace.TraceError(msg);
                if (DebuggerBreakOnFailure)
                {
                    Debugger.Break(); // Use the call stack window to find the invoker location
                }

                //throw new ArgumentNullException(msg, paramName);
            }
        }

    }
}

It is also a good example of using the compiler attributes "CallerFilePath", "CallerMemberName", and "CallerLineNumber" for diagnostics.

C# Task Object

Task basics
Task and Thread Difference

Here are some notes that I made from these and other blogs:
Task - Specifies some work to be executed asynchronously
ContinueWith - Specifies some work to be executed asynchronously after a task has completed

In computer science terms, a Task is a future or a promise. Basically, a Task "promises" to return you a T, but not immediately

A Thread is one of many ways to fulfill that promise. But not every Task needs a Thread. If the value you are waiting for comes from the filesystem or a database or the network, then there is no need for a thread. The Task might just register a callback to receive the value when the disk is done seeking.

In particular, the Task does not say why it is that it takes such a long time to return the value. It might be that it takes a long time to compute, or it might that it takes a long time to fetch. Only in the former case would you use a Thread to run a Task. (In .NET, threads are freaking expensive, so you generally want to avoid them as much as possible and really only use them if you want to run multiple heavy computations on multiple CPUs.

Tasks can be organised in parent child relationships so that a parent task will wait for its children to complete.

Here is an example of how to start a task with a particular return type and then wait for it to finish

var someTask = Task<int>.Factory.StartNew(() => slowFunc(1, 2));
Task<int32> task = new Task<int32>(n => Sum((Int32)n), 1000);
task.Start(); // Start the task
task.Wait();  // Wait for it to finish

Here is an example of how to cancel a task.

CancellationTokenSource cts = new CancellationTokenSource();
Task<int32> t = new Task<int32>(() => Sum(cts.Token, 1000), cts.Token);
t.Start(); // Start the task
cts.Cancel(); // Cancel the task

Task<int32> t = new Task<int32>(n => Sum((Int32)n), 1000);
       t.Start();
       // notice the use of the Result property
       Task cwt = t.ContinueWith(task => Console.WriteLine(
                       "The sum is: " + task.Result));

They are very easy to use and have a lot of advantages over Threads as follows:

• You can create return types to Tasks as if they are functions.
• You can the "ContinueWith" method, which will wait for the previous task and then start the execution. (Abstracting wait)
• You can use Task.WaitAll and pass an array of tasks so you can wait till all tasks are complete.
• You can attach task to the parent task, thus you can decide whether the parent or the child will exist first.
• You can achieve data parallelism with LINQ queries.
• You can create parallel for and foreach loops
• Very easy to handle exceptions with tasks.
• Most important thing is if the same code is run on single core machine it will just act as a single process without any overhead of threads.

Disadvantage of tasks over threads:

• Not knowing what thread the task is invoked on can be a problem in itself when locking access to data so assume the worst.
• You need .Net 4.0
• Newcomers who have learned operating systems can understand threads better.

Tip:- Always use Task.Factory.StartNew method which is semantically perfect and standard. Actually, under the hood it is a slightly more efficient means to initiate the task as well.

Also can force a task to execute on the GUI thread:

// Get the UI thread's context
var context = TaskScheduler.FromCurrentSynchronizationContext();
...
Task task = Task.Factory.StartNew( () =>
   {
       // Do some work...           
   })
   // Continue on the UI thread, since this lets us update when our
   // "work" completes.
   .ContinueWith(_ => this.label1.Text = "Task Complete!", context);

OR even simpler from within the GUI do

Task task = Task.Factory.StartNew( () =>
   {
       // Do some work...           
   })
   // Continue on the UI thread, since this lets us update when our
   // "work" completes.
   .ContinueWith(_ => this.label1.Text = "Task Complete!",
       TaskScheduler.FromCurrentSynchronizationContext());

NIST 800-131A Standard Summary

Read through the NIST 800-131A document and have tried to summarise the standard here. I have excluded all time limited options for this and mention here only the standards that are deemed always acceptable.

Encryption

Triple DES Encryption is being deprecated and only 3 key triple DES is now acceptable. SKIPJACK encryption is no longer acceptable. AES Encryption has 3 approved key lengths: 128, 192 and 256.
From the following Rijndael AES differences link it seems that the AES encryption algorithm is a form of the Rijndael algorithm except that it has a fixed block size. Essentially, if you want to use Rijndael as AES you need to make sure that:

• The block size is set to 128 bits
• You are not using CFB mode, or if you are, the feedback size is also 128 bits

Digital Signatures

There are three digital signature algorithmns approved: DSA, ECDSA and RSA. It seems that for RSA that this equates to a key size of at least 2048 bits.

Random Number Generators

The following are listed as the standards currently acceptable as specified in the SP 800-90 document: HASH, HMAC, CTR, DUAL_EC.

Digital Signatures

Basically this section says that the key length must be of at least 112 bits.

Hash Functions

SHA1 is no longer acceptable for digital signature generation HOWEVER, for “… hash-only applications (e.g., hashing passwords and using SHA-1 to compute a checksum…”, it is still acceptable (see page 14, end of section 9). SHA-224/256/384/512 are all deemed acceptable for all hashing function applications.

Message Authentication Codes

HMAC based hashing functions are always acceptable when the key size is at least 112 bits

Command Line Parameter Accessors in .NET

How can strings containing white space be passed as command line parameters?
Here is the test console program:

class Program
{     
    static void Main(string[] args)
    {
        Console.WriteLine("Main(string[] args)=" + string.Join(",", args));
        Console.WriteLine("Environment.CommandLine=" + Environment.CommandLine);
        Console.WriteLine("Environment.GetCommandLineArgs()=" + string.Join(",", Environment.GetCommandLineArgs()));

        Console.WriteLine("");
        Console.WriteLine("Press any key to continue ...");
        Console.ReadKey(false);
    }
}

Using the following as command ine arguments:

Test -b:"Dummy User" "whataboutthis?" /x'Does this work' /a:another a"rgument

Produces this (the command line arguments are comma separated):
Main(string[] args)=Test,-b:Dummy User,whataboutthis?,/x'Does,this,work',/a:another,argument
Environment.CommandLine="C:\Users\...\bin\Debug\TestAccountName.vshost.exe" Test -b:"Dummy User" "whataboutthis?" /x 'Does this work' /a:another a"rgument
Environment.GetCommandLineArgs()=C:\Users\...\bin\Debug\TestAccountName.vshost.exe,Test,-b:Dummy User,whataboutthis? ,/x'Does,this,work',/a:another,argument

Looks like quotation characters "" can be used to enclose a part of a command line that contains white space, the quotation characters themselves are removed. Placing matching quotation characters around/within a command line argument ensures that it is interpreted as a single command line argument even if it contains whitespace characters. Quotation characters are stripped from the command line parameters as they are processed so they will not appear in the arguments.

Summary

Main(string[] args)	Gives access to ONLY the command line parameters themselves. Executable is NOT included as a command line parameter. Quotation marks can be used to capture a parameter or part of a parameter containing whitespace
Environment.CommandLine	Gives access to the raw command line
Environment.GetCommandLineArgs()	Gives access to ALL the command line parameters. Executable is first command line parameter. Quotation marks can be used to capture a parameter or part of a parameter containing whitespace

De Morgan's Theorem

Wikipedia has more info on this
I am always forgetting this rule:

NOT (P  OR Q) = (NOT P) AND (NOT Q)
NOT (P AND Q) = (NOT P)  OR (NOT Q) 

or in more generealised form:

NOT (P  OR Q  OR R  OR ...) = (NOT P) AND (NOT Q) AND (NOT R) AND ...
NOT (P AND Q AND R AND ...) = (NOT P)  OR (NOT Q)  OR (NOT R)  OR ...

In C#

!(P || Q) = (!P) && (!Q)
!(P && Q) = (!P) OR (!Q) 

Can be useful sometimes to improve code readability but do not use it for optimisation (let the compiler do that)

A Generic ThreadPool.QueueUserWorkItem

Found the idea here
A generic version of the "ThreadPool.QueueUserWorkItem" method. I believe that this really belongs in the .NET framework

// Generic QueueUserWorkItem implementation, the thread routine signature
public delegate void ThreadRoutine<T>(T state);

/// <summary>
/// Extensions to the ThreadPool class
/// </summary>
public static class ThreadPoolExtender
{
  /// <summary>
  /// Queue specified thread routine/work item for processing 
  /// on a thread pool thread.
  /// </summary>
  /// <typeparam name="T">Thread routine parameter type.</typeparam>
  /// <param name="state">object containing state for the thread 
  /// routine.</param>
  /// <param name="threadRoutine">Thread routine/work item to queue 
  /// that shall be executed on a thread pool thread</param>
  /// <returns>indicates success.</returns>
  public static bool QueueUserWorkItem<T>(T state, ThreadRoutine<T> threadRoutine)
  {
    return ThreadPool.QueueUserWorkItem(s => threadRoutine((T)s), state);
  }
}

Sample usage with an an anonymous object

 
res = ThreadPoolExtender.QueueUserWorkItem(
    // Anonymous type, saves defining a class type just for this call
    new { onFinishedDelegate = onFinished, Folderpath = folderPath },
    (input) => // input matches the anonymous object defined in the line above
    {   // Start worker thread work
        bool outcome = this.DoSomething(input.Folderpath);
        // In this example we callback on a delegate to indicate that 
        // the thread work is complete
        input.onFinishedDelegate(outcome); 
    }); // End worker thread work

Binary Serialization

Some binary serialization links:
Version Tolerant Serialization
Format Your Way to Success with the .NET Framework Versions 1.1 and 2.0 - Used some of the classes here to develop the BinarySerializer class below
Advanced serialization tips
Custom Serialization
Here is a sample binary serialisation class

private class BinarySerializer
{
    internal interface IGenericFormatter
    {
        T Deserialize<T>(Stream serializationStream);
        void Serialize<T>(Stream serializationStream, T graph);
    }

    internal class GenericFormatter<F> : IGenericFormatter 
     where F : IFormatter, new()
    {
        IFormatter m_Formatter = new F();

        public T Deserialize<T>(Stream serializationStream)
        {
            return (T)m_Formatter.Deserialize(serializationStream);
        }
        public void Serialize<T>(Stream serializationStream, T graph)
        {
            m_Formatter.Serialize(serializationStream, graph);
        }
    }

    internal class GenericBinaryFormatter : 
     GenericFormatter<BinaryFormatter> { }

    public void SerializeToFile<Type>(Type obj, string filePath)
    {
        IGenericFormatter formatter = new GenericBinaryFormatter();
        using (Stream stream = new FileStream(
            filePath, FileMode.Create, FileAccess.ReadWrite))
        {
            formatter.Serialize(stream, obj);
            stream.Close();
        }
    }

    public Type DeserializeFromFile<Type>(string filePath)
    {
        Type res = default(Type);
        if (File.Exists(filePath))
        {
            IGenericFormatter formatter = new GenericBinaryFormatter();
            using (Stream stream = new FileStream(
                filePath, FileMode.Open, FileAccess.ReadWrite))
            {
                res = formatter.Deserialize<Type>(stream);
                stream.Close();
            }
        }
        return res;
    }

    public byte[] SerializeToByteArray<Type>(Type obj)
    {
        byte[] res = null;
        IGenericFormatter formatter = new GenericBinaryFormatter();
        using (MemoryStream stream = new MemoryStream())
        {
            formatter.Serialize(stream, obj);
            res = stream.ToArray();
            stream.Close();
        }
        return res;
    }

    public Type DeserializeFromByteArray<Type>(byte[] bytes)
    {
        Type res = default(Type);
        if ((bytes != null) && (bytes.Length > 0))
        {
            IGenericFormatter formatter = new GenericBinaryFormatter();
            using (MemoryStream stream = new MemoryStream(bytes))
            {
                res = formatter.Deserialize<Type>(stream);
                stream.Close();
            }
        }
        return res;
    }

    public Type Clone<Type>(Type obj)
    {
        byte[] bytes = SerializeToByteArray<Type>(obj);
        Type res = DeserializeFromByteArray<Type>(bytes);
        return res;
    }
}

Can be used with this code to test binary serialisation of something

private static Type SerializeDeserialize<Type>(Type src) 
    where Type
{
    BinarySerializer bs = new BinarySerializer();
    byte[] bytes = bs.SerializeToByteArray<Type>(src);
    // Use these lines to create binary serialization files, 
    //string filePath = Path.Combine(Path.GetTempPath(), "SerialisedObject.bin");
    //File.WriteAllBytes(filePath, bytes);
    Type ds = bs.DeserializeFromByteArray<Type>(bytes);
    return ds;
}