Tip #8 – Extract Class From Parameters

Use: If you find yourself passing a set of related values to a method, you should probably put all of those items into a single class or struct. From JetBrains:

This refactoring creates a new class or struct and converts parameters of the selected method into encapsulated fields of the newly created type (with constructor taking parameters, fields to store values and properties to retrieve values). Usages of parameters are converted to usages of properties of created type.

Before

   1:      public class EmployeeUtilities

   2:      {

   3:          public bool ValidateTerminatedEmployeeInfo(int employeeId

   4:                                                   , string firstName

   5:                                                   , string lastName

   6:                                                   , DateTime hireDate

   7:                                                   , DateTime terminateDate)

   8:          {

   9:              if (employeeId > -1 && 

  10:                  !String.IsNullOrWhiteSpace(firstName) && 

  11:                  !String.IsNullOrWhiteSpace(lastName) &&

  12:                  hireDate < DateTime.Now && 

  13:                  terminateDate > hireDate)

  14:              {

  15:                  // do awesome stuff

  16:                  return true;

  17:              }

  18:   

  19:              return false;

  20:          }

  21:      }

Right-click the method

Extract Class From Parameters

After

   1:      public class EmployeeInfo

   2:      {

   3:          private int _employeeId;

   4:          private string _firstName;

   5:          private string _lastName;

   6:          private DateTime _hireDate;

   7:          private DateTime _terminateDate;

   8:   

   9:          public EmployeeInfo(int employeeId, string firstName, string lastName, DateTime hireDate, DateTime terminateDate)

  10:          {

  11:              _employeeId = employeeId;

  12:              _firstName = firstName;

  13:              _lastName = lastName;

  14:              _hireDate = hireDate;

  15:              _terminateDate = terminateDate;

  16:          }

  17:   

  18:          public int EmployeeId

  19:          {

  20:              get { return _employeeId; }

  21:          }

  22:   

  23:          public string FirstName

  24:          {

  25:              get { return _firstName; }

  26:          }

  27:   

  28:          public string LastName

  29:          {

  30:              get { return _lastName; }

  31:          }

  32:   

  33:          public DateTime HireDate

  34:          {

  35:              get { return _hireDate; }

  36:          }

  37:   

  38:          public DateTime TerminateDate

  39:          {

  40:              get { return _terminateDate; }

  41:          }

  42:      }

  43:   

  44:      public class EmployeeUtilities

  45:      {

  46:          public bool ValidateTerminatedEmployeeInfo(EmployeeInfo employeeInfo)

  47:          {

  48:              if (employeeInfo.EmployeeId > -1 && 

  49:                  !String.IsNullOrWhiteSpace(employeeInfo.FirstName) && 

  50:                  !String.IsNullOrWhiteSpace(employeeInfo.LastName) &&

  51:                  employeeInfo.HireDate < DateTime.Now && 

  52:                  employeeInfo.TerminateDate > employeeInfo.HireDate)

  53:              {

  54:                  // do awesome stuff

  55:                  return true;

  56:              }

  57:   

  58:              return false;

  59:          }

  60:      }

Happy coding!

Tip #7 – Move String to Resource

Use: Moves a string into a resource file to enable localization.

Tip: Ensure your project contains at least one Resource (resx) file or the operation will fail.

Before

   1:       public string YouRock()

   2:       {

   3:           return "No, YOU rock Mr. Method-Caller!";

   4:       }

Right-click the string –> Refactor –> Refactor This…

Move to Resource

After

   1:       public string YouRock()

   2:       {

   3:           return StringResources.No_YOU_rock_Mr_Method_Caller;

   4:       }

Happy coding!

Tip #6 – Extract Interface

Use: Creates a new interface based on the selected class and updates the class to implement the new interface. This is most useful when working with an existing code base because we all define our interfaces first when doing greenfield development, right? 

Before

   1:      public class Shooter

   2:      {

   3:          public string Name { get; set; }

   4:   

   5:          public string ReleaseDate { get; set; }

   6:   

   7:          public int MaxPlayers { get; set; }

   8:   

   9:          public bool HasZombies { get; set; }

  10:   

  11:          public bool IsHalo { get; set; }

  12:   

  13:          public void Borrow()

  14:          {

  15:              //TODO: Implement borrow logic.

  16:          }

  17:      }

Right-click the class

Select members

After

   1:      public interface IGame

   2:      {

   3:          string Name { get; set; }

   4:          string ReleaseDate { get; set; }

   5:          int MaxPlayers { get; set; }

   6:          void Borrow();

   7:      }

   8:   

   9:      public class Shooter : IGame

  10:      {

  11:          public string Name { get; set; }

  12:   

  13:          public string ReleaseDate { get; set; }

  14:   

  15:          public int MaxPlayers { get; set; }

  16:   

  17:          public bool HasZombies { get; set; }

  18:   

  19:          public bool IsHalo { get; set; }

  20:   

  21:          public void Borrow()

  22:          {

  23:              //TODO: Implement borrow logic.

  24:          }

  25:      }

Happy coding!

Tip #5 – Replace Constructor with Factory Method

