MSDN Magazine - February 2009 - (Page 39)

Jeremy miller Patterns In PractIce Convention Over Configuration Have you ever thought about how much time on your project is spent on the core problems versus the time you spend wrestling with purely technical concerns? Some may say that the most important goal of all new software technologies and techniques is to reduce the distance between the developer’s intent for the software and the realization of that intent in code. And the industry has continuously raised the level of abstraction to allow developers to spend more time delivering functionality and less time writing low-level infrastructure—but there’s still a long way to go. Think about this for a minute. If you were to show your code to your business representatives—assuming that they were actually willing to read the code with you—how much of that code would they care about? Those business representatives will probably only care about the code that expresses the business functionality of the system. That code is the “essence” of the system. On the other hand, they probably wouldn’t have the slightest interest in code such as type declarations, configuration settings, try/catch blocks, and generic constraints. That code is the infrastructure, or “ceremony,” that you, the developer, have to go through just to ship code. In previous installments of this column I’ve largely explored fundamental design concepts and principles, most of which have been part of the design canon for quite some time. This time around, I’d like to look at some newer techniques that you can adopt to reduce the amount of ceremony in your code. Some of these concepts may be new to you, but I believe that all of this will be part of the .NET mainstream within a few years. Figure 1 Standing on Ceremony Sub FileOperations() On Error Goto ErrorHandler Dim A as AType Dim B as AnotherType ' Put some code here Set A = Nothing Set B = Nothing ErrorHandler: Err.Raise Err.Number, _ "FileOperations" & vbNewLine & Err.Source, _ Err.Description, _ Err.HelpFile, _ Err.HelpContext Exit Sub Flash forward to today and contemporary programming languages such as C# or Visual Basic .NET. Today, garbage collection eliminated most of the explicit memory cleanup that you used to face in Visual Basic 6.0 programming. Stack traces in exceptions are built into the Microsoft .NET Framework itself, so you no longer have to do that for yourself. If you think about all the rote boilerplate code that was eliminated when you moved to the .NET Framework, you can say that the .NET-compliant languages are more productive and readable than Visual Basic 6.0 because of the reduction in ceremony code. The .NET Framework was a big jump, but the evolution in languages isn’t finished yet. Let’s consider a simple property in C# implemented the classical way: public class ClassWithProperty { // Higher Ceremony private string _name; public string Name { get { return _name; } set { _name = value; } } } The Impact of Language Innovation The first factor I’d like to consider is the choice of programming language and how you use programming languages. To illustrate the impact of a programming language on the amount of ceremony in the code, let’s take a little detour into the musty pages of history. Earlier in this decade I was building a large system in Visual Basic 6.0. Each method would look something like what you see in Figure 1. Every single bit of that code was ceremony. I used a fair amount of boilerplate on each method to create an equivalent of a stack trace for easier debugging. I also had to dereference variables inside the method (Set A = Nothing) to release those objects. I had a strict standard for code reviews just to verify that the error handling and object cleanup was coded correctly on each method. The actual code, the essence of the system, floated somewhere in the middle of all that ceremony. The essence of this code is simply that the class ClassWithProperty has a string property named Name. Let’s fast forward to C# 3.0 and do the same thing with an auto property: public class ClassWithProperty { // Lower Ceremony public string Name { get; set; } } This code has the exact same intent as the classic style property, but it required noticeably less “compiler noise” code. Send your questions and comments to mmpatt@microsoft.com. February 2009 39

Table of Contents Feed for the Digital Edition of MSDN Magazine - February 2009

MSDN Magazine - February 2009 Contents Toolbox CLR Inside Out Data Points Cutting Edge Patterns In Practice Best Practices .Net Interop "Oslo" Basics Patterns Silverlight Under The Table Foundations Windows With C++ .NET Matters Going Places { End Bracket }

MSDN Magazine - February 2009

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.