.NET Coding Standards For The Real World (2012)

Please Set
Phones To
David McCarter
Vibrate

dotnettips.dotnetdave@gmail.com

© David McCarter 2012

About David McCarter
•Microsoft MVP
•David McCarter’s .NET Coding Standards
•http://codingstandards.notlong.com/
•dotNetTips.com
•700+ Tips, Tricks, Articles, Links!
•Open Source Projects:
•http://codeplex.com/dotNetTips
•San Diego .NET Developers Group
•www.sddotnetdg.org
•UCSD Classes
•http://dotnetdaveclasses.notlong.com

@davidmccarter

davidmccarter
dmccarter


 Packed full of:
 Videos of all sessions from
last 2 years!
 Slide decks from last 2
years!
 Demo projects from last
two years!
 David McCarter’s .NET
interview Questions!
 Extras
 Conference Photos!
 Surprise videos!
 Order online:
 http://dotnettips.wordpress.com/store/


Overview

Common Coding Mistakes

Defensive Programming

Coding Style

Summary

5 © David McCarter 2012

 First, you might not agree with
everything I say… that’s okay!
 Pick a standard for your company
 Every programmer on the same page
 Easier to read and understand code
 Easier to maintain code
 Produces more stable, reliable code
 Stick to the standard!!!
 Important part of Agile!


 Make sure it’s easily available to each
programmer
 Print or online (Share Point)
 Enforce via code reviews, pair
programming
 If the standard is insufficient or is causing
problems the standard can be adjusted, but
it should not be "hacked".


 Provide programs to make it easier for
programmers to maintain:
 StyleCop – FREE from Microsoft for C#
programmers.
 CodeIt.Right – Enterprise edition shares
profiles. Can create custom profiles for your
company.
 submain.com/products/codeit.right.aspx
 FxCop (Analyze in VS) – FREE from Microsoft
 Use Refactoring Tools!


 Scenario: In production Client Server
Application with millions in sales
 23 projects of 755,600 lines of .NET code*
Violations

This is why you need to follow good coding practices
throughout the lifecycle of the project!


