Peter Ritchie's MVP Blog : .NET Development

Evolving code over time

PeterRitchie — Tue, 31 Mar 2009 04:02:00 GMT

Given economics, time constraints, resource limitations, etc.; you can't write all the functionality for a given solution for a single release. Even if you weren't limited by these constraints, you're likely to get changing requirements as development progresses and everyone learns more about the software under development.

It's fairly easy to prioritize what is developed and what isn't. You simply develop only what you need (see YAGNI). But, how do you manage adding new functionality without causing undue grief? One way is to only make additive changes to the code. For example, let's say we have the method create CreateRequestPacket that creates a blob of bytes to send to a host over the wire:

public static byte[] CreateRequestPacket()
{
    byte[] result = new byte[12];
    result[0] = REQUEST_CODE;
    result[1] = NO_OPTIONAL_DATA_FLAG;
    result[2] = (byte) (result.Length - 2);

    Random random = new Random();
    for(int i = 3; i < result.Length; ++i)
    {
        result = (byte) (random.Next() % byte.MaxValue);
    }
    return result;
}

In iteration x it writes out a request making certain assumptions about what the request contains. But, in iteration y it needs to optionally include other data. A non additive way is to simply modify CreateRequestPacket to do what is needed:

public static byte[] CreateRequestPacket(bool useOptionalData)
{
    byte[] result = new byte[12];
    result[0] = REQUEST_CODE;
    result[1] = OPTIONAL_DATA_FLAG;
    int index = 2;
    if(useOptionalData)
    {
        result[index] = GetOptionalData();
        ++index;
    }
    result[index] = (byte) (result.Length - index);

    Random random = new Random();
    for(int i = index + 1; i < result.Length; ++i)
    {
        result = (byte) (random.Next() % byte.MaxValue);
    }
    return result;
}

Now all calls to CreateRequestPacket need to change before a build can occure and you might not be able to modify all the files that contain these calls. So it causes undue blocking and forces you to change a number of files before you can check the file that CreateRequestPacket is contained withing.

Another way of implementing this would be to implement an additive change. That is, add a method that does what is needed and change the previous implementation to call the new method. For example:

public static byte[] CreateRequestPacket(bool useOptionalData)
{
    byte[] result = new byte[12];
    result[0] = REQUEST_CODE;
    result[1] = OPTIONAL_DATA_FLAG;
    int index = 2;
    if(useOptionalData)
    {
        result[index] = GetOptionalData();
        ++index;
    }
    result[index] = (byte) (result.Length - index);

    Random random = new Random();
    for(int i = index + 1; i < result.Length; ++i)
    {
        result = (byte) (random.Next() % byte.MaxValue);
    }
    return result;
}

public static byte[] CreateRequestPacket()
{
    return CreateRequestPacket(false);
}

This allows you to check the file that contains CreateRequestPacket in right after passing unit testing and allows you to gradually change all calls to CreateRequestPacket as time permits.

DevTeach 2009 Vancouver

PeterRitchie — Thu, 26 Mar 2009 16:33:00 GMT

