C# features
-
Upload
sagaroceanic11 -
Category
Technology
-
view
427 -
download
5
description
Transcript of C# features
James Michael Hare2012 Visual C# MVPApplication Architect
ScottradeAugust 3rd, 2012
http://www.BlackRabbitCoder.netTwitter: @BlkRabbitCoder
Me:Blog: http://www.BlackRabbitCoder.netTwitter: @BlkRabbitCoder
Information on Scottrade Careers:http://jobs.scottrade.comTwitter: @scottradejobs
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.
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 WondersSyntactical Sugar
Implicit TypingAuto-Propertiesusing Blocksstatic Class Modifier
Castsas (TryCast)
StringCase-Insensitive Equals()static IsNullOrEmpty()static
IsNullOrWhitespace()Object:
static Equals()Path
BCL Class for Path Handling
StopwatchBCL Class for Timing
TimeSpan static Factory Methods
OperatorsConditionalNull-Coalescing
InitializersObject InitializersCollection Initializers
Extension MethodsDefining Custom
ExtensionsLINQ Extension
Methods
Implicit typingSo 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 PropertiesMost properties simply get/set a backing
field:
Auto-Implemented PropertiesManually 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).
Auto-Implemented PropertiesC#:
Auto-Implemented PropertiesVB:
Using using BlocksWhen using an IDisposable instance, be
careful how you clean up:
What happens if exception is thrown before one or all are disposed?
Using using BlocksFully protecting gets ugly fast…
Using using Block Safer -- handles Dipose() even if exception.Can stack multiple using declarations in C#.Looks cleaner than multi-indenting.
C#:
Using using BlockVB doesn’t look quite as clean when
“stacked”, but still cleaner than the try/finally.VB:
Static Class ModifierSome utility classes contain only static
methods:
Static Class ModifierClasses with only static (Shared) methods
and properties shouldn’t be instantiated or inherited.
Could mark class sealed (NotInheritable) and create private constructor:
Static Class ModifierInstead, 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.
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 EqualsSometimes 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 EqualsInstead of converting ToUpper(), use optional
argument for case-insensitivity:C#:
VB:
Can also be applied to static String.Equals().
String CompareReturns 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 ChecksOften 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?
Static String Empty ChecksThe 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.
Static String Empty ChecksC#:
VB:
Static Object Equals CheckWhat happens in the following if the LHS is
null?C#:
VB:
Equals() instance method can handle null RHS, but not LHS.
Static Object Equals CheckYou 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 ClassPath has helper methods for
parsing/combining paths.
The Stopwatch ClassBCL 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 ClassC#:
VB:
TimeSpan Factory MethodsHow 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 Factory MethodsTimeSpan 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.
TimeSpan Factory MethodsC#:
VB:
The Conditional OperatorEssentially 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 OperatorC#:
VB:
The Null-Coalescing OperatorAllows 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 ?? substituevalue != null ? value : substitute
VB:If(value, substitue)If(value IsNot Nothing, value, substitue)
The Null-Coalescing OperatorC#
VB:
Object InitializersMany times, we create an object and then
immediately set a series of properties:
Lot of repetitive code especially if names are long:
Object InitializersOf 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 InitializersC#:
VB:
Collection InitializersSimilarly, creating collections can be
repetitive:
Especially if the type contained is non-trivial:
Collection InitializersCan use collection initializer syntax to add
multiple items at time of collection construction:C#:
VB:
Collection InitializersEven works well in conjunction with object
initializers for initializing collections of complex objects:C#:
VB:
Collection InitializersWhat is the difference between these?
Collection InitializersInitializers 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 MethodsIf 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 MethodsC#:
Extension MethodsVB:
Extension MethodsCan 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.
LINQToo many times developers re-invent the
wheel.Say you have a list of Product such as:
LINQIf you wanted all products with value > 100
grouped by category, you could do something like…
LINQOr 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.
Questions?Questions?