We've all seen the big "macro" features in .NET, this presentation is to give praise to the "Little Wonders" of .NET -- those little items in the framework that make life as a developer that much easier!

1. James Michael Hare
2012 Visual C# MVP
Application Architect
Scottrade
August 3rd, 2012
http://www.BlackRabbitCoder.net
Twitter: @BlkRabbitCoder

2. Me:
Blog: http://www.BlackRabbitCoder.net
Twitter: @BlkRabbitCoder
Information on Scottrade Careers:
http://jobs.scottrade.com
Twitter: @scottradejobs

3. What are “Little Wonders”?
The .NET Framework is full of “macro-sized”
goodness that can help make our coding lives easier
by automating common tasks.
But, the .NET Framework also has a lot of smaller
“micro-sized” tips and tricks that can improve code.
Many developers know of most of these, but it is
often surprising how many times newer developers
don’t.
These are just a few of those items, there are many
more.

4. How do they help?
Basically, by employing these small items at the right
time, you can increase application:
Readability – some of the wonders make code much
more concise and easy to read.
Maintainability – often goes hand and hand with
readability, by removing ambiguity of the code, it is
easier to maintain without introducing errors.
Performance – a few of the little wonders can even help
increase the performance of your code (depending on
usage).

5. The Little Wonders
Syntactical Sugar Stopwatch
 Implicit Typing  BCL Class for Timing
 Auto-Properties TimeSpan
 using Blocks  static Factory Methods
 static Class Modifier Operators
Casts  Conditional
 as (TryCast)  Null-Coalescing
String Initializers
 Case-Insensitive Equals()  Object Initializers
 static IsNullOrEmpty()  Collection Initializers
 static Extension Methods
IsNullOrWhitespace()  Defining Custom Extensions
Object:  LINQ Extension Methods
 static Equals()
Path
 BCL Class for Path Handling

6. Implicit typing
So many times declarations and instantiations are
redundant:
C#:
VB:
Since declared type is same as instantiated type, can
use implicit typing:
C#:
VB:
Generally speaking, more readable since less
redundant typing.

7. Auto-Implemented Properties
Most properties simply get/set a backing field:

8. Auto-Implemented Properties
Manually creating these can make code more bloated.
Auto-Implemented properties take the pain out of
declaring simple properties:
Automatically creates a private, hidden backing field.
Automatically creates a getter that returns field.
Automatically creates a setter that assigns field.
VB allows you to assign auto-property inline.
C# allows you to have different accessibility for set and
get (i.e. you can create read-only properties).

9. Auto-Implemented Properties
C#:

10. Auto-Implemented Properties
VB:

11. Using using Blocks
When using an IDisposable instance, be careful how
you clean up:
What happens if exception is thrown before one or all
are disposed?

12. Using using Blocks
Fully protecting gets ugly fast…

13. Using using Block
Safer -- handles Dipose() even if exception.
Can stack multiple using declarations in C#.
Looks cleaner than multi-indenting.
C#:

14. Using using Block
VB doesn’t look quite as clean when “stacked”, but
still cleaner than the try/finally.
VB:

15. Static Class Modifier
Some utility classes contain only static methods:

16. Static Class Modifier
Classes with only static (Shared) methods and
properties shouldn’t be instantiated or inherited.
Could mark class sealed (NotInheritable) and
create private constructor:

17. Static Class Modifier
Instead, mark class static and will prevent
inheritance, instantiation, and instance members.
C#:
VB doesn’t have static modifier for classes:
 Modules are the VB.NET equivalent.

18. The as Cast (TryCast)
If you use is check followed by a cast, you are checking twice…
 C#:
 VB:
The as cast (TryCast in VB) lets you do a conditional cast if type
is convertible, or null if not.

19. The as Cast (TryCast)
C#:
VB:

20. Case-Insensitive String Equals
Sometimes you will see someone attempting to check
case-insensitive string equality by using ToUppper():
C#:
VB:
This creates a temp string that needs to be garbage
collected later.

21. Case-Insensitive String Equals
Instead of converting ToUpper(), use optional
argument for case-insensitivity:
C#:
VB:
Can also be applied to static String.Equals().

22. String Compare
Returns integer result of whether the first argument
is less, equal, or greater than the second argument.
Has optional parameter for case-insensitive.

23. Static String Empty Checks
Often time in code you will see something like:
C#:
VB:
Compound expressions are harder to read.
Can lead to buggy code if incorrectly coded or
inverted.
If string has whitespace, what then?

