Developers solve problems. Good developers solve problems efficiently. The reward for that efficiency is [insert your preferred reward here]. Let’s assume you’re simply motivated by the satisfaction of a job well done (or maybe a promotion, a raise, longer lunch breaks, or just some extra time with your family). Whatever the motivation, the secret to solving problems efficiently is not inventing everything from scratch. Certainly the secret is not spinning your mental wheels hoping for inspiration. And most definitely the secret is not using Intellisense to arbitrarily try classes, methods, and properties until something works.

The secret to solving development problems efficiently is having the right information and the means to find the information you don’t have.

If you have been developing software for more than a week, you know that a working knowledge of language syntax and program construction (that is, "programming") is only a small part of the necessary skill set for solving problems with software. As a developer, you need to understand the technologies, processes, and methods available to you. You also need to have a set of reliable resources you can turn to when you encounter problems.

Below you will find some resource recommendations to help you find the information you need to help solve development problems more efficiently so you can get on with living the rest of your life.

Finding Answers to Specific Problems

Search Engines

I have heard colleagues muse about the changing role of "software developer," postulating that development has become a job mostly concerned with research and discovery. While that is no doubt an overstatement, the ability to find information quickly is an important skill. The place many of us turn to first is our search engine of choice whether it’s Live Search, Google, or a meta search site like Dogpile.

The appeal of most search engines is the beautiful simplicity of a single search box, but the needs of a developer are not simple when you factor in multiple versions of frameworks, programming languages with similar constructs, and behavior differences between competing products (I’m looking at you, Structured Query Language and Cascading Style Sheets). With just a short time investment, you can learn some advanced search operators and tricks to help narrow search results to exactly the information you need. For example, search for "live advanced search keywords" or "google advanced operators" and you’ll find a bunch of operators to help you become a search ninja.

