1. Anonymous Code Scopes in Methods
It's possible to have anonymous inner scopes within your method definitions. (I'm yet to come across a non-contrived use case for this!)
void MethodWithAnonymousScope()
{
var helloPart = "Hello";
{
var worldPart = "world";
Console.WriteLine("{0} {1}", helloPart, worldPart);
}
// "worldPart" doesn't resolve in this scope
}
{
var helloPart = "Hello";
{
var worldPart = "world";
Console.WriteLine("{0} {1}", helloPart, worldPart);
}
// "worldPart" doesn't resolve in this scope
}
2. Increment/Decrement Operator Position Significance
The position of the increment (++) and decrement (--) operators is significant. In the example below, when the increment operator is used as a postfix, it returns the value of 'number' before it has been incremented. Conversely, the prefix increment operator returns the value after it has been incremented. The decrement operator works with the same logic but decrements the number.
void PlusPlusOperator()
{
var number = 0;
Console.WriteLine(number++); // Outputs zero
Console.WriteLine(++number); // Outputs two
}
{
var number = 0;
Console.WriteLine(number++); // Outputs zero
Console.WriteLine(++number); // Outputs two
}
3. The Default Keyword
The default keyword is a neat way to get the default value for a specified type. It's especially useful when working in a generic context.
void DefaultKeyword()
{
var intDefault = default(int); // default(int) == 0
var boolDefault = default(bool); // default(bool) == false
// default(string) == null (as for all reference types)
var stringDefault = default(string);
}
{
var intDefault = default(int); // default(int) == 0
var boolDefault = default(bool); // default(bool) == false
// default(string) == null (as for all reference types)
var stringDefault = default(string);
}
4. Null-Coalescing Operator
The null-coalescing operator (??) provides a succinct way of returning a default value if your reference or nullable-value type is null. In the following example, if myNullableInteger (left operand) is not null, then it's returned, else the default value for int is returned (right operand).
int NullCoalescingOperator()
{
int? myNullableInteger = SomeMethodThatCouldReturnNull();
return myNullableInteger ?? default(int);
}
{
int? myNullableInteger = SomeMethodThatCouldReturnNull();
return myNullableInteger ?? default(int);
}
5. Short-Circuit Evaluation with Boolean Operators
The logical AND (&&) and OR (||) operators are short-circuit evaluated (left to right). For example, if the left operand of a logical AND is false, the right operand is not evaluated (as the whole condition will always be false). Similarly, if the left operand of a logical OR is true, the right operand is not evaluated. This can be demonstrated by observing the output of:
void ShortCircuitEvaluation()
{
bool result;
result = LeftOperand(true) || RightOperand(false);
result = LeftOperand(false) || RightOperand(true);
result = LeftOperand(true) && RightOperand(false);
result = LeftOperand(false) && RightOperand(true);
}
bool LeftOperand(bool value)
{
Console.WriteLine("Left operand evaluated");
return value;
}
bool RightOperand(bool value)
{
Console.WriteLine("Right operand evaluated");
return value;
}
It's useful to know this so that you can safely perform multiple tests in a single if statement. In the example below, if myObject is null, the right operand is not evaluated (which is good because it'd cause a NullReferenceException).
{
bool result;
result = LeftOperand(true) || RightOperand(false);
result = LeftOperand(false) || RightOperand(true);
result = LeftOperand(true) && RightOperand(false);
result = LeftOperand(false) && RightOperand(true);
}
bool LeftOperand(bool value)
{
Console.WriteLine("Left operand evaluated");
return value;
}
bool RightOperand(bool value)
{
Console.WriteLine("Right operand evaluated");
return value;
}
if (myObject != null && myObject.SomeProperty == SomeValue)
...
Also note that if you use a single '&' and single '|' you bypass short-circuit evaluation and force the entire condition to be evaluated.
...
6. Aliases for Generic Types
You can assign an alias to a namespace but you can also assign an alias to a specific generic type to save yourself from typing the awkward generic syntax over and over again (especially useful when working with key/value pair based generic types where the value may also be a key/value pair!).
using StringList = System.Collections.Generic.List<string>;
...
void GenericAliases()
{
// Can use the alias "StringList"
// instead of List<string>
var stringList = new StringList();
stringList.Add("Hello");
stringList.Add("World");
stringList.ForEach(Console.WriteLine);
}
...
void GenericAliases()
{
// Can use the alias "StringList"
// instead of List<string>
var stringList = new StringList();
stringList.Add("Hello");
stringList.Add("World");
stringList.ForEach(Console.WriteLine);
}
7. Extension Methods on Dynamic Types
I came across this one when working with the dynamic ViewBag in ASP.NET MVC. As the title states, you cannot invoke an extension method on a type (that has the extension method defined for it and is in scope) which is dynamically typed. I have documented this one in this post (click to view). As the post shows, you have to call your extension method in the same fashion as you would call a standard static method, then pass your dynamically typed variable in as a parameter to the extension method.8. System.String supports an Indexer
The string class has a readonly (get) char indexer defined on it, thus allowing you to access characters in the string using a zero-based index.
void StringIndexer()
{
string message = "Hello, world!";
for (int i = 0; i < message.Length; i++)
{
Console.WriteLine(message[i]);
}
}
{
string message = "Hello, world!";
for (int i = 0; i < message.Length; i++)
{
Console.WriteLine(message[i]);
}
}
9. Using foreach with System.String
The string class implements the
void ForeachWithString()
{
string message = "Hello, world!";
foreach (char character in message)
{
Console.WriteLine(character);
}
}
{
string message = "Hello, world!";
foreach (char character in message)
{
Console.WriteLine(character);
}
}
10. Introspecting Code with Expression Trees
The System.Linq.Expressions.Expression class enables you to represent a code expression in a tree-based data structure that can then be used for introspection. This is a powerful feature which also then enables code modification in the expression tree (at runtime) and then subsequent compilation and execution.The following example shows how we can wrap a simple lambda expression into an Expression, introspect the expression, compile the expression (in this case returning a
void Expressions()
{
Expression<Func<int, int, int>> addExpression = (a, b) => a + b;
foreach (var param in addExpression.Parameters)
{
Console.WriteLine(
"Func Param Name: {0}, Param Type: {1}",
param.Name,
param.Type);
}
Console.WriteLine("Func return type: {0}",
addExpression.ReturnType);
Console.WriteLine("10 + 20 = {0}",
addExpression.Compile()(10, 20));
// Can also use the Invoke method on the returned Func<...>
// to aid readability
// e.g. addExpression.Compile().Invoke(10, 20);
}
You may have indirectly used expression trees if you're an ASP.NET MVC developer. The HTML helper classes make extensive use of them, for example, the Html.TextBoxFor method has an overload that accepts a single parameter of type {
Expression<Func<int, int, int>> addExpression = (a, b) => a + b;
foreach (var param in addExpression.Parameters)
{
Console.WriteLine(
"Func Param Name: {0}, Param Type: {1}",
param.Name,
param.Type);
}
Console.WriteLine("Func return type: {0}",
addExpression.ReturnType);
Console.WriteLine("10 + 20 = {0}",
addExpression.Compile()(10, 20));
// Can also use the Invoke method on the returned Func<...>
// to aid readability
// e.g. addExpression.Compile().Invoke(10, 20);
}