Use: If an application must control how or when new instances of classes are created, a factory method can achieve this. ReSharper makes it simple to wrap a constructor with a static factory method.

Before

   1:      public class Car

   2:      {

   3:          private IList<IPart> _parts;

   4:   

   5:           public Car(IList<IPart> parts)

   6:           {

   7:               _parts = parts;

   8:           }

   9:      }

Right-click the constructor

Name your method or accept the default

After

   1:      public class Car

   2:      {

   3:          public static Car CreateCar(IList<IPart> parts)

   4:          {

   5:              return new Car(parts);

   6:          }

   7:   

   8:          private IList<IPart> _parts;

   9:   

  10:          private Car(IList<IPart> parts)

  11:           {

  12:               _parts = parts;

  13:           }

  14:      }

Happy coding!

Tip #4 – Convert Abstract Class to Interface

Use: This is used when the class(es) that will be inheriting from a base class also need to inherit from another base class. Derived types can inherit from only one base class but can implement multiple interfaces.

Before

   1:      public abstract class Book

   2:      {

   3:          public abstract string Title { get; set; }

   4:   

   5:          public abstract string Year { get; set; }

   6:   

   7:          public abstract string Author { get; set; }

   8:   

   9:          public abstract void Lend();

  10:   

  11:          public abstract void AddToInventory();

  12:      }

Right-click the class

After

   1:      public interface Book

   2:      {

   3:          string Title { get; set; }

   4:          string Year { get; set; }

   5:          string Author { get; set; }

   6:          void Lend();

   7:          void AddToInventory();

   8:      }

Note: Notice that this refactoring does not change the name of the type. At this point, there will be a squiggly line under the interface’s name, Book. Placing the cursor on Book and pressing <Alt+Enter> will prompt ReSharper to rename it to IBook.

Happy coding!

Tip #3 – Convert Into LINQ Expression

Use: ForEach blocks that perform simple bits of logic can often times be rewritten as lambda expressions. This reduces the number of lines of code and usually makes the code more readable.

Before

         public IList<Album> FindAlbumsToGiveAway(IList<Album> albums)
         {
             var badAlbums = new List<Album>();

             foreach (Album album in albums)
             {
                 if (album.Genre == "Country")
                     badAlbums.Add(album);
             }

             return badAlbums;
         }

Press <Alt+Enter>

After

         public IList<Album> FindAlbumsToGiveAway(IList<Album> albums)
         {
             return albums.Where(album => album.Genre == "Country").ToList();
         }

Happy coding!

Tip #2 – Create Field

Use: Within the body of a class or property, you can type the name of a non-existent variable name. When you place your cursor on the variable, ReSharper provides several options to resolve the impending compilation error. Create Field is one of the options.

Before

   1:          public void AddAlbum(string album)

   2:          {

   3:              if (String.IsNullOrWhiteSpace(album))

   4:                  throw new ArgumentOutOfRangeException("album",

   5:                                                        album,

   6:                                                        "Please provide an album name.");

   7:   

   8:              _albums.Add(album);

   9:          }

Press <Alt+Enter>

After

        private IList<string> _albums = new List<string>();

        public void AddAlbum(string album)
        {
            if (String.IsNullOrWhiteSpace(album))
                throw new ArgumentOutOfRangeException("album",
                                                      album,
                                                      "Please provide an album name.");

            _albums.Add(album);
        }

Note: I chose the type IList<string>. The default type selected by ReSharper in this case was object. I also added the initializer to the field to avoid null reference exceptions. Please don’t take any of these examples as best coding practices, they are contrived to demonstrate a particular refactoring.

Happy coding!

Tip #1 – To Automatic Property

Use: If a public property does not contain any logic, it can be converted to an auto-property, removing the corresponding private field and replacing usages of the private field.

Before

   1:          private string _name;

   2:          public string Name

   3:          {

   4:              get { return _name; }

   5:              set { _name = value; }

   6:          }

   7:   

   8:          public void CheckName()

   9:          {

  10:              if (_name == "Dark Side of the Moon")

  11:                  Console.WriteLine("Awesome");

  12:          }

Place your cursor on the Name property and…

Press <Alt-Enter>

After

   1:          public string Name { get; set; }

   2:   

   3:          public void CheckName()

   4:          {

   5:              if (Name == "Dark Side of the Moon")

   6:                  Console.WriteLine("Awesome");

   7:          }

Happy coding!

Welcome to a quick and dirty example in which I’ll make use of interfaces, inheritance and generics. I was working with some code that did a lot of iterating over collections to find objects with a particular ID. This is an abstracted example of what I did to simplify and centralize that code in a reusable manner.

If you are using Visual Studio 2008, you could achieve the same kind of reuse with an extension method on your generic list. The project I was working on was in .NET 2.0 and Visual Studio 2005.

This method returns a student’s course based on its ID. The student object here is a private class member. The CurrentCourses property is a List<Course> collection.

private Course FindCourseOld(int id)
{
    foreach (var course in _student.CurrentCourses)
    {
        if (course.ID == id)
        {
            return course;
        }
    }

    return null;
}

