Black Belt C# Series - Syntax
The Black Belt C# series aims to uncover powerful but lesser-known features of the C# language. Each article introduces a few of these features and shows you how to use them to take your programming to the next level.
The “??” Operator
This granule of syntactical sugar, known as the the “Null Coalescing Operator”, provides a quick way to check and react to null values. As an example, lets say we have a widget name which came from an external source. Programming defensively, it’s always good idea to check reference types for null before working with them. Here’s an example of the code that may be written without using the operator:
1: string WidgetName = DivineWidgetNameFromEther();
2:
3: if (WidgetName != null)
4: {
5: System.Diagnostics.Debug.WriteLine(WidgetName);
6: }
7: else
8: {
9: System.Diagnostics.Debug.WriteLine("WidgetName is null");
10: }
1: string WidgetName = DivineWidgetNameFromEther();
2:
3: System.Diagnostics.Debug.WriteLine(WidgetName ?? "WidgetName is null");
This, vastly superior version, produces identical output to the first. If WidgetName is not null, then it’s simply written to the output window. However, if WidgetName does happen to be null, “WidgetName” is null” is safely written instead. This is a great way to unobtrusively improve quality in your program without sacrificing readability.
Black Belt Tip: Lazy Instantiation Made Easy
Leverage the null coalescing operator to achieve lazy instantiation with manually implemented properties:
1: private List<Widget> _Widgets = null;
2: public List<Widget> Widgets
3: {
4: get { return _Widgets ?? (_Widgets = new List<Widget>()); }
5: }
Automatic Properties
Auto-Implemented properties are a nice shorthand (C# 3+) for expressing a public property and a private (although inaccessible) field… without having to type all of that out. Have a look:
1: /// <summary>
2: /// This is a valid property and NOT a field.
3: /// </summary>
4: private string WidgetDescription { get; set; }
This is a perfectly valid property, backed by a private field that is created automatically but is inaccessible. Here is the disassembly:
1: .property instance string WidgetDescription
2: {
3: .get instance string BlackBeltCSharp.Form1::get_WidgetDescription()
4: .set instance void BlackBeltCSharp.Form1::set_WidgetDescription(string)
5: }
6:
7:
8: .field private string <WidgetDescription>k__BackingField
9: {
10: .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
11: }
You can designate a different scope for the getter and for the setter, without leaving automatic properties. For Example:
1: public string WidgetDescription { get; private set; }
Advanced Generics
Taking advantage of generics, introduced in .NET 2.0, is a great way to improve your productivity while layering on type-safety and added performance benefits (up to 200% when working with value types such as integers). To review, here is a sample generic method and usage:
Sample Generic Method
1: /// <summary>
2: /// Selects and returns an item at (pseudo)random from the supplied list
3: /// </summary>
4: /// <typeparam name="T">Any Type</typeparam>
5: /// <param name="FromList">Source list from which to pick an item from</param>
6: /// <returns>(pseudo)Randomly selected item</returns>
7: private T SelectRandom<T>(List<T> FromList)
8: {
9: Debug.Assert(FromList != null, "FromList (of type " + typeof(T).Name + ") is null.");
10:
11: //Picks a pseudo-random index in "FromList"
12: int RandomlySelectedIndex =
13: new Random((int)(DateTime.Now.Ticks % 0x7FFFFFFF)).Next(FromList.Count);
14:
15: //Returns item at randomly chosen index
16: return FromList[RandomlySelectedIndex];
17:
18: }
Sample Usage
1: List<String> Names = new List<String>() { "Daniel Dennett", "John Locke", "Saul Kripke" };
2: List<int> Numbers = new List<int>() { 2, 5, 7 };
3:
4: Debug.WriteLine("Read " + SelectRandom<int>(Numbers) +
5: " books from " + SelectRandom<string>(Names));
The usage outputs something like “Read 7 books from John Locke”. The important thing to notice is the use of the same generic “SelectRandom” method for both integers and strings.
Type Inference
It’s possible for the c# compiler to infer the type to be used. For example, this is perfectly legal:
1: Debug.WriteLine("Read " + SelectRandom(Numbers) +
2: " books from..." + SelectRandom(Names));
Where T : new()
This special constraint limits acceptable types to those which feature a public, parameterless constructor. This allows for some really special syntax inside a generic class. Have a look:
1: class ConstrainedGenericClass<T> where T : new()
2: {
3: private T NewItemOfTypeT = new T();
4: }
Using the “new()” constraint unlocks the ability to easily instantiate a new version of the specified class type. This is just the tip of the iceberg, for a complete list of constraints, visit:
http://msdn.microsoft.com/en-us/library/6b0scde8(VS.80).aspx
Currying
Likely the most advanced and confusing topic surrounding generics in c#, currying is the process of distributing an argument list over several functions, instead of one. For example, instead of having one function that takes three arguments, you can have three functions taking one argument, each building on the next. Let me show you a few examples:
Example Without Currying
1: private void DoWork()
2: {
3: //Outputs 11
4: Debug.WriteLine(AddNumbers(1, 3, 7));
5: }
6:
7: //Returns sum of three integers
8: private int AddNumbers(int X, int Y, int Z)
9: {
10: return X + Y + Z;
11: }
Example With Currying
1: private void DoWork()
2: {
3: var CurriedNumberAdder = Curry(AddNumbersWork);
4:
5: //Outputs 11
6: Debug.WriteLine(CurriedNumberAdder(1)(3)(7));
7: }
8:
9: Func<int,int,int,int> AddNumbersWork = (X, Y, Z) => X + Y + Z;
10:
11: //Standard Curry Function
12: private Func<T1, Func<T2, Func<T3, T4>>> Curry<T1, T2, T3, T4>(Func<T1, T2, T3, T4> function)
13: {
14: return a => b => c => function(a, b, c);
15: }
If you haven’t yet delved into functional programming then this example may be confusing and the benefit may not be immediately obvious. What’s happening here is each function calls the next, while contributing its argument. This process continues until it gets to the last function (X + Y + Z), which in this case defines what should happen with the arguments that have been assembled.
There are a few interesting benefits to this massive overhead of complexity. First, it’s possible to slowly assemble the function in bits and pieces over many lines. Example:
Example of Calling One Argument at a Time
1: private void DoWork()
2: {
3: var CurriedNumberAdder = Curry(AddNumbersWork);
4:
5: //...Do Something Else Here
6:
7: var FirstResult = CurriedNumberAdder(1);
8:
9: //...Do Something Else Here
10:
11: var SecondResult = FirstResult(3);
12:
13: //Outputs 11
14: Debug.WriteLine(SecondResult(7));
15: }
This may be useful for reducing the scope and span of variables that contribute to your curried function. More importantly, by encapsulating combinations of arguments inside a variable, it opens up new possibilities for reuse:
Example Reusing Curried Functions
1: private void DoWork()
2: {
3: var CurriedNumberAdder = Curry(AddNumbersWork);
4:
5: var FirstResult = CurriedNumberAdder(1);
6: var SecondResult = FirstResult(3);
7:
8: //Outputs 5
9: Debug.WriteLine(SecondResult(1));
10:
11: //Outputs 14
12: Debug.WriteLine(SecondResult(10));
13:
14: //Outputs 104
15: Debug.WriteLine(SecondResult(100));
16: }