[assembly: AssemblyTitle(“My App")]
[assembly: AssemblyDescription(“My App Management System")]
[assembly: AssemblyCompany(“Acme International")]
[assembly: AssemblyProduct(“My App")]
[assembly: AssemblyCopyright("Copyright © 2011 Acme Inc.")]
[assembly: ComVisible(false)]
[assembly: AssemblyVersion("2010.3.0.20")]
[assembly: AssemblyFileVersion("2010.3.0.20")]
[assembly: CLSCompliant(true)]

 Use the System.CLSCompliantAttribute
 Ensures that all its types and members are
compliant with the Common Language
Specification (CLS).
 Fill out all Assembly attributes

 Turn on Code Analysis!
 Always do this when creating a new project!
 Choose appropriate rule set.

public class FileCache
{
string _tempPath;
public FileCache(string tempPath)
public FileCache(string tempPath)
{
{ var cacheDir=
Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
_tempPath = tempPath;
} if (Directory.Exists(cacheDir) == false)
} {
Directory.CreateDirectory(cacheDir);
}
}
}

 Do not call code from a constructor!
 Can cause Exceptions.
 Capture parameters only.


public class Response
{
protected WebResponse response;
CurrentResponse {get; set;}
}

 Public instance fields should never be used.
 Use private fields wrapped inside public
properties should always be used instead.
 This allows validation the incoming value.
 This allows events to be thrown.


if (String.IsNullOrEmpty(txtPassword.Text))
(txtPassword.Text == "")
{
MessageBox.Show("Enter Password. ");
Password.");
}

 Length property of a string should be
compared with zero.
 Use IsNullOrEmpty(System.String) method!


private bool _showAdvancedSettings = false;
_showAdvancedSettings;

 Do not initialize Value types with its default
value
 Increase the size of an assembly
 Degrade performance.
 CLR (Common Language Runtime)
initializes all fields with their default values.


private byte[] GetContents(string location)
{
try
{
return ContentManager.Archiver.GetArchive(location);
}
catch (FileNotFoundException ex)
(Exception ex)
{
//Clean Up code
LogWriter.WriteException(ex, TraceEventType.Error,);
throw;
return null;
}
}

 Do not catch general Exception or
SystemException. Only specific exception should be
caught.
 If caught, re-throw in the catch block.
 “API” assemblies should not log exceptions/ events

 Always use the using/ Using statement to
make sure that unmanaged resources are
disposed of even if an exception interrupts
your application.

using (var logoImage = new Bitmap(_logoPath))
{
Bitmap logoImage = new Bitmap(_logoPath);
using (var ms = new MemoryStream())
MemoryStream ms = new MemoryStream();
{
logoImage.Save(ms, ImageFormat.Jpeg);
logoImage.Save(ms, ImageFormat.Jpeg);
ms.Close();
}
}


 Refactor for code reuse, low cyclomatic
complexity values.
 If you can’t see your code on one screen in
the editor, then it’s probably too long!
 Keep generics in mind.
 Real World Example:
 There was a method that was ~3500 lines of
code! About 3495 lines were in the If portion
and 3 in the Else portion!


 There are two kinds of programmers:
 Complexifiers are averse to reduction.
 Simplifiers thrive on concision.
 If your method, class etc. seems huge or
overly complicated, then you are most likely
doing it wrong!
 Refactor!
 Ask a follow programmer!
 Pair programming!
 Code review!

 Practice Defensive Programming!
 Any code that might cause an exception
(accessing files, using objects like DataSets
etc.) should check the object (depending on the
type) so an Exception is not thrown
 For example, call File.Exists to avoid a
FileNotFoundException
 Check an object for null
 Check a DataSet for rows
 Check an Array for bounds
 Check String for null or empty
 Clean up unused objects!

 Always check for valid parameter arguments
 Perform argument validation for every public
or protected method
 Throw meaningful exceptions to the
developer for invalid parameter arguments
 Use the System.ArgumentException class
 Or your own class derived from
System.ArgumentException
 Use Code Contracts in .NET 4
 See my video on YouTube


public IEnumerable<Type> FindDerivedTypes(string path, string baseType, bool classOnly)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path", "Must pass in path and file name.");
}

if (string.IsNullOrEmpty(baseType))
{
throw new ArgumentNullException("baseType", "Parent Type must be defined");
}

if (File.Exists(path) == false)
{
throw new FileNotFoundException("Could not find assembly file.", path);
}

//Code removed for brevity

}


 Never assume that Enum arguments will be
in the defined range.
 Always use Enum.IsDefined to verify
value before using!
public Environment.SpecialFolder RootFolder
{
get
{ return this._rootFolder; }
set
{
if (!Enum.IsDefined(typeof(Environment.SpecialFolder), value))
{
throw new InvalidEnumArgumentException("value",
(int)value, typeof(Environment.SpecialFolder));
}
this._rootFolder = value;
}
}


 When performing any operation that could
cause an exception, wrap in Try - Catch
block
 Do not catch non-specific exceptions (for
common API’s)
 Use Finally for cleanup code
 When throwing Exceptions try using from
System instead of creating custom Exceptions
 Use MyApplication_UnhandledException event
in VB.NET WinForm apps
 Use Application_Error event in ASP.NET apps

 Use consistent naming across variables
 Avoid single character variable names
 i, t etc.
 Do not abbreviate variable words (such as
num, instead of number)
 Unless they are well known like Xml, Html or
IO
 If deriving from a core type, add the suffix of
the identify type.
 ArgumentException or FileStream
 DO NOT vary variables by case! (C#)

 Take time to name your classes, methods,
namespaces and parameters so that they
are easy to understand
 Use consistent naming across methods,
assemblies, any project artifact
 Don’t use parameters names like sql, sql2 etc.
 Be consistent!


 Comment your code!
 While coding or before
 Keep it short and understandable
 Change/ remove comments that do not match
the code (after modification of the code)
 This includes removing TODO comments
 Mark changes with explanation, who changed
it and the date and time
 Include software change #, bug # etc.


 Examples of bad comments:
 “I was here 10/2/1960”
“This change made at the request of Satan”
“Don't know why this call is here doesn't seem
to do anything”
“This code doesn't work... so I've commented it
out and left it here for eternity...”
 NEVER WAIT UNTIL AFTER YOU ARE
DONE CODING!


//If user has permissions
if (x.a && b.z == 1 || c.f)
{
//Perform work
}

var userHasPermissions = x.a && b.z == 1 || c.f;

if(userHasPermissions)
{
//Perform work
}


 Comment all public classes and methods!
 XML can be turned into help docs, help html
with applications like Sandcastle
 http://sandcastle.notlong.com
 Very useful for teams and documentation for
users.
 Make this easy by using GhostDoc
 http://ghostdoc.notlong.com


 One Type per file
 Don’t hold Synchronization lock longer than
absolutely necessary (multi-threading)
 Always code for globalization!
 Resource files
 Formatting value types (dates, integer etc.)!
 Be consistent with { and } bracketing in C#
 Only use var/Dim when it’s obvious from the
right side of the statement what the type is
 Always using unit testing!


Check Code for Problems
Code.It
Style Cop FXCop
Right

Check in Code to TFS


 Refactor Pro! For Visual Studio
 http://refactorpro.notlong.com
1. StyleCop
 http://stylecop.notlong.com
2. CodeIt.Right
 http://codeitright.notlong.com
3. VS Analyze or FXCop
 http://fxcop.notlong.com


 Design Guidelines for Class Library
Developers
 http://DGForClassLibrary.notlong.com
 .NET Framework General Reference
Naming Guidelines
 http://namingguide.notlong.com


Questions?
•Presentation Downloads
•slideshare.com/dotnetdave
•Please Rate My Session:
•speakerrate.com/dotnetdave
•David McCarter’s .NET Coding
Standards
•codingstandards.notlong.com
•Geek Swag
•geekstuff.notlong.com

@davidmccarter

davidmccarter
dmccarter


.NET Coding Standards For The Real World (2012)

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to .NET Coding Standards For The Real World (2012)

Similar to .NET Coding Standards For The Real World (2012) (20)

More from David McCarter

More from David McCarter (15)

Recently uploaded

Recently uploaded (20)

.NET Coding Standards For The Real World (2012)

Editor's Notes