I think a good C# developer needs to get a handle on .NET generics.  Most of the advanced features in C# deal with lots of generics and having a very good understanding of generics will help considerably, most especially when dealing with generic delegates.  So here in this post, we will review generics.

Generic type definitions can be methods, classes, structures, and interfaces.

// an example generic class
public class MyGenericClass<T>
{
    public T MyProperty;
}

The placeholders (e.g. <T>) are called generic type parameters, or type parameters.

You specify the actual types to substitute for the type parameters during instantiation.

// instantiate generic class with string type
MyGenericClass<string> c = new MyGenericClass<string>();

When instantiated, a generic type definition becomes a constructed generic type.

You can place limits or constraints on generic type parameters.

// limit type to value types except Nullable
public class MyGenericClass<T> where T : struct {/*...*/}

// limit type to reference types which can include classes,
//  interfaces, delegates, and array types
public class MyGenericClass<T> where T : class {/*...*/}

// limit type to types with public parameterless constructor
// must be specified last in multiple constraints
public class MyGenericClass<T> where T : new() {/*...*/}

// limit type to specified base class or to types derived from it
public class MyGenericClass<T> where T : MyBaseClass {/*...*/}

// limit type to specified interface or to types that implement it
public class MyGenericClass<T> where T : IMyInterface {/*...*/}

// limit type to specified type parameter    

// in a generic member function, it limits its type to the type 
//  parameter of the containing type
public class MyGenericClass<T>
{
    void MyMethod<U>(List<U> items) where U : T {/*...*/}
}

// in a generic class, it enforces an inheritance relationship
//  between the two type parameters
public class MyGenericClass<T, U> where U : T {/*...*/}

// type parameter can have multiple constraints 
//  and constraints can also be generics
//  and constraints can be applied to multiple type parameters
public class MyGenericClass<T, U> 
    where T : MyClass, IMyInterface, System.IComparable<T>, new()
    where U : struct
{
    // ...
}

A method is considered a generic method definition if it has two parameter lists: a list of type parameters enclosed in <> and a list of formal parameters enclosed in ().  A method belonging to a generic or non-generic type does not make the method generic or non-generic.  Only the existence of the two parameter lists will make the method generic, as in the example below.

public class MyClass
{
    // a generic method inside a non-generic class
    T MyGenericMethod<T>(T arg) {/*...*/}
}

A type nested in a generic type is considered by CLR to be generic even if it doesn’t have generic type parameters of its own.  When you instantiate a nested type, you need to specify the type arguments for all enclosing generic types.

// generic type
public class MyGenericType<T, U>
{
    // nested type
    public class MyNestedType
    {
        // ...
    }
}

// ... somewhere in code you instantiate the nested type   
MyGenericType<string, int>.MyNestedType nt = 
    new MyGenericType<string, int>.MyNestedType();

The following are some common generic collection counterparts provided by the .NET framework:

• Dictionary<TKey, TValue> which is the generic version of Hashtable.  It uses KeyValuePair<TKey, TValue> for enumeration instead of DictionaryEntry.
• List<T> which is the generic version of ArrayList.
• Queue<T> and Stack<T> which is the generic versions of collections with same names.
• SortedList<TKey, TValue> which is a hybrid of a dictionary and list, just like it’s nongeneric version of same name.
• SortedDictionary<TKey, TValue> which is a pure dictionary, and LinkedList<T>.  Both don’t have nongeneric versions.
• Collection<T> which is a base class for generating custom collection types, ReadOnlyCollection<T> which provides read-only collection from any type implementing IList<T>, and KeyedCollection<TKey, TItem> for storing objects containing their own keys.

There are also generic interface counterparts for ordering and equality comparisons and for shared collection functionality:

• System.IComparable<T> and System.IEquatable<T> which define methods for ordering comparisons and equality comparisons.
• IComparer<T> and IEqualityComparer<T> in the System.Collections.Generic namespace, which offer alternative way for types that do not implement System.IComparable<T> and System.IEquatable<T>.  They are used by methods and constructors of many of the generic collection classes.  An example would be passing a generic IComparer<T> object to the constructor of SortedDictionary<TKey, TValue> to specify a sort order.  Generic classes Comparer<T> and EqualityComparer<T> are their base class implementations.
• ICollection<T> which provides basic functionality for adding, removing, copying, and enumerating elements in a generic collection type.  It inherits from IEnumerable<T> and the nongeneric IEnumerable.
• IList<T> which extends ICollection<T> with methods for indexed retrieval.
• IDictionary<TKey, TValue> which extends ICollection<T> with methods for keyed retrieval.  Generic dictionary types also inherit from nongeneric IDictionary.
• IEnumerable<T> which provides a generic enumerator structure used by foreach.  It inherits from nongeneric IEnumerator because MoveNext and Reset methods appear only on the nongeneric interface.  This means consumer of the nongeneric interface can also consume the generic interface because the generic interface provides for nongeneric implementation.