It’s pretty simple, but suppose you had a dozen or more types with an ID property that were all queries like this? It smells like an opportunity to do some refactoring. We need to keep all the functionality of the List<T> generic collection, including sorting, index operations, and enumerating, but we want to provide a dictionary-type of lookup on the ID property. Let’s inherit from List<T> and add a method to perform our lookup.

Before an object can be stored in this new collection, our child of List<T>, that we are going to create, we need to ensure it has an ID property on which we can operate. To that end, I present to you the IHasIdentifier interface. I know it’s not grammatically correct, but I think it gets the point across.

public interface IHasIdentifier
{
    int ID { get; set; }
}

The new interface has a single property named ‘ID’, which many of the types you might consider using in our collection may already have. Next up is the IdentityList<T> itself. The implementation I have here is very simple. There is just a single method, GetItemByID, added to the base class, List<T>.

public class IdentityList<T> : List<T> where T : IHasIdentifier
{
    public T GetItemByID(int id)
    {
        foreach (var obj in this)
        {
            if (obj.ID == id)
            {
                return obj;
            }
        }

        return default(T);
    }
}

We’re inheriting from List<T> and specifying that T must implement IHasIdentifier. Now, in the GetItemByID method, we can do our iteration to find the object with the given ID and return it. Finally, let’s take a look at the FindCourseNew method which uses our IdentityList<T> collection.

private Course FindCourseNew(int id)
{
    return _student.CurrentCourses.GetItemByID(id);
}

The code here is much cleaner, and there could be more opportunity for code reuse with the IdentityList<T>. Many of the dictionary type of methods could be adapted and used within this collection. You can download the sample code here. As always, any and all feedback is welcome!

I have been using Roland WeigeIt’s GhostDoc 2.1.3 for both Visual Studio 2005 and 2008 for about six months, and I am hooked. For those of you who have not heard of GhostDoc, here is the summary from Roland’s site:

GhostDoc is a free add-in for Visual Studio that automatically generates XML documentation comments for C#. Either by using existing documentation inherited from base classes or implemented interfaces, or by deducing comments from name and type of e.g. methods, properties or parameters.

It saves me so much time writing XML documentation in my code that there is no longer any excuse for any docs being missing. Documenting a piece of code is as simple as right-clicking on it and selcting ‘Document This’ (there is also a keyboard shortcut – CTRL-D is the default). The built-in rules for creating the comments are probably sufficient for most developers, but more advanced users can edit existing rules or add their own.

I have attached a small sample project containing some domain classes representing part of a pharmacy system. Here are a few examples of the XML documentation that is generated using GhostDoc’s default configuration. Some of the code is a bit contrived so that I could demonstrate different types of comments.

Documenting a Constructor

/// <summary>
/// Initializes a new instance of the <see cref="Drug"/> class.
/// </summary>
/// <param name="id">The id.</param>
public Drug(int id)
{
    LoadDrug(id);
}

Documenting a Dispose Method

/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
    // TODO: clean up resources
}

Documenting Properties

/// <summary>
/// Gets or sets the therapeutic categories.
/// </summary>
/// <value>The therapeutic categories.</value>
public List<DrugCategory> TherapeuticCategories { get; set; }

/// <summary>
/// Gets or sets the NDC.
/// </summary>
/// <value>The NDC.</value>
public string NDC { get; set; }

/// <summary>
/// Gets or sets a value indicating whether this instance is generic.
/// </summary>
/// <value>
///     <c>true</c> if this instance is generic; otherwise, <c>false</c>.
/// </value>
public bool IsGeneric { get; set; }

Documenting a Method

/// <summary>
/// Loads the drug.
/// </summary>
/// <param name="id">The id.</param>
private void LoadDrug(int id)
{
    // do nothing... just an example
}

Documenting an Inherited/Implemented Method

/// <summary>
/// Creates a new object that is a copy of the current instance.
/// </summary>
/// <returns>
/// A new object that is a copy of this instance.
/// </returns>
public object Clone()
{
    return MemberwiseClone();
}

Documenting an Overridden Method

/// <summary>
/// Returns a <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
/// </summary>
/// <returns>
/// A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
/// </returns>
public override string ToString()
{
    return String.Format("{0} {1}", Name, DoseRoute);
}

Documenting an Event

/// <summary>
/// Occurs when [allergy detected].
/// </summary>
public event EventHandler AllergyDetected;

As you can see, the default configuration of GhostDoc is pretty intelligent. Here are some shots of the rules configuration options provided by default:

(I added the shading in the second shot to mask options that were visible in the previous one.)

Users have the ability to change any of these existing rules or add their own. This post is just a brief overview of the product, so I won’t go into details on how to configure a rule at this time. Let me know if you would be interested in more posts that dive into more details on the configuration of GhostDoc.

If you don’t already use it, I encourage you to download it and give it a try. The learning curve is not steep and the benefits are great. Plus, it’s free! One more quick note, VB support is experimental at this time, and it is turned off by default. To enable it, go to the Options tab on the config screen.

GhostDoc download links are here.

My sample project (VS2008) can be downloaded here.