Hidden Features of C#? [closed]

Question

This came to my mind after I learned the following from this question:

where T : struct

We, C# developers, all know the basics of C#. I mean declarations, conditionals, loops, operators, etc.

Some of us even mastered the stuff like Generics, anonymous types, lambdas, LINQ, ...

But what are the most hidden features or tricks of C# that even C# fans, addicts, experts barely know?

Here are the revealed features so far:

Keywords

• yield by Michael Stum
• var by Michael Stum
• using() statement by kokos
• readonly by kokos
• as by Mike Stone
• as / is by Ed Swangren
• as / is (improved) by Rocketpants
• default by deathofrats
• global:: by pzycoman
• using() blocks by AlexCuse
• volatile by Jakub Šturc
• extern alias by Jakub Šturc

Attributes

• DefaultValueAttribute by Michael Stum
• ObsoleteAttribute by DannySmurf
• DebuggerDisplayAttribute by Stu
• DebuggerBrowsable and DebuggerStepThrough by bdukes
• ThreadStaticAttribute by marxidad
• FlagsAttribute by Martin Clarke
• ConditionalAttribute by AndrewBurns

Syntax

• ?? (coalesce nulls) operator by kokos
• Number flaggings by Nick Berardi
• where T:new by Lars Mæhlum
• Implicit generics by Keith
• One-parameter lambdas by Keith
• Auto properties by Keith
• Namespace aliases by Keith
• Verbatim string literals with @ by Patrick
• enum values by lfoust
• @variablenames by marxidad
• event operators by marxidad
• Format string brackets by Portman
• Property accessor accessibility modifiers by xanadont
• Conditional (ternary) operator (?:) by JasonS
• checked and unchecked operators by Binoj Antony
• implicit and explicit operators by Flory

Language Features

• Nullable types by Brad Barker
• Anonymous types by Keith
• __makeref __reftype __refvalue by Judah Himango
• Object initializers by lomaxx
• Format strings by David in Dakota
• Extension Methods by marxidad
• partial methods by Jon Erickson
• Preprocessor directives by John Asbeck
• DEBUG pre-processor directive by Robert Durgin
• Operator overloading by SefBkn
• Type inferrence by chakrit
• Boolean operators taken to next level by Rob Gough
• Pass value-type variable as interface without boxing by Roman Boiko
• Programmatically determine declared variable type by Roman Boiko
• Static Constructors by Chris
• Easier-on-the-eyes / condensed ORM-mapping using LINQ by roosteronacid
• __arglist by Zac Bowling

Visual Studio Features

• Select block of text in editor by Himadri
• Snippets by DannySmurf

Framework

• TransactionScope by KiwiBastard
• DependantTransaction by KiwiBastard
• Nullable<T> by IainMH
• Mutex by Diago
• System.IO.Path by ageektrapped
• WeakReference by Juan Manuel

Methods and Properties

• String.IsNullOrEmpty() method by KiwiBastard
• List.ForEach() method by KiwiBastard
• BeginInvoke(), EndInvoke() methods by Will Dean
• Nullable<T>.HasValue and Nullable<T>.Value properties by Rismo
• GetValueOrDefault method by John Sheehan

Tips & Tricks

• Nice method for event handlers by Andreas H.R. Nilsson
• Uppercase comparisons by John
• Access anonymous types without reflection by dp
• A quick way to lazily instantiate collection properties by Will
• JavaScript-like anonymous inline-functions by roosteronacid

Other

• netmodules by kokos
• LINQBridge by Duncan Smart
• Parallel Extensions by Joel Coehoorn

Answer 1

Mixins. Basically, if you want to add a feature to several classes, but cannot use one base class for all of them, get each class to implement an interface (with no members). Then, write an extension method for the interface, i.e.

public static DeepCopy(this IPrototype p) { ... }

Of course, some clarity is sacrificed. But it works!

Answer 2

Not sure why anyone would ever want to use Nullable<bool> though. :-)

True, False, FileNotFound?

Answer 3

Avoid checking for null event handlers

Adding an empty delegate to events at declaration, suppressing the need to always check the event for null before calling it is awesome. Example:

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

Let you do this

public void DoSomething()
{
    Click(this, "foo");
}

Instead of this

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

Please also see this related discussion and this blog post by Eric Lippert on this topic (and possible downsides).

Answer 4

My favorite trick is using the null coalesce operator and parentheses to automagically instantiate collections for me.

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }

Answer 5

"yield" would come to my mind. Some of the attributes like [DefaultValue()] are also among my favorites.

The "var" keyword is a bit more known, but that you can use it in .NET 2.0 applications as well (as long as you use the .NET 3.5 compiler and set it to output 2.0 code) does not seem to be known very well.

Edit: kokos, thanks for pointing out the ?? operator, that's indeed really useful. Since it's a bit hard to google for it (as ?? is just ignored), here is the MSDN documentation page for that operator: ?? Operator (C# Reference)

Answer 6

From CLR via C#:

When normalizing strings, it is highly recommended that you use ToUpperInvariant instead of ToLowerInvariant because Microsoft has optimized the code for performing uppercase comparisons.

I remember one time my coworker always changed strings to uppercase before comparing. I've always wondered why he does that because I feel it's more "natural" to convert to lowercase first. After reading the book now I know why.