The schedule for DevTeach 2009 Vancouver has been announced (http://www.devteach.com/). There’s lots of great software development sessions from some of the leaders in our industry.

If you’re planning on improving yourself, this is the conference to go to. Not only can you attend excellent sessions; but you can hob-knob with the presenters and pick their brains.

If you have a friend or co-worker who’s interested, there’s a limited-time two-for-one offer for an even better price: http://www.devteach.com/Register.aspx

A Upcoming Pandemic of Domain Anaemia

PeterRitchie — Thu, 29 Jan 2009 17:10:00 GMT

There's a well-known anti-pattern called the anaemic domain model[1][2]. This anti-pattern basically says domain entities, chronically, have little or no behaviour (remember, object-oriented design is about attributes and behaviour).

It should be obvious that a domain model that isn't truly object oriented is a domain model with a problem. But, let's look at other reasons why the Anaemic Domain Model is an anti-pattern. Your Domain is the nexus, the essence, of your system.

An anaemic domain model is basically a reporting system. Each "Entity" becomes, essentially, a query. This is fine, reporting systems are necessary and prevalent. But, to shoe-horn a domain model on top of this leads away from good reporting patterns that could add value and increases complexity, needlessly. The designers spend most of their time trying to force entities on the system, without recognizing the basic reporting nature of the system. This usually leads to "reports" that have to pull in multiple domain "entities" to generate the report--rehydringing data into an entity (usually through some sort of ORM) with no value added. i.e. an ORM that will manage the child-parent relationship (and either pre-load or lazy-load aggregates) doesn't provide much value here.

The worst case scenario with an anaemic domain model is that there really is behaviour there; but it's not handled in the domain entities; it's handled in a different layer. This is a problem because this circumvents the whole point of a domain model and layering.

One indication of anaemia is that most of the domain classes simply contain attributes. Anyone familiar with patterns should recognize this as a Data Transfer Object, not a Domain Entity. There's nothing wrong with DTOs, they're very important in almost all systems with any sort of complexity; but they're not Domain Entities. Let's be truthful, there are systems with little or no behaviour in the domain; and that's not a bad thing. Systems like this likely don't need a Domain Model and may not need techniques like Domain Driven Design. The quicker people recognize that, the quicker they can be using a more appropriate architecture and design. In some extreme cases the anaemic-domain-entity-DTOs service other DTOs

Now, where am I going with this? Well, there's been a series of guidance out of Microsoft Patterns and Practice about some application "patterns".

First, let me describe what a pattern is. A pattern is a way of "documenting a solution to a design problem" [3]. First, for it to be a pattern, it needs to detail the problem and it's context, then provide a solution. The latest "patterns" from P&P do not detail the problem or a context. They're simply architectural descriptions.

Now the association between the Anaemic Domain Model and the latest P&P guidance. In 3 of the 5 recently publish "patterns" the following is detail is included: "A Domain Entity pattern is used to define business entities that contain data only." This is the very definition of an Anaemic Domain Model. Plus, in the RIA pattern the following, contradictory, detail is included: "Domain entities are responsible for implementing business rules. Entities from the domain model represent business objects that contain data and implement behavior [sic]. In other words, the business objects are responsible for implementing business operations and interacting with other business objects."

This is disconcerting because historically sample code and guidance from Microsoft is simply reused without thought. This leads to poorly designed and architected applications, and the .NET community as a whole is seen as one that produces poor-quality code and design. Without context about the problems these patterns try to solve, they will be misused—likely forced upon contexts and situations where they don’t fit, simply because “they’re from Microsoft”.

[1] MF Bliki- AnemicDomainModel

[2] Anemic Domain Model - Wikipedia, the free encyclopedia

[3] Design pattern (computer science) - Wikipedia, the free encyclopedia

Technorati Tags: Microsoft Patterns and Practicies,Anti-patterns,Anaemic,Anemic,Domain Model,Microsoft

del.icio.us Tags: Microsoft Patterns and Practicies,Anti-patterns,Anaemic,Anemic,Domain Model

Unable To Step Into .NET Source

PeterRitchie — Mon, 24 Nov 2008 20:59:00 GMT

I began getting a problem a while ago that I was unable to step into the .NET source in Visual Studio 2008. It happened suddenly, and I noticed it shortly after installing SP1. Given my observation it appears to be due to upgrading the SP1; but I couldn’t find anyone else not having the same problem. I had another computer where it worked, so I basically put it aside.

Today I had a chance to have a closer look. I had configured 2008 (RTM, not SP1) to get the .NET source based on Shawn Burke’s blog and had not encountered any problems. Once I upgraded to SP1 and checked “enabled .Net source stepping”, I all I ever got when trying to step through source is a dialog asking me for the location of the CS file.

What I had configured was to place the debug symbols into a folder in the Visual Studio 2008 user directory (c:\Documents and Settings\PRitchie\My Documents\Visual Studio 2008\Symbols, for example).

Despite creating a new subdirectory for SP1, I still could not step through the source.

It wasn’t until I moved the directory down the hierarchy that I finally got some joy. I first tried it on the root and it worked fine. I then tried it as a sub directory within my documents and it worked fine. I imagine that the path was longer that 260 and rather than present the user with an error with that detail it assumed it couldn’t find the file it was looking for and asked the user for the location of it. But, I’m guessing.

Hope this helps someone else.

Pass-through Constructors

PeterRitchie — Fri, 21 Nov 2008 18:09:00 GMT

Pass-through constructors is a term I use to describe parameterized constructors that have none of their own logic and simply pass parameters to the base class. For example:

    public class BaseClass
    {
        private String text;
        public BaseClass(String text)
        {
            this.text = text;
        }
    }
 
    public class DerivedClass : BaseClass
    {
        public DerivedClass(String text)
            : base(text)
        {
        }
    } 

DevTeach 2008 Includes over $1,000 In Free Software.

PeterRitchie — Thu, 13 Nov 2008 08:52:00 GMT

Announced recently, registering for and attending DevTeach Montreal 2008 will land you with $1,000 of free software. Including:

Visual Studio 2008 Pro
Expression Web 2
TechEd Conference DVD set

The sessions have shaped up to be some of the best training money can buy, now you get a bunch of free software to boot.

For more details on the free software see: http://www.devteach.com/News.aspx

For a look at the sessions see: http://www.devteach.com/Schedule.aspx

To register go to: http://www.devteach.com/Register.aspx

.NET 4.0, Evolving .NET Development

PeterRitchie — Wed, 12 Nov 2008 16:02:00 GMT

.NET 4.0 is the first release of .NET since 2.0 that evolves .NET for every programmer. .NET 3.0 was largely LINQ and .NET 3.5 was largely new namespaces (like WCF, WWF, etc.)

.NET 4.0 evolves the programming and design for any programmer. It offers framework support for parallel processing (PFX will be released), Code Contracts (now DbC is a reality at the framework level, and opens the possibility of it being a reality at the language level post 2010), variance changes (co- and contra-variance on generics interfaces and delegates is now a reality).

Parallel Processing
Moore's law has changed from single processors doubling in speed every 18 months to doubling in processing power through increased core count every 18 months. This means for applications to make use of processing power increases they must increasingly make use of parallel processing and multi-threading. The PFX makes this more a reality by providing a framework by which application designers can more easily write code to support multi-core processors and multi-processor computers.

With PFX writing a loop to make use of multiple processors (while still supporting single processors) will be as easy as:

    uint[] numbers = new uint[] {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};

    Parallel.ForEach(numbers, delegate(uint number) { Trace.WriteLine(CalculateFibonacci(number)); });

Code Contracts
Design by contract is a form of writing software with verifiable interface specifications. These specifications can be used at compile time to find code that breaks the contract and not require checking of the contract at run-time. For example:

    [ContractInvariantMethod]

    public int Calculate()

        int result = 0;

        foreach (int value in values)

            this.operation(ref result, value);

        return result;

If anything modifies the current class within the Calculate method, an exception will be thrown at run-time. Compilers will eventually be able to perform rudimentary checks at compile-time to ensure these contracts are abided by. For example:

    [ContractInvariantMethod]

    public int Calculate()

        int result = 0;

        foreach (int value in values)

            this.operation(ref result, value);

        this.date = DateTime.Now;

        return result;

...may eventually cause a compile error on the assignment to this.date. The person designing this type intended this method to be invariant, meaning it doesn't change the state of the object to which it belongs. This design attribute can now be guaranteed.

Being able to include more design aspects in code and code definitions is a great step forward in not only writing intention-revealing code but in the ability to write more reliable code.

Variance changes

C# has always had intuitive variance when it came to arrays. For example, the following is valid code:

    Shape[] shapes = new Triangle[10];

Given:

    class Shape {

        //...

    class Triangle : Shape {

        //...

Generics variance was a different storey.  Prior to Visual C# 2010, this following is a compile error:

    Func<Triangle> triangle = () => new Triangle();
    Func<Shape> shape = triangle;
 
...despite Triangle being a type of shape (or otherwise known as "bigger" than Shape).  This is known as invariant. In Visual C# 2010 you can now create delegates (as well as types and methods) that are no longer invariant.  For example, a Func delegate could be created that is covariant:
        delegate T Func<out T>();
(not the new use of the out keword) ...which could make our previous code:
    Func<Triangle> triangle = () => new Triangle();
    Func<Shape> shape = triangle;
...compiler without error.
 
The same can be done for contravariance with the the new use of the in keyword:
        delegate T Action<in T>(T value);
 
For more details on generics variance, please see Eric Lippert's series on generics variance: http://blogs.msdn.com/ericlippert/archive/tags/Covariance+and+Contravariance/default.aspx

Other
Another notable improvement is side-by-side (SxS) support for multiple versions of .NET. This allows hosting of more than one version of the CLR within a single process. This makes writing shell extensions, for example, in C# a reality in .NET 4.0. You shouldn't need to target .NET 4.0, but as long as .NET 4.0 is installed you should be able to write shell extensions in a current version of .NET (like .NET 2.0) and it will be supported. Prior to .NET 4.0, a process could only have one version of the CLR loaded into a process, making extending 3rd party native applications (like the Windows shell) very problematic because what version of the CLR that was loaded into a process would depend on the first extension loaded. If the first extension loaded was a .NET 1.1 assembly then any other extensions loaded requiring .NET 2.0 would subsequently fail.

Becoming a Visual Studio Jedi Part 1

PeterRitchie — Tue, 02 Sep 2008 18:49:00 GMT

Becoming a Visual Studio 2008 (and often Visual Studio 2005) Jedi

In much the same grain as James' Resharper Jedi posts, I'm beginning a series of posts on becoming a Visual Studio Jedi. It involves getting the most out of Visual Studio off-the-shelf, doing things as quickly as possible and with as little friction as possible. I think it's useful for all users; but especially useful for those who are in situations where they can't install refactoring tools like Refactor Pro! or Resharper.

First, familiarize yourself with Sara's Visual Studio Tips blog; then subscribe to her blog.

I'll attempt to provide detail at a less granular level than Sara's blog (i.e. using a series of commands to perform a specific task); but I may overlap here and there

Take advantage of Auto-Hide
Like Jimmy Bogard and Jeffery Palermo, I have my Visual Studio UI very lean. 99% of the time, I'm working in code. The Solution Explorer (SE), Properties, Output, etc are auto-hide panes. When I need to use them I hover the mouse over the tab to make them visible, do what I need to do with them, then get back to the code. The Code Editor is the only window that isn't auto-hide or floating.

Navigate find results via keyboard
Whenever anything is displayed in a find results window, you can iterate each item in the list via a keystroke. The default C# keyboard map had F8 and Shift+F8 as the shortcuts for next and previous.

For example:

Press Ctrl+Shift+F to bring up the Find in Files form.
Enter "TODO\:.*refactor" in the "Find what" text box.
Ensure Match case, Match whole word are unchecked.
Ensure Use is checked and has Regular expressions selected.
Press Alt+F to search.

A Find Results window is displayed that shows the results of the search.

F8 goes to the first result.
Pressing F8 again goes to the next.
Pressing Shift+F8 goes to the previous result.

F8 and Shift+F8 work for most lists like Find Results 1, Find Results 2, Error List, Output:Build, etc.

File name extensions when adding classes
Do you find your self selecting text in the file name when you use the Add Class wizard? Or, do you always type ".cs" at the end of your file name? You may be happy to know you don't have to do that. Simply invoke the Add Class wizard and type the name of the class. The wizard adds the missing .cs for you. For example:
Press Alt+P, C
Enter "MyNewClass"
Press Enter
A file MyNewClass.cs is added to your project and it contains class named "MyNewClass".

Consider a Custom toolbar

There's generally only handful of toolbar buttons that you might need, especially if you're a keyboard user like me. There's some things that simply don't have a default keyboard mapping. Another good reason for having a custom toolbar item with only the buttons you use is if you often change the size of your Visual Studio window. The default layout has two or more toolbars (depending on the edition and any add-ins you have installed). You can carefully position those toolbars so they may take up one or two lines; but when you then shrink the size of your window the get wrapped and they won't restore if you expand the size of your window. Having a single toolbar means this wrapping of toolbars can never happen.

Export Settings

Once you get your UI the way you want it, you can actually save the layout.

Click on Tools\Import and Export Settings.
Select Export selected environment settings.

This is really handy if you get into low-resource situations (like the application you're developing or its framework uses up too many GDI handles and Visual Studio can't allocate a handle to display a toolbar or a frame. When this happens Visual Studio actually turns off those GUI elements; when you close and restart those panes/frames are no longer displayed by default.)

Trials and Tribulations of DataGridView, Column Selections, and Sorting

PeterRitchie — Tue, 26 Aug 2008 20:06:00 GMT

I had to implement some custom sorting in a DataGridView recently. Essentially, the stakeholders wanted full column selection (like Excel) while still having the ability to sort the data based on a particular column.

This particular DataGridView is data-bound. DataGridView offers the Sort(DataGridViewColumn, ListSortDirection) method to perform this. Nice and easy I thought: I’ll set the SelectionMode to DataGridViewSelectionMode.ColumnHeaderSelect and simply call Sort with the selected column.

Well, much to my chagrin this had the side effect of making that column look selected all the time. No matter where else I clicked, that recently sorted column looked selected (SelectedColumns had a count of zero). And to add insult to injury, when I control-clicked that column (thinking it was selected) to unselected it, it caused a NullReferenceException deep in the framework.

Suffice it to say, this makes it very difficult to sort by columns in DataGridView without using the built-in sort-column-when-header-is-clicked mode.

What I’m now attempting to do is to unselect the column before sorting it. This, in itself, is not trivial either; there’s no public method to select or deselect a column in the DataGridView. I’ve had to create a new DataGridView derivative and call the protected method SetSelectedColumnCore. A few hoops…

I’ve logged a couple of issues on Microsoft Connect about these problems. The first is about ctrl-clicking the column and getting an exception: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=363623 The second is about the visual state of the column remaining “selected”: https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=363623 Attached to this post you will find the project referenced by the two Connect issues.

[Update: I've currently only tried this with a .NET 2.0 project in Visual Studio 2008 SP1; if you find this problem occurs in Visual 2008 RTM, please comment.]

[Update: I overlooked the DataGridViewColumn.Select property, so there's no need to derive from DataGridView]

Location of unit tests.

PeterRitchie — Thu, 21 Aug 2008 01:24:00 GMT

I had a short conversation at Alt.Net Canada about the location of unit tests. I personally tend towards a distinct unit test project. But, I deal with mostly commercial, off-the-shelf (COTS) projects where I simply can't ship code like that. I also don't want to wire-off the unit test via #if because I would then be shipping something different than that which was tested.

From an enterprise application point of view, this is different. I would have no problem including the unit tests within their respective project as production code

DataGridViewColumn.Frozen

PeterRitchie — Mon, 11 Aug 2008 22:34:00 GMT

DataGridViewColumn.Frozen is documented as "When a column is frozen, all the columns to its left (or to its right in right-to-left languages) are frozen as well."

Which is nice until you think of the consequences. The consequences being that freezing a column and all columns to the left is performed with a single assignment of true to the Frozen property of that column; but to unfreeze is not the opposite (a assignment of false to the Frozen property of that column). No, you must unfreeze each of those columns to the left. This can be done by manually unfreezing each column, or by unfreezing column 0.

This means that column.Frozen = false is not the opposite of column.Frozen = true—resulting in unbalanced reversible side-effects.

Neither of the techniques to “unfreeze” the column that was frozen is intuitive; but unfortunately this interface is not "intention revealing". You’re not just setting the Frozen property of a column, you’re setting the frozen property of that column and all the columns to the left.

Greg Young recently commented (I don’t remember where) about writing classes without any properties. This approach would have helped here. What Greg is alluding to is to recognize behaviour rather than shape. Freezing the current column and all columns to the left is a behaviour, not an attribute; and it should be modeled as a method rather than a property.

At any rate, if you have a DataGridView on your form, you may be interested in using these methods instead:

        private void FreezeAtColumn(int value)

            dataGridView.Columns[value].Frozen = true;

        private void UnfreezeColumns()

            dataGridView.Columns[0].Frozen = false;

ITSWITCH #1: Answer

PeterRitchie — Mon, 28 Jul 2008 19:00:00 GMT

Last post I detailed some code that may or may not have something wrong in it. If you thought InitializeOne and IntializeTwo are semantically identical (e.g. they differ only by performance), you'd be wrong.

If you simply ran the code, you'd be able to guess where the problem is. To understand what's causing the problem. Let's look at how C# effectively implements the two loops.

InitializeOne is essentially equivalent to

        private class PrivateDelegateHelper

            public String Value { get; set; }

            public void Method()

                TestClass.ProcessText(Value);

        public void InitializeThree(String[] strings)

            delegates = new List<MethodInvoker>(strings.Length);

            MethodInvoker cachedAnonymousDelegate = null;

            PrivateDelegateHelper privateDelegateHelper = new PrivateDelegateHelper();

            String[] copyOfStrings = strings;

            for(int i = 0; i < copyOfStrings.Length; ++i)

                privateDelegateHelper.Value = copyOfStrings;

                if (cachedAnonymousDelegate == null)

                    cachedAnonymousDelegate = new MethodInvoker(privateDelegateHelper.Method);

                delegates.Add(cachedAnonymousDelegate);

Now it's obvious, right?

For those you don't want to read all the code, the problem is that only one PrivateDelegateHelper object is instantiated and its value property is set in each iteration of the loop. Because the delegates aren't run until sometime after the loop, they're all run with the last value of the string array as their argument.

The technical term for what we've implemented here is a closure. If you're using Resharper 4.x, you would have noticed a warning "Access to modified closure":

...which is attempting to tell you that the closure (the delegate and cached bound variables) has changed (in this case one of the bound variables has changed between the creation of a closure and another and out expected output is effected).

By the way, you can get the same thing with C# 3+ with lambdas (i.e. you can also write closures with lambdas):

        public void InitializeOne(String[] strings)

            delegates = new List<MethodInvoker>(strings.Length);

            for (int i = 0; i < strings.Length; ++i)

                String value = strings;

                delegates.Add(() => ProcessText(value));

        public void InitializeTwo(String[] strings)

            delegates = new List<MethodInvoker>(strings.Length);

            foreach(String value in strings)

                delegates.Add(() => ProcessText(value));

ITSWITCH: #1

PeterRitchie — Fri, 25 Jul 2008 18:58:00 GMT

Is There Something Wrong In This Code Here

UPDATE: as several readers pointed out there was compile error in the code what was being displayed. The line "String value = string" was showing up as "String value = string". I'm not sure why; but throwing some spaces between the i and the square brackets seems to have solved it.

In the following class, is there something wrong with either InitializeOne or InitializeTwo (hint, it has nothing to do with compile errors and I'm ignoring performance differences)?

    public class TestClass

        private List<MethodInvoker> delegates;

        private static void ProcessText(String text)

            Trace.WriteLine(text);

        public void Run()

            foreach(MethodInvoker invoker in delegates)

                invoker();

        public void InitializeOne(String[] strings)

            delegates = new List<MethodInvoker>(strings.Length);

            for (int i = 0; i < strings.Length; ++i)

                String value = strings[ i ];

                delegates.Add(delegate { ProcessText(value); });

        public void InitializeTwo(String[] strings)

            delegates = new List<MethodInvoker>(strings.Length);

            foreach(String value in strings)

                delegates.Add(delegate { ProcessText(value); });

Answer on Monday.

Working with Resharper's External Annotation XML Files

PeterRitchie — Mon, 21 Jul 2008 20:32:00 GMT

Resharper 4.0 has external annotation XML files that you can create to give Resharper more information about your code. For example, you can tell Resharper that a particular method does not accept a null argument. For example, the following method does not accept a null argument:

using System;

namespace Utility

    public static class Text

        public static int GetLength(String text)

            if (text == null) throw new ArgumentNullException("text");

            return text.Length;

An external annotation file can be created to inform Resharper of this fact and have it warn you when possible null values are passed as an argument:

            String text = null;

            Utility.Text.GetLength(text);

First, you need to create a directory within the Resharper ExternalAnnotations directory. This ExternalAnnotations directory is usually in the form of "%SystemDrive%\Program Files\JetBrains\ReSharper\vBuild#\Bin\ExternalAnnotations" for example "C:\Program Files\JetBrains\ReSharper\v4.0.816.4\Bin\ExternalAnnotations".

The directory we need to create is the same name as our assembly (without the extension). In our case this would be "C:\Program Files\JetBrains\ReSharper\v4.0.816.4\Bin\ExternalAnnotations\Utility".

Next, we need to create an XML file to contain the information required by Resharper. The name of this file is the same as the directory name, plus ".xml". So, the full file name would be "C:\Program Files\JetBrains\ReSharper\v4.0.816.4\Bin\ExternalAnnotations\Utility\Utility.xml". This file essentially has an assembly element with child member elements that provide meta-data about methods and arguments. In our case we want to tell Resharper that the Utility.Text.GetLength(String) method does not accept null values for the argument named "text". To do this we populate the file with the following XML:

<?xml version="1.0" encoding="utf-8" ?>

<assembly name="Utility">

    <member name="M:Utility.Text.GetLength(System.String)">

        <parameter name="text">

            <attribute ctor="M:JetBrains.Annotations.NotNullAttribute.#ctor" />

        </parameter>

    </member>

</assembly>

After restarting Visual Studio, Resharper will now warn that "text", when passed to GetLength, in the following code, has a "Possible 'null' assignment to entity marked with "NotNull" attribute".

            String text = null;

            Utility.Text.GetLength(text);

I've tried this with the GA build and with both Visual Studio 2005 (SP1) and Visual Studio 2008.

For more information about the annotation options, search for AssertionConditionType in the Resharper help and browse around "%SystemDrive%\Program Files\JetBrains\ReSharper\vBuild#\Bin\ExternalAnnotations" for examples.

Drag-copying in Visual Studio Solution Explorer.

PeterRitchie — Fri, 18 Jul 2008 16:46:00 GMT

NOTE: I've tried this in Visual Studio 2008 (VS2k8), I'm assuming the same thing happens in Visual Studio 2005 (VS2k5).

In the process of refactoring, it's *very* common for me to rename a type. This is most easily done by renaming the file in the Solution Explorer (SE)--which renames the file, the type, and and any uses of the type in the entire solution.

Occasionally, I need to create a new type based on another. Copying an abstract type in order to implement the abstract type is often handy--I just fill in the abstract members (and delete "abstract") in the copied type after renaming it.

Drag-copy in the SE seems like it would take care of a couple of steps at once for me: make a copy and rename it. Unfortunately it doesn't do that. It makes a copy of the file (as "Copy of typename.xx") but doesn't rename any types in the class that match the file name.

This might seem somewhat trivial... I can simply rename the file name then refactor rename the type in the file so that the type and all it's constructors are renamed in one fell swoop. Alas, this simply opens a can of worms that can completely confound a newcomer and annoy an expert.

That simple, intuitive method of renaming a copy of a file then the type within the file actually renames *all* types of that name. Since we've just made a copy of the type, that means it's always going rename types in two files. The side-effect of drag-copy in SE means you *must* manually rename the type in the file you just copied. You can do this with search-replace; but that's friction I don't want and really makes SE drag-copy unusable.

I've logged a bug about it on Connect; but the olde "by design" card was played...

Nested Types

PeterRitchie — Tue, 15 Jul 2008 14:47:00 GMT

Recently Michael Features blogged about nested types. The title was almost "nested types considered harmful".

I don't agree. I don't agree that they're any more harmful than any other C# construct (except goto...). Nested types are like anything else in our tool-belt: they have a time and place and can be abused.

But, when to use them? Well, for the most part I agree with Michael, you should avoid them. But, there are times when they're simply the best solution in a given set of circumstances.

Let's look at asynchronous programming model (APM) in .NET.

        // Paraphrased from MSDN

        // Accept one client connection asynchronously.

        public static void DoBeginAcceptTcpClient(TcpListener

            listener)

            // Start to listen for connections from a client.

            Trace.WriteLine("Waiting for a connection...");

            // Accept the connection.

            // BeginAcceptSocket() creates the accepted socket.

            listener.BeginAcceptTcpClient(

                DoAcceptTcpClientCallback,

                listener);

        // Process the client connection.

        public static void DoAcceptTcpClientCallback(IAsyncResult ar)

            // Get the listener that handles the client request.

            TcpListener listener = (TcpListener)ar.AsyncState;

            // End the operation and display the received data on

            // the console.

            TcpClient client = listener.EndAcceptTcpClient(ar);

            // TODO: do something with client.

            // Process the connection here. (Add the client to a

            // server table, read data, etc.)

            Trace.WriteLine("Client connected completed");

In this simple scenario we are getting by with a state of simply a TcpListener object. In a more complex scenario, you'll likely also want a connection-specific queue, some sort of information about what to do after a connection, etc. While you can use existing types of have several collection instance fields to keep track of each of these things; you then have to introduce synchronization of those collections, managing the content of those collections, etc.--it's much easier and safer to send that information on the stack. One method I've tried is simply passing an Object collection as the state; but that quickly becomes hard to manage because of the lack of type-safety on the elements in the array (if I remove an element and replace it with another type, the compile can't know and I'll get a run-time error instead of a compile-time error). To get type safety I generally introduce a new type to aggregate all the types I need in this asynchronous callback. While this new type *could* be reusable by other classes; it likely isn't and I don't want to then be bound that that explicit contract I've signed by making the types publicly available. The only option of not making them publicly available is as private nested types. For example:

        private class AcceptTcpClientParameters

            public CommandQueue CommandQueue { get; private set; }

            public Command NextCommand { get; private set; }

            public TcpListener TcpListener { get; private set; }

            public AcceptTcpClientParameters(int commandQueue, int nextCommand, TcpListener tcpListener)

                CommandQueue = commandQueue;

                NextCommand = nextCommand;

                TcpListener = tcpListener;

        // Accept one client connection asynchronously.

        public static void DoBeginAcceptTcpClient(TcpListener

            listener, CommandQueue commandQueue, Command nextCommand)

            // Start to listen for connections from a client.

            Trace.WriteLine("Waiting for a connection...");

            // Accept the connection.

            // BeginAcceptSocket() creates the accepted socket.

            listener.BeginAcceptTcpClient(

                DoAcceptTcpClientCallback,

                new AcceptTcpClientParameters(commandQueue, nextCommand, listener));

        // Process the client connection.

        public static void DoAcceptTcpClientCallback(IAsyncResult ar)

            AcceptTcpClientParameters parameters = ar.AsyncState as AcceptTcpClientParameters;

            if(parameters == null) return;

            TcpClient client = parameters.TcpListener.EndAcceptTcpClient(ar);

            parameters.NextCommand.Process(parameters.CommandQueue, client);

I find this use of nested types to be more object-oriented (the needs of the DoAcceptTcpClientCallback are abstracted), more intention revealing, better implements Single Responsibility Principle (SRP), better separates concerns, more maintainable and more agile.

Now, to be clear; this is forced set of circumstances. You're using a library that implements the APM (right? You haven't implemented APM yourself...). But, that's my point--nested types are almost essential in a given set of circumstances.

Sandcastle Source Code Published

PeterRitchie — Wed, 02 Jul 2008 18:15:00 GMT

The source for the Sandcastle project has been published. This is great news.

For more information, see http://www.codeplex.com/Sandcastle/SourceControl/ListDownloadableCommits.aspx.

Comparing CodeRush Refactor! Pro and Resharper 4, part 1 or N -- first glance.

PeterRitchie — Thu, 26 Jun 2008 01:17:00 GMT

Metadata view of code in referenced assemblies
This is a big one for me. For whatever reason, Refactor 4 (and prior) completely disables this and sends you to the Object Browser instead. You get metadata view with CodeRush Refactor! Pro.

Keyboard layout
As you might imagine, CodeRush Refactor! Pro and Resharper had completely different keyboard layouts. So, if you're used to R# then Refactor! Pro will take a bit of getting used to.

One thing I don't like with the default Refactor! Pro keyboard layout, is they've replaced Ctrl-. with Quick Navigation. I use Ctrl-. (instead of Shift-Alt-F10 to get at the smart-tag menu). Shift-Alt-F10 for smart-tag menu seems more common; so I'll have to get use to Shift-Alt-F10.

Refactor! Pro's Editor enhancements
R# doesn't change to how the editor looks as much as CodeRush Refactor! Pro. It has the Marker Bar, error/warning/info colouring, and action light-bulbs. Refactor! Pro with CodeRush has many more, like region painting, flow-break evaluation, Visibility Icons, structural highlighting, etc.

Real-time analysis
Both R# and CodeRush Refactor! Pro do real-time code analysis. R# has text colouring and the right-hand marker bar. CodeRush Refactor Pro has a marker bar on both the left and the right. The left marker bar in CodeRush Refactor! Pro highlights issues for each line, and the right (as does R#) shows a file-wide view of issues. I find the R# marker bar sometimes doesn't align with the scroll bar so that an issue may be beside the scroll-bar in the marker bar but is actually scrolled off the screen. CodeRush Refactor Pro doesn't do that and in fact shows the visible portion of the document in its marker bar. i.e. the marker bar is beside the Visual Studio Indicator Margin (where the breakpoint bullets appear).

Refactorings
They both have many of the same refactorings. When it comes to non-refactorings the two sometimes approach things differently. For example R# deals with adding members to a class through "Generate Code" list; whereas CodeRush Refactor Pro uses templates. E.g. in R#, to add a constructor you hit Alt-Ins and select Constructor. With Refactor you simply enter "cc "(that 'c', 'c', space).

Smart-Tags
Both approach smart-tags slightly differently. With R# they use the actions light-bulb at the left margin. This includes fixes for warnings, errors, plus refactorings, but doesn't include code generation options. CodeRush Refactor Pro uses an ellipsis-like icon that appears right at the site of the potential refactoring. Code Refactor Pro is a richer experience. It will show you the result of a refactoring with arrows showing where things will move, red strike-out showing what will be removed, and highlights for things that will be changed/renamed.

Entity Framework Petition of Vote of Non Confidence

PeterRitchie — Wed, 25 Jun 2008 17:21:00 GMT

I had intended to be happy simply being a signatory of ADO .NET Entity Framework Vote of No Confidence. But, there's people suggesting signatories of this petition are wackos or on the fringe.

Do yourself a favour and read the petition. Read what we have issues with and how we think Entity Framework (EF) can be improved to be a better product. Read seminal material by industry leaders on entity-oriented and object-oriented application development like Domain Driven Design, and Agile Principles, Patterns and Practices in C# (and the predecessor Agile Software Development: Principles, Patterns and Practices) and Applying Domain-Driven Design and Patterns: With Examples in C# and .NET. If after you have understand this information, you think being forced to use EF on a software development team would mean it would be hard to implement generally accepted object-oriented and entity-oriented design, the sign the petition.

Yes, you have the choice no to use EF; but you also have the choice to help people to not have to deal with the issues detailed in the petition simply because they were not made aware of them.

And despite the naysayers of people who think EF should improve, the ADO.NET team is listening and agrees.

Spaces or Tabs?

PeterRitchie — Mon, 26 May 2008 14:25:00 GMT

In this day and age it seems silly to get into a discussion about whether your companies coding guidelines should have a section mandating either spaces or tabs for indents. Tabs are clearly more flexible, but I really don't think it matters at all; people can easily read code that contains spaces or tabs.

But, Microsoft has departed from what seems to be the rest of the world and is mandating spaces in their new Microsoft Source Analysis Tool for C#.

Word is that an update will not only mandate spaces but mandate 4 for indents.

Again, I don't think it's much of an issue; except Microsoft Source Analysis Tool for C# doesn't offer a rule to mandate tabs over spaces. They're not providing a tool for organizations to use to enforce local coding guidines, but providing a tool to mandate Microsoft's coding guidelines.

The tool can be downloaded here and a discussion on tabs can be found here.