24. Static String Empty Checks
The System.String class has some static methods for
checking for null, empty, or whitespace only strings:
IsNullOrEmpty() – returns true if reference is null or
contains a completely empty string (zero Length).
IsNullOrWhiteSpace() – returns true if reference is
null, zero Length, or if all characters in string are
whitespace.
These static methods make the intent of the code
cleaner and eliminate need for compound expression.
Inverting the condition is also much more obvious.

25. Static String Empty Checks
C#:
VB:

26. Static Object Equals Check
What happens in the following if the LHS is null?
C#:
VB:
Equals() instance method can handle null RHS, but
not LHS.

27. Static Object Equals Check
You could check for null of LHS first, but gets ugly.
Use static (Shared) Equals() method instead:
C#:
VB:
Safer than using operator == for most types since ==
relies on an operator overload to exist.

28. The Path Class
Path has helper methods for parsing/combining
paths.

29. The Stopwatch Class
BCL class in System.Diagnostics.
Allows for much more precise timing than comparing
DateTime instances.
Contains basic methods for controlling Stopwatch:
Start() – marks starting time to now.
Stop() – marks ending time to now.
Reset() – resets start and end times.
Contains properties to query duration including:
ElapsedMilliseconds – long for milliseconds elapsed.
Elapsed – precicse elapsed time as a TimeSpan.

30. The Stopwatch Class
C#:
VB:

31. TimeSpan Factory Methods
How many times have you seen code like this and
wondered what the TimeSpan represents?
C#:
VB:
The constructors for TimeSpan are a bit ambiguous.

32. TimeSpan Factory Methods
TimeSpan has a series of static factory methods:
TimeSpan.FromDays(double days)
TimeSpan.FromHours(double hours)
TimeSpan.FromMinutes(double minutes)
TimeSpan.FromSeconds(double seconds)
TimeSpan.FromMilliseconds(double millis)
These methods can be used to create TimeSpans of
varying durations in a way that promotes better
readability.

33. TimeSpan Factory Methods
C#:
VB:

34. The Conditional Operator
Essentially a mini if-then-else operator.
Best used for small decisions that lead to a value
assignment or return.
If used simply, can make code more concise.
C#:
<bool-expression> ? <if-true> : <if-false>
VB:
If(<bool-expression>, <if-true>, <if-false>)

35. The Conditional Operator
C#:
VB:

36. The Null-Coalescing Operator
Allows concise substitution for null (Nothing) references.
 C#:
<reference> ?? <null-substitute>
 VB:
If(<reference>, <null-substitute>)
Equivalent to conditional operator checking for null/Nothing:
 C#:
value ?? substitue
value != null ? value : substitute
 VB:
If(value, substitue)
If(value IsNot Nothing, value, substitue)

37. The Null-Coalescing Operator
C#
VB:

38. Object Initializers
Many times, we create an object and then
immediately set a series of properties:
Lot of repetitive code especially if names are long:

39. Object Initializers
Of course, you could make it easier by providing
constructors, but you lose some readability:
Also, would need several constructor overloads or
acceptable default parameters.
Object initializers come in handy because they can be
used to initialize any public property or field.
Improves readability since tagged with property
name.

40. Object Initializers
C#:
VB:

41. Collection Initializers
Similarly, creating collections can be repetitive:
Especially if the type contained is non-trivial:

42. Collection Initializers
Can use collection initializer syntax to add multiple
items at time of collection construction:
C#:
VB:

43. Collection Initializers
Even works well in conjunction with object
initializers for initializing collections of complex
objects:
C#:
VB:

44. Collection Initializers
What is the difference between these?

45. Collection Initializers
Initializers preserve beforefieldinit modifier in the IL:
Gives small performance bump - without beforefieldinit
the CLR must check the class to see if static constructor
called before accessing any static member.

46. Extension Methods
If you develop a good piece of generic functionality
and want to attach it to an existing (sealed) type or
interface, you can create an Extension Method
Treated just like a true instance method, except can
be called off null (Nothing) reference, although this
is not recommended.
In C#, create a static class and static method with
this keyword marking the first argument.
In VB, create a Module and mark with
<Extension()> attribute.

47. Extension Methods
C#:

48. Extension Methods
VB:

49. Extension Methods
Can call just like regular instance methods:
Can be useful for adding behavior generically or to
interfaces.
Used to give most of the LINQ functionality to
IEnumerable.
Overuse can cause confusion and pollute IntelliSense.

50. LINQ
Too many times developers re-invent the wheel.
Say you have a list of Product such as:

51. LINQ
If you wanted all products with value > 100 grouped
by category, you could do something like…

52. LINQ
Or use the LINQ extensions methods:
Or LINQ expression syntax:
Either way, the algorithms are already written and
unit tested and ready to use.
Don’t reinvent the wheel.

53. Questions?

54. Platinum
Sponsors
Gold
Sponsors
Silver
Sponsors