Generics support few types of constraints:

• Interface: Allow only types that implement specific interfaces to use your generic.
• Class/Base class: Allow only types that match or inherit from a specific base class to use your generic.
• Constructor: Require types that use your generic to implement a parameterless constructor.

Say you have a custom Interface as below

public interface IMyCustomOne
{
	string WhatsMyName();
}

and a generic method

public bool CheckNameEqualJohn<T>()
{
	return (T.WhatsMyName == "John");
}

Compiler will throw you at the instant you try to build.

To solve this, we add Where at the end

public bool CheckNameEqualJohn<T>() where T : IMyCustomOne
{
	return (T.WhatsMyName == "John");
}

Woots, compiler is now happy! The obstacle has been removed and off you go to maximize your creativity. If you need 2 constraints, how to go about it?

public class MyClass<T,U>
	where T : IMyCustomT
	where U : IMyCustomU
{
	//....
}

Some additional jargons about this constraint that will make you look cooler in front of your peers

Unbound Type Parameter
Basically this refers to the most basic way of us using generic

public class MyClass<T>
{
	//....
}

Naked Type Constraint
When a generic type parameter is used as constraint

public class MyClass<T>
{
	public void MethodOne<U>(U param) where U : T
	{
		//....
	}
}

Happy Generic'ing!

If (MyValue == "3") { //3 means ok, do some stuff }

What if one day you decide that you don't like 3 (for whatever reason) and change it to 30? You will have to find and replace the repeated value all over your project. Yes, you have the FindAndReplace function with most IDE, but holy cow, you only realize that the last couple of 3 meant something else!

So a safer way is to cast the value into appropriate enum for comparison or any other operation.

'VB.NET
dim myEnumValue as TheEnum = CType([Enum].Parse(GetType(TheEnum), _
				tempValue.ToString()), TheEnum)
If myEnumValue = TheEnum.NumberThree Then
	'..
End If

//C#
TheEnum myEnumValue = (TheEnum)Enum.Parse(typeof(TheEnum), tempValue);
if (myEnumValue == TheEnum.NumberThree) { //.. }

"Hey, that looks useful. I want it in my SuperCoolReusable library" you might say. With the power of Generic, we can put it into a common call.

'VB.NET
Public Shared Function ParseEnum(Of T)(ByVal Value As Object) As T
	Return CType([Enum].Parse(GetType(T), Value.ToString()), T)
End Function

//C#
public static ReturnType ConvertStringToEnum<ReturnType>(string Value)
{
	return (ReturnType)Enum.Parse(typeof(ReturnType), Value);
}

Another simple yet useful tip!

Answer: Ah, RegularExpression is your saviour today.

Say you have defined one pattern '{D:mmddyy}' so that you can have a dynamic date part in the string value. Your string variable :

string myValue = "My mum say i am a good boy on {D:ddMMMyyy}";

Firstly, you need to declare your pattern in regular expression format, and it should be:

string myPattern = "(?<myPat>{d:[mdy]+})";

Here we use (?<name>=pattern), which is what we called Grouping Construct to group pattern together. We easily retrieve the value with the grouping as you can see later. Once you have the pattern ready, we are ready to utilize .NET RegularExpression (RegEx)

MatchCollection colMatches = RegEx.Matches(myValue, myPattern, RegExOptions.IgnoreCase);

Note that I use RegExOptions.IgnoreCase here because I am lazy to define all cases of date-time formatting characters. And MatchCollection is used as I expect to have multiple similar patterns in my string. If you don't, you can replace it with:

Match pMatch = RegEx.Match(myValue, myPattern, RegExOptions.IgnoreCase);

If everything is ok, we should have some results.

foreach (Match pMatch in colMatches)
{
	Console.WriteLine("{0} is found at {1}", pMatch.Value, pMatch.Index);
}

pMatch.Value should give you the pattern found in the string, and pMatch.Index is the index of occurence. Once you have this information, you can do anything you can!

Extending from above, I use back similar technique to parse the matched pattern.

string PATTERN_IN_PATTERN = @"{(?<key>\w+)(:(?<pattern>\w+))?}";
Match pInnerMatch = Regex.Match(pMatch.Value,
					PATTERN_IN_PATTERN, RegexOptions.IgnoreCase);

if (pInnerMatch.Success) //if there is a match
{
	//retrieve the "key" group value
	switch (pInnerMatch.Result("${key}").ToUpper())
	{
		case "D":
			// use the "pattern" group value to format today's date
			myValue = myValue.Replace(pMatch.Value,
					DateTime.Now.ToString(pInnerMatch.Result("${pattern}")));
	}
}

The final result:

My mum say i am a good boy on 29Jan2008

Easy, right? Don't have to mess with indexes, where you need to worry about whether the count starts from 0 or 1. And it is reusable in any language! What if you have more than one patterns? Just declare a collection/array (i am sure you know how) and do the hula-loop!

Create a new Shortcut and put this in the shortcut path (single line):

"%YOUR PROGRAM FILES%\Common Files\Microsoft Shared\Help 9\dexplore.exe"
/helpcol ms-help://MS.MSDNQTR.v90.en /LaunchNamedUrlTopic DefaultPage

Coalescing Null Operator

You are probably thinking what's that. Maybe it is just me, but it is one of the cool subtle features in C# that I just discovered today. Shame on me ya. Basically you all are familiar with this:

string myStrVarB = (myStrVarA == null) ? "null string" : myStrVarA

So with coalescing null operator (??), you can shortened it to:

string myStrVarB = myStrVarA ?? "null string"

Let's see, that is saving of 17 characters. Your boss sure will praise you for that On a side note, in case you don't know, you can allow a scalar type to be null by using the nullable operator:

int? myInteger = null

yield return

Definition from MSDN: "Used in an iterator block to provide a value to the enumerator object or to signal the end of iteration". I assume you have previous knowledge with IEnumerable (or iterator), so i am not going into detail with it. The yield statement appears only inside an iterator block and returns the value that is expected by the calling foreach statement. Cut the theory and show me the example.

public static IEnumerable Power(int number, int exponent)
{
	int counter = 0;
	int result = 1;
	while (counter++ < exponent)
	{
		result = result * number;
		yield return result;
	}
}

static void Main()
{
	// Display powers of 2 up to the exponent 8:
	foreach (int i in Power(2, 8))
	{
		Console.Write("{0} ", i);
	}
}

There you go, another simple bit of my learning

Found this very easy to read yet informative post on Asynchronous Method Invocation. I admit that what i know about .NET is merely the tiny tip of what the iceberg can offer. Oh hell, life is long and learning is life long, ain't it?

Here's a summary of what i learnt:

• MethodInvoke - built in delegate in .NET that allow you to call a method that takes in no parameter
• BeginInvoke - execute the target function and return to caller instantly
• ThreadPool in .NET has a limit of 25. Avoid 'starving' the pool else be fined by performance loss
• EndInvoke - return proper values/parameters from the previous function call
• IAsyncResult - log of all datas (exceptions, return value, output parameters, etc) after execution is completed
• AsyncCallBack - used when you don't wish to wait for completion of the execution (that's the purpose of asynchronous call bah)
• Command Pattern (ICommand interface) - rather than BeginInvoke, EndInvoke, CallBack everywhere in your Main(), apply this pattern to group calls together.

That's all folks. I might not have explained everything properly, so best for you to read it yourself.

Original post