You also have generic delegates in .NET framework.  An example is the EventHandler<TEventArgs> which you can use in handling events with custom event arguments.  No need to declare your own delegate type for the event.  If you need to brush up on events and delegates, see my post on raising events and nongeneric delegates.

public event EventHandler<PublishedEventArgs> Published;

There are also a bunch of useful generic delegates available for manipulating arrays and lists

• Action<T> which allows you to perform action on an element by passing an Action<T> delegate instance and an array to the generic method Array.ForEach<T>.  You can also pass an Action<T> delegate instance to the nongeneric method List<T>.ForEach.
• Predicate<T> which allows you to specify a search criteria to Array’s Exists<T>, Find<T>, FindAll<T>, and so on and also to List<T>’s Exists, Find, FindAll, and so on.
• Comparsion<T> which allows you to provide a sort order.
• Converter<TInput, TOutput> which allows you to convert between two types of arrays or lists.

Ok so that’s all we have for generics.  Just a review of the basics that a C# developer need to know.

There are two different methods of retrieving the list of Primary Keys and Foreign Keys from database.

Method 1: INFORMATION_SCHEMA

SELECT
DISTINCT
Constraint_Name AS [Constraint],
Table_Schema AS [Schema],
Table_Name AS [TableName]
FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
GO

Method 2: sys.objects

SELECT OBJECT_NAME(OBJECT_ID) AS NameofConstraint,
SCHEMA_NAME(schema_id) AS SchemaName,
OBJECT_NAME(parent_object_id) AS TableName,
type_desc AS ConstraintType
FROM sys.objects
WHERE type_desc IN ('FOREIGN_KEY_CONSTRAINT','PRIMARY_KEY_CONSTRAINT')
GO


I am often asked about my preferred method of retrieving list of Primary Keys and Foreign Keys from database. I have a standard answer. I prefer method 3, which is querying sys database. The reason is very simple. sys. schema always provides more information and all the data can be retrieved in our preferred fashion with the preferred filter.

Let us look at the example we have on our hand. When Information Schema is used, we will not be able to discern between primary key and foreign key; we will have both the keys together. In the case of sys schema, we can query the data in our preferred way and can join this table to another table, which can retrieve additional data from the same.

Let us play a small puzzle here. Try to modify both the scripts in such a way that we are able to see the original definition of the key, that is, create a statement for this primary key and foreign key.

If I get an appropriate answer from my readers, I will publish the solution on this blog with due credit.

Hashtable. This optimizes lookups. It computes a hash of each key you add. It then uses this hash code to look up the element very quickly.
Don’t use this. It is an older .NET Framework type. It is slower than the generic Dictionary type. But if an old program uses Hashtable, it is helpful to know how to use this type.Dictionary
First example. We create a Hashtable with a constructor. When it is created, the Hashtable has no values. We directly assign values with the indexer, which uses the square brackets.

Next:The example adds three integer keys, with one string value each, to the Hashtable object.

Result:The program displays all the DictionaryEntry objects returned from the enumerator in the foreach-loop.

WriteLine:The WriteLine call contains a format string that displays the key-value pairs with a comma.

Based on: .NET 4.5

C# program that adds entries to Hashtable

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	Hashtable hashtable = new Hashtable();
	hashtable[1] = "One";
	hashtable[2] = "Two";
	hashtable[13] = "Thirteen";

	foreach (DictionaryEntry entry in hashtable)
	{
	    Console.WriteLine("{0}, {1}", entry.Key, entry.Value);
	}
    }
}

Output

13, Thirteen
2, Two
1, One

Foreach. You can loop through the Hashtables by using the DictionaryEntry type in a foreach-loop. You can alternatively get the Keys collection and copy it into an ArrayList.Foreach
DictionaryEntry. A DictionaryEntry contains two objects: the key and the value. This is similar to a KeyValuePair from the newer generic Dictionary.DictionaryEntryKeyValuePair
ContainsKey. You will want to call ContainsKey on your Hashtable with the key contents. This method returns true if the key is found, regardless of the value.

Also:Contains works the same way. We see an example of using the indexer with the square brackets.

C# program that uses Contains method

using System;
using System.Collections;

class Program
{
    static Hashtable GetHashtable()
    {
	// Create and return new Hashtable.
	Hashtable hashtable = new Hashtable();
	hashtable.Add("Area", 1000);
	hashtable.Add("Perimeter", 55);
	hashtable.Add("Mortgage", 540);
	return hashtable;
    }

