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!
How to Troubleshoot Apps for the Modern Connected Worker
C#/.NET Little Wonders
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.
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).
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?
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:
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.
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.
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.
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.
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.
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>)
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.
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.
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.
