C#/.NET Little Wonders

James Michael Hare 2011 Visual C# MVP Application Architect Scottrade August 5 th , 2011 Blog: http://www.BlackRabbitCoder.net Twitter: @BlkRabbitCoder

What are “Little Wonders”?
The .NET Framework is full of “macro-sized” goodness that makes 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.
Even then, many developers know of some of these but not all of them.
These are just a few of those items, there are many more.

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).

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

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.

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

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).

C#:

VB:

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?

Using using Blocks
Fully protecting gets ugly fast…
C#:

Using using Blocks
VB:

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

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

Static Class Modifier
Some utility classes contain only static methods:

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

Instead, mark class static and will prevent inheritance, instantiation, and instance members.
C#:
VB doesn’t have static classes, per se:
Modules are the VB.NET equivalent.

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.

The as Cast (TryCast)
C#:
VB:

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.

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

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.

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?

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.

C#:
VB:

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.

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.

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

The Path Class
Much safer and cleaner than combining/parsing by hand.

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.

The Stopwatch Class
C#:
VB:

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.

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.

C#:
VB:

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>)

The Conditional Operator
C#:
VB:

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)

The Null-Coalescing Operator
C#
VB:

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:

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.

Object Initializers
C#:
VB:

Similarly, creating collections can be repetitive:
Especially if the type contained is non-trivial:

Can use collection initializer syntax to add multiple items at time of collection construction:
C#:
VB:

Even works well in conjunction with object initializers for initializing collections of complex objects:
C#:
VB:

What is the difference between these?

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.

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.

Extension Methods
C#:

Extension Methods
VB:

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.

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

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

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

Questions? Questions?

http://geekswithblogs.net	19191
http://blackrabbitcoder.net	8383
http://www.blackrabbitcoder.net	1819
http://feeds.feedburner.com	304
http://planetcsharp.com	298
http://www.gogoframework.blogspot.com	126
url_unknown	109
http://gogoframework.blogspot.com	85
http://infovaran.squarespace.com	17
http://www.slideshare.net	14
http://www.gogoframework.blogspot.mx	14
http://www.gogoframework.blogspot.com.es	11
http://gogoframework.blogspot.mx	11
http://localhost	9
http://devfeeds.com	9
http://gogoframework.blogspot.com.es	4
http://www.gogoframework.blogspot.com.ar	4
http://www.twylah.com	3
http://feeds2.feedburner.com	2
http://127.0.0.1:8795	2
http://translate.googleusercontent.com	2
http://goaheaddebu.blogspot.com	2
http://cosmoton.org.es	1
http://webcache.googleusercontent.com	1
http://feedproxy.google.com	1
http://www.dataclips.com	1
http://mail.dastanley.com	1
http://twitter.com	1
http://blogvirtual.org	1

C#/.NET Little Wonders

by BlackRabbitCoder on Nov 11, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

29 Embeds 30,426

Statistics

C#/.NET Little Wonders — Presentation Transcript