    static void Main()
    {
	Hashtable hashtable = GetHashtable();

	// See if the Hashtable contains this key.
	Console.WriteLine(hashtable.ContainsKey("Perimeter"));

	// Test the Contains method. It works the same way.
	Console.WriteLine(hashtable.Contains("Area"));

	// Get value of Area with indexer.
	int value = (int)hashtable["Area"];

	// Write the value of Area.
	Console.WriteLine(value);
    }
}

Output

True
True
1000

Objects. An indexer is a property that receives an argument inside square brackets. The Hashtable implements indexers. It returns plain objects so you must cast them.Indexer
Multiple types. The example here adds string keys and int keys. Each of the key-value pairs has different types. You can put them all in the same Hashtable.

Warning:This code might throw exceptions. Casting is a delicate operation. It is hard to get right.

Info:If the cast was applied to a different type, the statement could throw an InvalidCastException. We avoid this with “is” or “as.”

C# program that uses multiple types

using System;
using System.Collections;

class Program
{
    static Hashtable GetHashtable()
    {
	Hashtable hashtable = new Hashtable();

	hashtable.Add(300, "Carrot");
	hashtable.Add("Area", 1000);
	return hashtable;
    }

    static void Main()
    {
	Hashtable hashtable = GetHashtable();

	string value1 = (string)hashtable[300];
	Console.WriteLine(value1);

	int value2 = (int)hashtable["Area"];
	Console.WriteLine(value2);
    }
}

Output

Carrot
1000

Cast. You can use the as-operator to attempt to cast an object to a specific reference type. If the cast does not succeed, the result will be null.Null

Is:You can also use the is-operator. This operator returns true or false based on the result.

Is

As:With Hashtable, you can reduce the number of casts by using the as-operator. This is a performance warning given by FxCop.

AsFxCop

C# program that casts Hashtable values

using System;
using System.Collections;
using System.IO;

class Program
{
    static void Main()
    {
	Hashtable hashtable = new Hashtable();
	hashtable.Add(400, "Blazer");

	// This cast will succeed.
	string value = hashtable[400] as string;
	if (value != null)
	{
	    Console.WriteLine(value);
	}

	// This cast won't succeed, but won't throw.
	StreamReader reader = hashtable[400] as StreamReader;
	if (reader != null)
	{
	    Console.WriteLine("Unexpected");
	}

	// You can get the object and test it.
	object value2 = hashtable[400];
	if (value2 is string)
	{
	    Console.Write("is string: ");
	    Console.WriteLine(value2);
	}
    }
}

Output

Blazer
is string: Blazer

Keys, values. We can loop over keys and values, or store them in an ArrayList. This example shows all the keys, then all the values, and then stores the keys in an ArrayList.

Note:This Hashtable example uses the Keys property. This property returns all the keys.

Keys:The first loop in the program loops over the collection returned by the Keys instance property on the Hashtable instance.

Values:The second loop in the program shows how to enumerate only the values in the Hashtable instance.

Console.WriteLine

Copy:We create a new ArrayList with the copy constructor and pass it the Keys (or Values) property as the argument.

ArrayList

C# program that loops over Keys, Values

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	Hashtable hashtable = new Hashtable();
	hashtable.Add(400, "Blaze");
	hashtable.Add(500, "Fiery");
	hashtable.Add(600, "Fire");
	hashtable.Add(800, "Immolate");

	// Display the keys.
	foreach (int key in hashtable.Keys)
	{
	    Console.WriteLine(key);
	}

	// Display the values.
	foreach (string value in hashtable.Values)
	{
	    Console.WriteLine(value);
	}

	// Put keys in an ArrayList.
	ArrayList arrayList = new ArrayList(hashtable.Keys);
	foreach (int key in arrayList)
	{
	    Console.WriteLine(key);
	}
    }
}

Output

800       (First loop)
600
500
400
Immolate  (Second loop)
Fire
Fiery
Blaze
800       (Third loop)
600
500
400

Keys and values, notes. The Keys and Values public accessors return a collection of the keys and values in the Hashtable at the time they are accessed.

However:If you need to look at all the keys and values in pairs, it is best to enumerate the Hashtable instance itself.
Count, Clear. You can count the elements in a Hashtable with the Count property. The example also shows using the Clear method to erase all the Hashtable contents.

Tip:An alternative to Clear() is to reassign your Hashtable reference to a new Hashtable().

Note:This example shows how to use the Count property. This property returns the number of elements.

First:We add data to the Hashtable. It captures the Count, which is 4. It then uses Clear on the Hashtable, which now has 0 elements.

C# program that uses Count

using System;
using System.Collections;