In addition to your search engine of choice, Wikipedia can be an invaluable problem solving tool. I have found Wikipedia to be especially useful when searching for general topics such as common computer science algorithms and concepts. Although I often end up at Wikipedia through search engine results, Wikipedia has its own search box right on the home page (http://wikipedia.org/).

Of course not all problems will have solutions waiting to be discovered via a search engine. Some problems have already been solved in another part of your organization and you simply have no idea about the pre-existing solution. There are many tools designed to help companies deal with code asset management and search behind the firewall. One interesting product is Krugle, a specialty search engine built for indexing and searching code.

Stack Overflow

Searching is great when you know exactly what to search for and somebody else has previously solved a similar problem. When you are dealing with a more difficult issue, you may want to pose your specific problem to other developers for advice. There are plenty of discussion boards and forums for developers on the Internet to ask and answer questions.

One intriguing and useful site is Stack Overflow, a "collaboratively edited question and answer site for programmers." This innovative developer Q&A site allows users to post responses to questions and vote answers up or down based on usefulness, accuracy, etc. In addition to posting questions, you can search Stack Overflow or browse posted questions by tag. When you are posting a question on Stack Overflow, the application automatically searches existing questions and shows you matches that might already contain the answer you seek.

For obscure topics and scenarios such as bizarre error codes, Stack Overflow can be a job saver.

Twitter

Microblogging seems to be all the rage these days and some developers find services like Twitter to be an extremely effective way to share tips and send out requests for help. Twitter and similar services can be a two-edged sword, though, as they can be as much a distraction as a tool for information exchange.

If you are not familiar with Twitter, it lets you follow posts or "tweets" from other Twitter users. Tweets can be no more than 140 characters. You choose who you want to follow.

There are plenty of ways to use Twitter that will surely reduce your efficiency, but with a bit of intentionality in your approach, you can build a reasonable size network of trusted colleagues with whom you can swap questions, answers, tips, and tricks. (When your friends hear you are "on Twitter," they may demand to know your Twitter username. You might need to maintain separate Twitter accounts for work and personal use.)

Officemates, Coworkers, and IM Contacts

If you are anything like me, you find it tempting to just ask an officemate or IM contact for an answer. Of course this means solving my problem at the expense of my colleague who is distracted from doing his/her own work. With your recently acquired ninja search engine skills, take a look at some of the research on the impact of interruptions on productivity and ponder how a work culture that accepts interruptions as common practice could ultimately make you a less effective developer. Just something to think about before you start picking the brains of your cubicle mates.

Other Options

What sources do you rely on for finding answers to specific problems? Leave a comment below.

Keeping Up with New Technologies

With the rapid and continuous rate of change in the software development space, keeping up with the latest and greatest technologies could be a full-time job – in fact it is in many organizations! It really has become impossible to keep up with everything, but you should not let the fear of information overload prevent you from staying informed about significant changes directly related to your area of expertise. Being informed about new technologies helps you make informed choices about the tools, platforms, and libraries you will use to get from problem to solution.

Blogs

One easy way to stay informed about topics that might affect you is to subscribe to at least a few blogs in your area. Scott Guthrie’s blog is a good choice if you only want to get the big headline news like a new release of the .NET Framework (http://weblogs.asp.net/scottgu/). If you’re a Silverlight developer, Tim Heuer’s blog would be a good choice (http://timheuer.com/blog/). If you’re an ASP.NET developer, perhaps try the Visual Web Developer Team Blog (http://blogs.msdn.com/webdevtools/).

If checking blogs via a blog reader is not your thing, you might want to use a service that will deliver new blog posts to you via email.  FeedBlitz (http://www.feedblitz.com/) is a service I use for several blogs that I want to track even when I’m too busy to spend time reading my larger blog subscription list. Or you might want to add a few feeds to a customized browser home page through a service like Pageflakes or Netvibes.

Podcasts

Another way to stay current on technology is by listening to audio podcasts like .NET Rocks (http://dotnetrocks.com/) and Hanselminutes (http://hanselminutes.com/). Internet audio shows like these are generally packed with great technical content that helps keep you up to date. Podcasts can be an easy way to transform a tedious commute into a serious professional development opportunity. Personally I use the Zune desktop software (http://zune.net/) to automatically download new podcast episodes and sync them to my Zune device. If you don’t have a Zune, you can still grab the MP3 files from the Zune download folder and copy them to any portable media player.

User Groups

User groups are another great way to stay current on new technologies. User groups are community-run technical groups that hold events (both in-person and virtual) for members to learn about technologies related to the focus area(s) of the groups. User group events often happen outside of normal work hours, which can admittedly make it difficult for some people to attend. In addition to learning opportunities, user group events can be a great place to discuss technical issues you are tackling and increase the size of your network of colleagues that you can turn to for help.

Go to http://www.ineta.org/ to find details (including meeting times and places) for .NET-focused user groups in your neck of the woods.

Challenging Your Thinking

When building software, your existing methods for thinking about problems are used to design a solution based on the tools and information you have available. Too many times I have seen developers stuck in a mental rut and developing solutions inefficiently because of outdated or misguided thinking about the problem at hand. Case in point: I used to spend far too much time building and deploying simple tools and utilities as compiled executables until I learned to embrace scripting as a fully legitimate form of programming (after having turned my back on my past as a UNIX scripting hack). In part my thinking was influenced by the experiences of other developers who were sharing their experiences online.

If you do not have people challenging your think, I believe you will stagnate as a developer. That means talking to or reading the musings of other developers. Ideally you will find yourself disagreeing with or questioning their thoughts on a regular basis. You aren’t being challenged if you only read what likeminded people write.

Below are some sources that I find useful in challenging my thinking and assumptions. They might not work for you, which is fine, but I encourage you to find your own trusted sources that will regularly challenge your thinking.

CodingHorror.com is written by the brilliant and prolific Jeff Atwood. It has been a constant trove of insight and reasoned perspective, ranging from discussions of technical details to choosing a programming chair. (Jeff is one of the founders of the abovementioned Stack Overflow.)

JoelOnSoftware.com is written by the equally brilliant Joel Spolsky. He is the source of such gems as "The Joel Test: 12 Steps to Better Code" and "Things You Should Never Do." In addition to development topics, Joel writes about management and business issues. (Joel is the other founder of Stack Overflow.  Hmmm… perhaps I have a bias.)

Ted Neward writes a technical blog (http://blogs.tedneward.com/) that I regularly enjoy. Although I don’t read every post, I always find his pontifications worth digesting.

Daniel Crenna (http://dimebrain.com/blog) is another technical blogger whose musings I enjoy reading. Daniel is a great community champion and the founder of several open source projects. His blogging pace has slowed down in 2009 as he’s been working on some useful projects, but I keep hoping he’ll starting writing again soon. He’s a web / RIA guy, an area I’m interested in, so he stays in the ol’ blog list.

Join the Conversation

What do you do to be more efficient as a developer? What are your favorite resources for challenging your thinking? How do you keep up on technology changes in your area of expertise? How do you find solutions to specific problems? Leave a comment to share YOUR tips with us.

—–

Derek Hatchard is the content editor for http://microsoft.com/youshapeit/msdn and http://devshaped.com. He is also the founder of Crowd Space. You can find him online at http://derekh.com, http://ardentdev.com, and http://twitter.com/derekhat.

Continuous Integration is a development practice that can help improve your company’s ability to deliver quality software. It can reduce the time to market and the deployment cycle from functional complete products to having the solutions deployed on desktop or servers.

Continuous Integration, or CI, can start with a lone developer desktop and mature closer towards production. The ultimate goal is to have a CI environment that can take you from checked-in code to production ready installation packages.

The instructions in this article will help you get started with CI even if you’re a single developer or a small team.

This is a process that takes time, but don’t be afraid of the road ahead, I will walk you through the first baby-steps towards a well-tuned machine. CI-practice is one of many important elements for the software development industry to mature to levels of other types of manufacturing.

Introduction to Continuous Integration

Martin Fowler has written a very good introduction to CI which you can read this on his website: http://martinfowler.com/articles/continuousIntegration.html [1]

Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily – leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly. This article is a quick overview of Continuous Integration summarizing the technique and its current usage.

The clean and simple essence of CI is to avoid the situation “It works on my machine”. This has caused a lot of pain between developer and users, but also between developers. Most of us have experienced that our projects stops compiling properly after a Get Latest operation on the source control system. Another important aspect of CI is to have a cycles of automatic compilation and testing of your projects. We will get deeper into automatic testing later in this article.

Source Control Systems

If you are not familiar with source control systems (SCM), I suggest reading a good introduction by Eric Sink. While the first CI example I will give in this article doesn’t use SCM, it is an essential piece of the puzzle if you’re doing computer software development. Even as a single developer, it’s advisable to use a SCM. SCM will give you better control and management of your projects, with history and the ability to restore deleted code.

Introduction to SCM: http://www.ericsink.com/scm/scm_intro.html [2]

There are many providers of SCM software; for the purpose of this article we will use Microsoft Visual SourceSafe. When your team grows and you have the finances to purchase licenses, I suggest upgrading to Microsoft Visual Studio Team System, which is a complete Application Life-Cycle Management (ALM) suite.

Setting up your environment

There are various CI solutions available for .NET developers, one of the most popular is Cruise Control .NET (http://ccnet.thoughtworks.com/ [3]).

[Please note that all examples are from a 64-bit system where the Program Files paths includes (x86) for 32-bit applications. If you have a 32-bit environment, please make sure you remove any reference to (x86).]

Cruice Control .NET (CC.NET) comes in various forms, for beginners the setup alternative is the simplest to get you started (CruiseControl.NET-1.4.2-Setup.exe).

After the installation has completed, a new folder will appear in the Windows start menu. From here we can access the main configuration file and launch the console application.

Before we continue with updates to our configuration file, we need to learn a little bit about build tools…

Build Tools

To compile the source code, you will need a tool that does the build for you. One alternative is NAnt, which is a free tool (http://nant.sourceforge.net/ [4]).

With Visual Studio 2005 Microsoft introduced MSBuild, which is a standalone build engine for .NET. This has made it more accessible for third parties and made it simpler to automate and script.

The simplest way to get started with a build process is to utilize MSBuild, which is already installed if you have .NET Framework 2.0. We will configure CC.NET to start the MSBuild process which takes care of the compilation of our Visual Studio Solution.

New Project or Existing Solutions

It is much less effort to include guidance, frameworks, and tools in the beginning of a new project. This applies to CI as well. The further you get in the development process, the harder it gets to make everything work properly in a CI-environment.

Sample Projects

For the purpose of this article, we’ll create a new Visual Studio solution called IntegrationSample. Within this solution we will create 3 projects: IntegrationSample (Windows Forms), Integration.Common (Class Library) and Integration.Test (Class library).

Add a Person.cs class to the Common project with the following code:

This class represents part of our business domain model and has certain business logic applied to it that is important to our business, namely the method that tells us if a person is more than 60 years old. The next step is to apply a test for our domain object.

Automated Testing with Unit Tests

Being able to automate the testing process of your projects is an important feature of a CI-environment. Having source code that works as tests for your application logic will help you when you’re later going back to modify, extend and fix existing code. With good tests you can ensure that your code changes won’t break the whole application. There are different frameworks available for unit testing, the most widely used with .NET is NUnit (www.nunit.org [5]). To learn more about test-driven development, visit Wikipedia: http://en.wikipedia.org/wiki/Test-driven_development [6]

When the installation of NUnit is complete, you can explore the included samples to learn more about writing unit tests. You can use the NUnit GUI to run your unit tests outside of the CI-environment.

To start writing unit tests, you need to add a reference to the following assembly in your Integration.Test project: "C:\Program Files (x86)\NUnit 2.4.8\bin\nunit.framework.dll". Additionally you should create a reference between the Test and the Common project, so we can access our business domain model in the tests project.

When you’re done adding the reference, let’s create a class named PersonTest.cs which will contain all the unit tests for our specific domain object.

Tests are done through assertions. There are many types of assert methods included in the NUnit framework and you should use them to validate your business logic. Writing good unit tests is hard and it’s a practice in which you will continually improve as you get more experienced with it.

You can now begin to run and validate the unit tests on your local machine, open the NUnit GUI application and open the Integration.Test.dll file.

As you can see in my screenshot, both of the tests for the Person object validates. When we later go back to change the business logic, we can use the unit tests as a means to validate that our changes doesn’t break anything.

Bringing it all together

Let’s go back to the CC.NET configuration file and start modifying it so we get our CI-environment up and running. It’s advisable to have a dedicate computer that act as a build-computer, but it’s not a requirement.

The first thing we’re going to do is modify the default configuration file to run NUnit and our tests, here is the script so far:

<cruisecontrol xmlns:cb="urn:ccnet.config.builder">
 <project name="IntegrationSample">
  <tasks>
   <nunit>
    <path>C:\Program Files (x86)\NUnit 2.4.8\bin\nunit-console.exe</path>
    <assemblies>
     <assembly>C:\Source\Samples\IntegrationSample\Integration.Test\bin\Debug\Integration.Test.dll</assembly>
    </assemblies>
   </nunit>
  </tasks>
 </project>
</cruisecontrol>

Save the configuration and start the CruiceControl.NET application in the start menu. This will open a console application that will run your configuration. This is useful for beginners and when you’re setting up a new environment. When the configuration is complete, you should use the Windows Service for a more stable runtime.

When you ran the CC.NET installation, it should have created a virtual directory for you on the local Internet Information Services. If you happen to have any problems with this, make sure you create a virtual directory called webdashboard and map it to C:\Program Files (x86)\CruiseControl.NET\webdashboard.

Opening up the web dashboard should show us our IntegrationSample project and hopefully a green status, indicating that our unit tests has completed successfully. With the current configuration, we need to click the Force button to run tests.

This dashboard will be your viewport into the status and history of integration builds. You can drill down into the details of a build and you can have multiple CC.NET projects specified in the configuration file.

Our next step is to make CC.NET compile our source code using MSBuild.exe.

Within the <tasks> element in the configuration, add the following script above the NAnt task, which will tell CC.NET to execute MSBuild.exe with our Visual Studio solution file.

<msbuild>
 <executable>C:\WINDOWS\Microsoft.NET\Framework\v3.5\MSBuild.exe</executable>
 <workingDirectory>C:\Source\Samples\IntegrationSample\</workingDirectory>
 <projectFile>IntegrationSample.sln</projectFile>
 <buildArgs>/noconsolelogger /p:Configuration=Debug /v:m</buildArgs>
 <targets>Build</targets>
 <timeout>720</timeout>
 <logger>C:\Program Files (x86)\CruiseControl.NET\server\ThoughtWorks.CruiseControl.MsBuild.dll</logger>
</msbuild>

To validate that CC.NET is working correctly, we can go ahead and make a quick modification to the source code. If you reverse the operator for the age method, we should see the IntegrationSample fail on the dashboard. Drilling down into the details, we should see that our unit test fails.

The last and final step is to add support for a source control system. As you have now seen, you can setup an CI-environment without source control, but it makes sense to use source control. A source control system adds history and backup support and the ability to make heavy and local changes and not disrupt the active codebase which is inside the source control database.

Visual SourceSafe 2005

If you don’t have a source control system yet, an easy way to get started is with Microsoft Visual SourceSafe 2005. With an MSDN Subscription, you can download it from the downloads page.

When you go beyond a small team of programmers I suggest upgrading the source control with a more modern provider, like Visual Studio Team System or SourceGear [7].

Going back to Visual Studio and our IntegrationSample project, we will go ahead and add it to our source control provider of choice.

When the solution and all the projects is added to the source control, we can open the Visual SourceSafe Explorer and see how our newly added project is added and we can begin to check-out and check-in code changes.

We’re now ready for the final changes to our ccnet.config file. Open up the configuration file from the start menu and add the following new elements to the top beneath the <project> element.

<triggers>
 <intervalTrigger seconds="60" />
</triggers>

 <sourcecontrol type="vss" autoGetSource="true" applyLabel="true">
 <executable>C:\Program Files (x86)\Microsoft Visual SourceSafe\ss.exe</executable>
 <project>$/IntegrationSample</project>
 <username>build</username>
 <password>Password123</password>
 <ssdir>C:\Source\VSS</ssdir> <!-- Path to your SourceSafe database -->
 <workingDirectory>C:\Source\Samples\IntegrationSample\Build\</workingDirectory>
 <cleanCopy>false</cleanCopy>
</sourcecontrol>

Make sure you use a different working directory than your normal project folder, if you are running CC.NET on the same machine that you’re developing on. You also need to modify the <workingDirectory> and <assembly> elements we created earlier. See the bottom of the article for a full version of our build script.

When you start CruiceControl.NET again, you should see something similar to this output. Please beware that it can take a short while for the process to start.

As you can see, the script finds that there has been modification in the project inside our source control, which triggers a get process of the source code and later compilation and test-run.

You can specify your own trigger interval in the configuration file, depending on the size of your development team and your software, you can tune it to make sure you build often, but not so much that your build server starts having trouble.

You should create a special user account that your build process can run as and access the source control, as you can see in the example above I created a user called build.

Now it’s time to test the whole cycle of editing source code, check-in, watch the build server figure out there has been a modification and trigger a compilation and test-run. Let’s check out the Person.cs file and modify the age check to make our unit tests fail.

When you’re checking code back into the source control system, it’s good practice to add an informative comment. This is useful for historical purposes and for other team members to get an overview of changes in the history view.

After checking in our changes, we only need to wait a few seconds to see that CC.NET discovers our change and runs our script.

Congratulations, you now have a CI-environment up and running!

Going Forward

We have looked at the base tools in a CI-environment, going forward I suggest taking a look at frameworks and tools that works good together with CC.NET. FxCop [8] is a tool from Microsoft that analyzes your assemblies and reports anything that is not according to the industry standards for naming conventions, etc. NCover [9] is a tool which will generate code coverage reports (that means it will highlight which application logic in your application is being covered by unit tests). If you’re a component shop, API documentation is important. Using tools like SandCastle [10] you can automatically generate help files from your XML comments.

There is a whole world to explore and the extension ability to your CI-environment is endless and everything is there to help you improve the process of building good software with high quality.

You should now understand how to setup your own CI-environment using free tools. Best of luck in setting up your own environment!

References:

[1] http://martinfowler.com/articles/continuousIntegration.html

[2]http://www.ericsink.com/scm/scm_intro.html

[3] http://ccnet.thoughtworks.com/

[4] http://nant.sourceforge.net/

[5] http://www.nunit.org/

[6] http://en.wikipedia.org/wiki/Test-driven_development

[7] http://www.sourcegear.com/

[8] http://msdn.microsoft.com/en-us/library/bb429476(VS.80).aspx

[9] http://www.ncover.com/

[10] http://www.codeplex.com/Sandcastle

Sample Soure Code (includes the ccnet.config build script):

IntegrationSample.zip

Build Script

<cruisecontrol xmlns:cb="urn:ccnet.config.builder">
 <project name="IntegrationSample">

  <triggers>
   <intervalTrigger seconds="60" />
  </triggers>

  <sourcecontrol type="vss" autoGetSource="true" applyLabel="true">
   <executable>C:\Program Files (x86)\Microsoft Visual SourceSafe\ss.exe</executable>
   <project>$/IntegrationSample</project>
   <username>build</username>
   <password>Password123</password>
   <ssdir>C:\Source\VSS</ssdir> <!-- Path to your SourceSafe database -->
   <workingDirectory>C:\Source\Samples\IntegrationSample\Build\</workingDirectory>
   <cleanCopy>false</cleanCopy>
  </sourcecontrol>

  <tasks>

   <msbuild>
    <executable>C:\WINDOWS\Microsoft.NET\Framework\v3.5\MSBuild.exe</executable>
    <workingDirectory>C:\Source\Samples\IntegrationSample\Build\IntegrationSample\</workingDirectory>
    <projectFile>IntegrationSample.sln</projectFile>
    <buildArgs>/noconsolelogger /p:Configuration=Debug /v:m</buildArgs>
    <targets>Build</targets>
    <timeout>720</timeout>
    <logger>C:\Program Files (x86)\CruiseControl.NET\server\ThoughtWorks.CruiseControl.MsBuild.dll</logger>
   </msbuild>

   <nunit>
    <path>C:\Program Files (x86)\NUnit 2.4.8\bin\nunit-console.exe</path>
    <assemblies>
     <assembly>C:\Source\Samples\IntegrationSample\Build\IntegrationSample\Integration.Test\bin\Debug\Integration.Test.dll</assembly>
    </assemblies>
   </nunit>

  </tasks>
 </project>
</cruisecontrol>

—–

Sondre is a Microsoft Regional Director with 11 years of experience in software and web development. He currently works as Technology Leader for the Microsoft department at Capgemini in Oslo, Norway. Sondre is additionally the leader of the Norwegian .NET User Group in Oslo and a speaker at various technology and software development events. Active blogger, writer and technology enthusiast with a special passion for robotics, intelligent systems and open source.

When Microsoft first introduced C# to the masses in 2000, it was, in many respects, a language that anyone who’d ever worked with Java or C++ could pick up, learn, and be a productive developer after only a few hours of study. Granted, there were a few subtleties that took a bit of getting used to, like events, but on the whole, the C# language emerged as a pretty close descendant of its predecessors.

But as C# developed, first in the 2.0 release and then in the 3.0 release, the language took a sharp turn from its ancestral legacy into some strange territory by comparison — first with enumerators in 2.0, then lambda expressions in 3.0 — and a number of .NET developers found themselves longing for "the good old days" of C#, worrying that the language was too complicated and painful to use now. Granted, the LINQ features of C# were widely and warmly received, but some of the underlying features that made LINQ possible were barely understood, and to this day, rarely used outside of LINQ.

It’s time to put that trend where it belongs — out to pasture. Let’s take a look at the top 6 features of C# that you should be using if you’re not already. And while we’re at it, let’s see if we can spare your fingers some trauma, by reducing the number of keystrokes required to get something done.

Auto-Generated Properties (3.0)

This is an easy one, a natural time-saver. How many times haven’t you written this kind of code?

Oh, sure, I know, several plugins for Visual Studio will generate those property definitions for you, but let’s be honest — any time an IDE feature has to write code for you, that’s a bad sign. How much nicer is it to just let the language do that for you (since that’s what languages do best):

Fingers feeling less traumatized already? The best part is, there’s no difference: The compiler will "cook up" the private field and property "get" and "set" blocks for you, doing exactly what you would have. Incidentally, this also solves the "Should I use the field or the property when I’m inside the class" dilemma, since now the only access is through the property, making the code easier to maintain when you do, finally, have to make the properties more than just get/set.

Object Initializers (3.0)

Along the same lines as auto-generated properties, the object initializer is another way the language saves you some finger trauma. Thanks to the prevalence of properties and dearth of intelligent constructors, a lot of .NET code looks a lot like this:

In other words, the "new-then-prepare-before-use" idiom. (Don’t feel bad if you’ve been doing this without even realizing it — lots of C++ and Java code look exactly the same). Fortunately, the object initializer can write all the same code in a slightly terser manner:

Now, granted, it’s not a huge savings in terms of keystrokes, but it does help stress the "prepare-before-use" nature that constructors are supposed to infer. It also makes it easier to write data-only objects, such as data transfer objects (DTOs), since now you have one less constructor that needs to be written, at a minimum. In fact, if all the constructor is doing is passing values to those same properties, leave it off altogether. This also helps avoid writing four or five (or more) different constructors to cover all the possible intialization permutations, along the lines of constructors that take "FirstName and LastName", "FirstName, LastName and Age", "FirstName, LastName and Gender", and so on.

Implicitly Typed Local Variables (3.0)

This one is simple: instead of writing:

… you can let the compiler figure out what the type of departmentLists is by examination, and not have to worry about getting the declaration exactly right:

Note that despite the obvious syntactic similarity to JavaScript "var" declarations, this isn’t a dynamic object — the language still knows it is a Dictionary generic parameterized on a Person and a List of Persons, and Intellisense will demonstrate that to anybody interested in looking. It’s simply a shorthand way to avoid some additional finger trauma.

Static Classes (2.0)

Static classes won’t spare your fingers, but they can spare your brain, because a static class is deliberately written such that the consumers of a static class can’t create an instance — in other words, a static class is exactly what its name implies, a class filled with nothing but static methods and properties. In other words, this is a perfect place to put those "utility" methods that don’t really belong on an object instance:

Static classes make sure that developers realize that these are methods that aren’t intended to be object instances — in a way, it’s almost a step backwards to the earlier days of procedural programming, but let’s face it, sometimes what you really want is just a global method. The various "math" operations come to mind, for example — it’s not really an operation of "Int32" to calculate the sine of itself (but extension methods, next, give you that if you want it).

Extension Methods (3.0)

Extension methods are simultaneously one of the most powerful and most dangerous features of C# 3.0 in that they present the appearance of sliding new methods in on an existing and defined type, even if that type is sealed. (In other words, no inheritance is necessary).

Consider the System.Int32 type. As a mathematical type, it doesn’t know how to do much besides the four cardinal operations: add, subtract, multiply, divide, and all that. That’s great for simple math, but if you’re trying to build something bigger and stronger than that, you don’t get a lot of help from it. Granted, the Framework has a number of useful operations on the Math class to do some of that, but particularly for some of the unary operations (like taking the absolute of a given number, Math.Abs()), it feels awkward — it would be nice if that was an operation on System.Int32 natively.

Extension methods allow you to do exactly that:

The syntax is a little indirect, but there’s two main parts. The definition of the extension method itself is fairly straightforward–it must be a static method on a static class, whose first parameter is adorned with the extra modifier "this", indicating the instance (the "this" object) on which the method is operating. Next, at the point of usage, the "using" statement brings the extension methods in that namespace ("MathExtensions") into the compiler’s field of vision, so that from that point on, those operations are available on the types specified in the "this" parameter. So, in the case above, Abs() appears on "int"s, but not on longs, decimals, floats or doubles (unless those extension methods were also put into MathExtensions, which wouldn’t be a bad idea).

The power of extension methods is pretty obvious, particularly when you consider that you could write an extension method taking a "this" parameter of Object, thus adding a method to the root of the entire hierarchy. Do this with care.

Anonymous Methods (2.0) and Lambda Expressions (3.0)

These two features are really the same thing, an easier way to pass a method (instance or static) as a parameter to a function. In of themselves, it may seem like they’re just an easier way to write one-off event handlers, but when combined with enumerators (below), it introduces a new style of programming to C#, that of functional programming, in the same vein as languages like Haskell or ML or their more recent brethren, F# and Scala.

Here’s a concrete example: we have a collection of Persons in a List that need to see if their birthday is today. We could, of course, rip through the list using the traditional foreach loop, find the Persons we want to find, then apply the logic (add 1 to their age) to each one, but if this list grows to be thousands of objects long, that could take a while.

Instead, let’s apply some anonymous methods and enumerators to do some of this in parallel. (Note that all of this is without having to do anything with F#, the Concurrency Control Runtime, or the Parallel LINQ extensions). We’ll have to do a little groundwork first, but in a second it’ll be clear why this is a powerful extension to the language.

First, let’s create an extension method that will add itself to a List<T> and provide a new Filter function that will take a method (in this case, we’ll use the Predicate<T> type already defined in 3.0) that will be used to decide which elements should be included in the results. Second, let’s create a second extension method on List<T>s that will take an Action<T> type and apply it to each of the elements in that list:

Using the new methods is pretty easy, as they just "appear" on the List<T> type once the ListExtensions namespace has been "using"ed:

So far, so good. But remember, we started this discussion talking about doing operations in parallel, and these are all happening in sequence. To demonstrate doing them in parallel without changing the basic programming model, let’s create a "Parallel Process" function, ParProcess, as an async-delegate-invoking version of the Process function above:

This would be a bit easier to write if we didn’t have to call EndInvoke on each async delegate invocation, but CLR lore holds that failing to do so leaks resources (and presumably, after enough of them, will crash the process). Writing an equivalent "Parallel Filter" function is trickier, since each asynchronous invocation will need to add the compared item into a collection to be returned to the user, but it’s not impossible — I leave that as an exercise to the reader. (Which is another way of saying, "I could have written this, but I was feeling either lazy or under terrible pressure to turn in my overdue article".)

Using the ParProcess version is no different than the Process version:

When run, the results that appear for the managed thread id’s may differ, but on my system, they ranged from 3 to 7.

Summary

In some ways, this may seem like a perverse way to take features of a programming language and do crazy things with them — after all, all of the code I’ve written above could have been done using "traditional" C# / object-oriented approaches, using traditional looping approaches and so on. I don’t think any of the designers of C# would hesitate for one moment to agree with that statement.

But the more we as C# developers can look at the new features of the language, including the new "dynamic" features that are coming in C# 4.0, and use them to better and more succinctly express the intent of the code or design, the more we can reduce the amount of code we have to write, ship, and maintain. And in the end, let’s be honest — the best line of code we’ve ever written is the one that we didn’t have to write in the first place.

—

Ted Neward is a Principal Consultant with ThoughtWorks, an international consultancy developing agile solutions. He is fluent in Java, C#, Scala, F#, C++, and a few other languages, and spends a lot of time studying programming languages, virtual execution engines, and scalable enterprise systems. He currently resides in the Pacific Northwest.

One of the most underutilized productivity features in Visual Studio 2005 and Visual Studio 2008 is Code Snippets. Even though most developers have heard about them, I find when working with consulting customers that there are few developers who use them on a regular basis. Even if they do use them, they vastly underutilize them by only using a couple of them and never create their own. In this article, I give you a quick intro into what code snippets are, how they work, what is available out of the box, and how to go beyond that by quickly creating your own code snippets.

Code Snippets Overview

Code snippets were introduced in Visual Studio 2005 and allow you to emit a chunk of code into your editor by typing a few keystrokes (a shortcut mnemonic). I’m going to use C# for the examples in this article, but just realize that code snippets work in Visual Basic and other .NET languages as well. That chunk of code can just be a static chunk of code, but what really makes code snippets powerful is that they can have placeholders that you can quickly overtype when you invoke the code snippet.

To try them out, the best one to start with is one you can probably use the most often: the prop snippet. Code snippets have both a title and a shortcut, although these will often both just be set to the shortcut value. The prop snippet emits a property with a backing member variable in Visual Studio 2005, or an auto-implemented property in Visual Studio 2008. Code snippets show up in the IntelliSense list as well, so if a snippet has a longer shortcut than a few letters, often you can just invoke it by typing a few of the letters and select it out of IntelliSense.

For example, if I go inside a class declaration and type prop and hit Tab twice (once to dismiss the IntelliSense list, the second time to invoke the code snippet), I get the following in the editor:

public int MyProperty { get; set; }

The type and property name will be highlighted in green, indicating that they are the placeholders defined in the snippet. For this snippet, the type is the first placeholder and will be selected so that if you start typing, you will overtype what is there. So for example, say I want a string property. I type string and hit Tab. Tab moves between the placeholders, and when the focus is placed on the next placeholder, it selects it as well so you can overtype with the value you want. So if I type Name and hit Enter, I leave the placeholder mode and my changes are accepted. If I keep hitting Tab, it revisits the placeholders in order in case you accidently tabbed past one or changed your mind as you were filling things in.

This one may not be stunning in its time savings, but when you add up the keystrokes (4 + 1 + 6 + 1 + 4 + 1) you have 17 versus the 30 for typing out the whole property yourself. Wham! You just became almost twice as fast at writing code! OK, don’t tell your manager just yet, you need to actually get used to doing this all the time first…

Now consider setting a switch case statement for an enumeration with a number of values. For example, say you needed to set up a switch/case on the states for System.Windows.Input.MouseAction. If you had a local variable of that type with something like the following method:

public void HandleMouseInput(MouseAction action)
{

}

If I go inside that method and type switch Tab Tab, I get the following snippet with a placeholder on the variable switch_on.

public void HandleMouseInput(MouseAction action)
{
  switch (switch_on)
  {
    default:
  }
}

If I type in action for the placeholder (the local variable of enum type MouseAction) and hit Enter, the snippet fills in all the enum values as case statements:

public void HandleMouseInput(MouseAction action)
{
    switch (action)
    {
        case MouseAction.LeftClick:
            break;
        case MouseAction.LeftDoubleClick:
            break;
        case MouseAction.MiddleClick:
            break;
        case MouseAction.MiddleDoubleClick:
            break;
        case MouseAction.None:
            break;
        case MouseAction.RightClick:
            break;
        case MouseAction.RightDoubleClick:
            break;
        case MouseAction.WheelClick:
            break;
        default:
            break;
    }
}

That is a huge keystroke savings filling all the tedious structure code! You just need to fill in what to do for each case.

Built-in Code Snippets

The list of built-in code snippets for C# is actually fairly short. There is really only a small number included out of the box. You can find the full list here with a short description of each for the core C# language snippets: (http://msdn.microsoft.com/en-us/library/z41h7fat(VS.80).aspx). There are some additional ones in other categories that ship with Visual Studio 2008, but the list is still fairly short for C#.  Visual Basic actually ships with hundreds. But this shouldn’t make you feel shorted as a C# developer. You can actually find a greatly expanded library of C# code snippets that shipped after VS 2005 here: http://msdn.microsoft.com/en-us/vs2005/aa718338.aspx. You can also find libraries of other code snippets out on CodePlex and other places on the net.  do, while, for, foreach, and a number of other common control structures are all in the basic set, along with everything from data access patterns to file IO patterns in the expanded sets. ctor is another one that is handy for declaring a default constructor for a class.

There is a Code Snippet Manager in the Tools menu of Visual Studio that will let you browse all the built in snippets, import new ones, and search online. However, if you understand what is going on under the covers, it is actually easier to just manipulate them as files.

Inside Code Snippets

Code snippets themselves are nothing more than XML files with a particular schema that reside in some directories that Visual Studio is aware of. Specifically, snippet files end with a (not surprising) extension of .snippet. The built-in code snippets that ship with Visual Studio reside under the folder C:\Program Files\Microsoft Visual Studio 9.0 under VC# or VB respectively. Visual Studio is the default editor for that file type, so you can just browse to those folders and double click on the .snippet files and edit the XML in Visual Studio. If you want to create your own snippets, put them in your Documents folder under Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets (or similar path for VB or 2005). Visual Studio watches this file all the time, so changes or additions to snippets take effect immediately without needing to restart Visual Studio.

There are a lot of elements supported in the schema but the key ones to focus on are Shortcut in the Header element, and the Declarations and Code elements under the Snippet element. Say I wanted to emit a code snippet like the following with a placeholder over the Boo! string so I could overwrite it:

System.Console.WriteLine("Boo!");

To do so, I would have a code snippet that looks like this inside:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Shortcut>cwboo</Shortcut>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>output</ID>
          <Default>Boo!</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[System.Console.WriteLine("$output$"$end$);]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

In this case, the IntelliSense shortcut to invoke it is cwboo. The code snippet declares one literal variable named output with a default value of Boo!. The actual code of the snippet has to be declared inside an XML CDATA section because some legal characters in C #and other languages could cause XML parsing errors. The output literal is a named placeholder in the emitted code which will be replaced with the default value and highlighted for overtyping as discussed earlier. You can see that when you use a literal in the snippet, you enclose it within leading and trailing $ delimiters. Everything else in the snippet (except other variables) is emitted as plain text in the editor when the snippet is invoked. You can see I am also using a built-in literal $end$, which specifies where the input cursor is placed when you hit Enter to leave the placeholder mode of snippets.

Creating Your Own Snippets

By now you are probably emitting some form of "Eeewwww!!!" sound at the thought of editing the XML whenever you want to create your own snippets. The good news is that you don’t have to. There are a couple of free tools out there to help you create and edit snippets without ever needing to touch the XML directly. One I have been using for years as a C# guy is Snippy (http://www.codeplex.com/snippy). It puts a very simple dialog interface on top of the XML schema for you to create your snippets (see Figure 1).

Figure 1: Snippy

A great way to start many custom snippets is to start with an existing one and just edit it. Just remember to do a "Save As…" and save it to your Documents code snippets folder mentioned earlier so you don’t overwrite the built-in ones.

Another choice is the Code Snippet Editor for Visual Basic 2008 (http://msdn.microsoft.com/en-us/vbasic/bb973770.aspx). For those language bigots, you will have to get over the title: it actually supports multiple languages (see Figure 2).

Figure 2: Code Snippet Editor for Visual Basic 2008

Either one of these will allow you to quickly create your own snippets and stop typing the same code over and over again.

Code Snippet Functions

I showed you the switch snippet earlier in the article, and that may lead you down the path of thinking you can pull off anything with a snippet. Unfortunately that is one of the most powerful ones you will find. There is a whopping three functions in the C# library for expanded capabilities in your snippets (http://msdn.microsoft.com/en-us/library/ms242312.aspx). The GenerateSwitchCases function is the one that did the magic for the switch code snippet. The ClassName function will emit the class name of the class in which the snippet is invoked. This is used by the ctor snippet I mentioned earlier to declare a default constructor. And lastly there is the SimpleTypeName function, which will take a fully qualified type name, and will emit both a using statement in C# (Imports in VB) and the root class name so that you don’t have fully qualified types in the emitted code. This is used by the built-in snippet cw, which emits a Console.WriteLine statement. Take a look at that built-in snippet if you want to see the way it is used. Unfortunately there is no way to add your own custom functions. If you want more power to do more custom things in your snippets, you might want to take a look at third party tools such as Developer Express CodeRush (http://www.devexpress.com/CodeRush) or JetBrains ReSharper (http://www.jetbrains.com/resharper/). They have things called templates that are like code snippets on steroids and are also extensible.

Wrap Up

Now you should have a good idea what code snippets are, how they work, and how to go beyond what you get out of the box. Let me share with you my approach to code snippets: If I find myself typing some code and I get that "déjà vu" feeling of "I know I’ve written this little chunk of code before", I stop myself, write it as a code snippet, and then I won’t ever have to write it again. Too often developers take the longer path because they think they will be "wasting time" by going and doing something like authoring a code snippet for the code they are writing. Many times, it is not authoring the code snippet that is the real waste of time.

—-

Brian Noyes is chief architect of IDesign (www.idesign.net), a Microsoft Regional Director and MVP, writer and speaker. He is the author of Developing Applications with Windows Workflow Foundation, Smart Client Deployment with ClickOnce, and Data Binding with Windows Forms 2.0. He is also a frequent speaker at conferences worldwide including Microsoft TechEd, DevConnections, VSLive!, DevTeach and others. You can contact him through his blog at http://briannoyes.net.