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!

The gang over at Channel 9 have just released the first beta of their Visual Studio Achievements project. I tried it out last night and it’s very cool. Here’s what it’s all about:

Bring Some Game To Your Code!

A software engineer’s glory so often goes unnoticed. Attention seems to come either when there are bugs or when the final project ships. But rarely is a developer appreciated for all the nuances and subtleties of a piece of code–and all the heroics it took to write it. With Visual Studio Achievements Beta, your talents are recognized as you perform various coding feats, unlock achievements and earn badges.

You can read the full announcement here and grab the beta from the Visual Studio Gallery here.

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!

This hopefully goes without saying (Yes, I am saying it), but these licenses are not for resale. They have unique, traceable keys. Please enter the contests only if you really need the software and plan to give back to the community in some way as a result of winning.

Here are some things not included in these licenses, which would be available with a paid MSDN Ultimate subscription: MSDN Magazine, support calls, Office 2010 licenses.

Update: Office 2010 licenses are included for development and test purposes only.

Contest number one is simple. Send me an email at alashcraft [at] gmail [dot] com and explain (honestly) why you need the subscription and what you plan to do with the tools. Keep in mind that this is all about community. I will choose the winner based on need and community influence. I must receive your entry by Friday, July 9 at 8:00am EDT (UTC – 4) and will announce the winner at 12pm that same day.

For the second contest, I want to make things a little more challenging. Email me a .NET-related technical article to be published on alvinashcraft.com as a guest post. The content must be original, written by the submitter, and not available on any other web sites or blogs. Please include a short bio for yourself as well. All must should be emailed to alashcraft [at] gmail [dot] com, and they must be received no later than Friday, July 16 at 8:00am EDT (UTC – 4). I will select the winner that weekend and announce the winner on Monday, July 19th. If I receive an overwhelming number of great articles, I may dig up some smaller prizes for 2nd and 3rd place (probably books). The winning post will be published the week of the 19th.

I will do my best to scan my spam folder for entries, but please try not to mention Viagra, cheap meds, free Photoshop software or foreign bank accounts in your emails to me.

Any attempts to shamelessly promote my blog or Twitter account will have no effect on the outcome of the contests but are welcome nonetheless. 

If you have any questions, leave a comment, email me, or send me a reply on Twitter.

I will eventually get this posted to Studio Styles. Until then, here is a dark theme for Visual Studio that I created. The green and orange give it a Halo-ish feel. Let me know what you think in the comments.

Downloads

HaloVibe theme for VS2008

HaloVibe theme for VS2010