class Program
{
    static void Main()
    {
	// Add four elements to Hashtable.
	Hashtable hashtable = new Hashtable();
	hashtable.Add(1, "Sandy");
	hashtable.Add(2, "Bruce");
	hashtable.Add(3, "Fourth");
	hashtable.Add(10, "July");

	// Get Count of Hashtable.
	int count = hashtable.Count;
	Console.WriteLine(count);

	// Clear the Hashtable.
	hashtable.Clear();

	// Get Count of Hashtable again.
	Console.WriteLine(hashtable.Count);
    }
}

Output

4
0

Count property, notes. Count returns the number of elements in the Hashtable. This property does not perform lengthy computations or loops.

Note:MSDN states that, for Count, “retrieving the value of this property is an O(1) operation.”

Time:This property is a constant-time accessor. It returns an integer and is a simple accessor with low resource demands.
Benchmark. We test the Hashtable collection against the Dictionary. The benchmark first populates an equivalent version of each collection.

Then:It tests one key that is found and one that is not found. It repeats this 20 million times.

Hashtable used in benchmark: C#

Hashtable hashtable = new Hashtable();
for (int i = 0; i < 10000; i++)
{
    hashtable[i.ToString("00000")] = i;
}

Dictionary used in benchmark: C#

var dictionary = new Dictionary<string, int>();
for (int i = 0; i < 10000; i++)
{
    dictionary.Add(i.ToString("00000"), i);
}

Statements benchmarked: C#

hashtable.ContainsKey("09999")
hashtable.ContainsKey("30000")

dictionary.ContainsKey("09999")
dictionary.ContainsKey("30000")

Benchmark of 20 million lookups

Hashtable result:  966 ms
Dictionary result: 673 ms

Results, benchmark. Hashtable is slower than the Dictionary code. I calculate that Hashtable here is 30% slower. This means that for strongly-typed collections, the Dictionary is faster.
Constructors. The 15 overloaded constructors provide ways to specify capacities. They let you copy existing collections. You can also specify how the hash code is computed.Constructor
A summary. Hashtable is an older collection that is obsoleted by the Dictionary collection. Knowing how to use it is critical when maintaining older programs. These programs are important.

The following are Unit Test best practices and guidelines:

1. Test one object or class per unit test class.
   Yes, you should refactor your code if you cannot test one class only.
2. Name your test class after the class it tests.
   If you have a class named SomeClassY, then your test class should be named SomeClassY_Tests.
3. Perform one test per test function.
   The test class can have as many functions as you need. Perform one test per function. That doesn’t mean one Assert call. Multiple assertions might be needed to perform one test.  Think of it this way. When a test fails, you should know exactly what failed and why just because of which test function failed.
4. A unit test should run on the Build and Continuous Integration (CI) systems.
   Unit tests are there to help you succeed and prevent you from failing. If they run rarely, they rarely help. They should run every time you check in code and every time your build kicks off. You should be automatically notified if any code you wrote breaks an existing Unit Test.
5. A unit test should never alter the system in any way.
   Don’t touch files, databases, registry, network, etc… A test that does so is a functional test not a Unit Test. If an object cannot be tested without touching the system, refactor the object to use an Interface (and if needed a wrapper) for interacting with the system so such can be faked, or mocked with a tool such as RhinoMocks or MOQ. This is important because if a Unit Test is running on the Build or CI system, you could actually introduce a change to the system that hides a bug and allows the bug to exist in a released product.
6. Make the test function names self documenting.
   This means if you want to test passing in a bool to FunctionX you might call your test functions something like this:
   FunctionX_True_Test()
   FunctionX_False_Test()
   Think of it this way. When a test fails, you should know exactly what failed and why just because of the function name.
7. Never assume 100% code coverage means 100% tested.
   For example, 100% coverage of a function that takes a string as a parameter might be 100% tested with one test. However, you may need to test passing in at least five string instances to avoid all types of bugs: expected string, unexpected string, null, empty, white space, and double-byte strings. Similarly a function that takes a bool parameter should be tested with both true and false passed in.
8. Test in the simplest way possible.
   Don’t elaborate, don’t add extra code. Just make a valid test as small as possible. Warning! That doesn’t mean you can forget the best practices and guidelines above. For example, if the simplest way is to test everything in one function do NOT do it. Follow the best practices and guidelines.
9. Get training and keep learning about Unit Testing.
   You won’t do it correctly without training and continued learning. It doesn’t matter if you do your own research and train yourself by reading online articles, blog posts, or books. Just get yourself trained and keep learning. There are many test frameworks, mocking frameworks, wrappers (such as System Wrapper), and encapsulation issues, and without training you may end up with Unit Tests that are not maintainable. You will find many opinions about best practices, some matter, some don’t, but you should know each side of the opinions and why those opinions exist whether you agree with them or not (this list included).

I hope this list helps you.