My code starts like this:

public static List<DbProgressReport> DbProgressReportProperty { get; set; }

Then, I try wrapping the updates with a lock as follows (removing the set because I do it someplace else now)

public static List<DbProgressReport> DbProgressReportProperty
{
    get
    {
        lock (lockDbProgressReportProperty)
        {
            return _dbProgressReportList;
        }
    }
}

I then realize that I need to copy the data because it may change while the caller prints it so I decide to return a temporary copy of the data as follows:

public static List<DbProgressReport> DbProgressReportProperty
{
    get
    {
        lock (lockDbProgressReportProperty)
        {
            var dbProgressReportsNew = new List<DbProgressReport>();
            if (_dbProgressReportList != null)
            {
                // make temp copy to avoid locking issues on read
                foreach (var rec in _dbProgressReportList)
                {
                    dbProgressReportsNew.Add(rec);
                }
            }
            return dbProgressReportsNew;
        }
    }
}

I then notice that ReSharper has a suggestion.

Taking the suggestion, Resharper changes the code to:

lock (lockDbProgressReportProperty)
{
    // make temp copy to avoid locking issues on 
    return _dbProgressReportList.ToList();
}

Before I go into the details, I’d just like to disclose that when I was first writing the Silicon Valley Code Camp web site, I was an asp.net and c# newby.  I’m not claiming wizard status now, but I have to admit that when I go back and look at some of the code I wrote back then (including what I’m showing below before the refactoring), it’s a little embarrassing.  Silicon Valley Code Camp for me as “when I’m not doing real work” web site so I don’t really have the time to go back and clean things up.  Now, with CodeRush, it’s easy to clean things up when I see them with very little effort.

Introduce Using Statement Refactoring

Here is the code I wrote 5+ years ago:

SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

// First, make a quick list of counts for each id that is unavailable and show
// not be shown
string selectCount = @"select VistaSlotsId FROM attendees 
                     WHERE VistaSlotsId >= 2 AND VistaSlotsId <= 5 Group By VistaSlotsId 
                     HAVING COUNT(*) >= @MaxPerSlot  ";
List<int> unavailableSlotsList = new List<int>();
SqlDataReader readerUnavailable = null;
SqlCommand cmdUnAvailable = new SqlCommand(selectCount, conn);
cmdUnAvailable.Parameters.Add("@MaxPerSlot", SqlDbType.Int).Value = maxPerSlot;
readerUnavailable = cmdUnAvailable.ExecuteReader();
try
{
    while (readerUnavailable.Read())
    {
        int id = readerUnavailable.GetInt32(0);
        unavailableSlotsList.Add(id);
    }
}
finally
{
    if (readerUnavailable != null) readerUnavailable.Close();
}

By placing the cursor over the “conn” on the top line of the code above, CodeRush gives us the following result:

There are actually quite a few things happening here.

1. It is showing us in the top textbox what the using syntax will be
2. It is crossing out the lines of code it will change
3. It is teaching us a little about the using statement

If I accept the changes, I get a nice refactoring.  I can continue doing this with “using” for SqlCommand and SqlReader.  I did need to move the SqlReader declaration inside the SqlCommand codeblock for this to work.  Here is the final refactored code that took about 10 seconds.  By hand, I’d say it would have taken me 3 minutes and I may have gotten it wrong which is why I would never do it before.  Now, I’m confident I did not break my code.

using (SqlConnection conn = new SqlConnection(connectionString))
{
    conn.Open();
    // First, make a quick list of counts for each id that is unavailable and show
    // not be shown
    string selectCount = @"select VistaSlotsId FROM attendees 
                                 WHERE VistaSlotsId >= 2 AND VistaSlotsId <= 5 Group By VistaSlotsId 
                                 HAVING COUNT(*) >= @MaxPerSlot  ";
    List<int> unavailableSlotsList = new List<int>();
    using (SqlCommand cmdUnAvailable = new SqlCommand(selectCount, conn))
    {
        cmdUnAvailable.Parameters.Add("@MaxPerSlot", SqlDbType.Int).Value = maxPerSlot;
        using (SqlDataReader readerUnavailable = cmdUnAvailable.ExecuteReader())
        {
            try
            {
                while (readerUnavailable.Read())
                {
                    int id = readerUnavailable.GetInt32(0);
                    unavailableSlotsList.Add(id);
                }
            }
            finally
            {
                if (readerUnavailable != null)
                    readerUnavailable.Close();
            }
        }
    }

Compress To Lambda Expression Refactoring

A lot of the Silicon Valley Code Camp web site was written prior to the introduction of Lamba Expressions.  If you recall, I wrote an MSDN article back in 2006 entitled Adding Personalization via Profiles to the ObjectDataSource in ASP.NET 2.0.  Ted Neward inspired a construct to cleverly sort the result list using delegates as shown in the screen shot (form that above post).

The code below is similar to the above but not quite the same.  This is how it looks before the refactoring:

Comparison<DataObjectSessionsOverview> comparison = null;
    switch (sortDataBase)
    {
        case "Userfirstname":
            comparison = new Comparison<DataObjectSessionsOverview>(
               delegate(DataObjectSessionsOverview lhs, DataObjectSessionsOverview rhs)
               {
                   return lhs.Userfirstname.CompareTo(rhs.Userfirstname);
               }
             );
            break;

CodeRush suggests:

Which then give us:

switch (sortDataBase)
{
   case "Userfirstname":
       comparison = (lhs, rhs) => lhs.Userfirstname.CompareTo(rhs.Userfirstname);
       break;

I like it!

So, say you have code like this:

var sessionAttendeeOds = 
  new SessionAttendeeODS();
listSessionAttendees = 
  sessionAttendeeOds.GetByUsername(Context.User.Identity.Name);

When I chose “InlineTemp”, the code changes to the following, make it easier to read.

listSessionAttendees = 
                new SessionAttendeeODS().GetByUsername(Context.User.Identity.Name);

Again, this is not a huge deal, but small fixes like this will add up over time and make my code cleaner and more readable.  CodeRush makes it so easy that I’m sure I’ll do this kind of thing more and more.

HTH’s.

In my original code, I had the following code that called the method GetLoadResultsFromInterval.

List<LoadResult> loadResultsForInterval =
    GetLoadResultsForInterval(rec.TimePoint,
                              rec.IntervalLengthInMs);

Then, I simply added one more parameter (loadFtpArrivalTimeDictionary) and ReSharper prompted me with the following:

If I choose the first “Add Parameter, I get what I would expect, which is just the method with an extra parameter.

/// </summary>
/// <param name="timePoint"></param>
/// <param name="intervalLengthInMs"></param>
/// <param name="loadFtpArrivalTimeDictionary"></param>
/// <returns></returns>
private static List<LoadResult> 
   GetLoadResultsForInterval(DateTime timePoint, 
   int intervalLengthInMs, 
   Dictionary<string, DateTime> loadFtpArrivalTimeDictionary)
{
   throw new NotImplementedException();
}

It even adds the param xml definition automatically.

However, I’m not quite as pleased with the second refactoring, that is, “Create Overload”.  It does almost everything I would expect, but does not implement the method, which I think it could.  Or, at least it could give it a try.  What it does implement is the following:

I’m actually including a picture of it rather than the actual code because it created an error.  It should have said DateTime instead of loadFtpArrivalTimeDictionary.  Two other things of interest.

First, it did not add xml comments (which is probably because of the syntax error), and second, I would have expected it to have called the overloaded method as follows instead of what it did.

private static List<LoadResult> GetLoadResultsForInterval(DateTime timePoint,
    int intervalLengthInMs, 
    Dictionary<string, DateTime> loadFtpArrivalTimeDictionary)
{
    // - put additional code here
    return GetLoadResultsForInterval(timePoint, intervalLengthInMs);
}

I began this post to brag about yet another awesome ReSharper refactoring because I really just wanted to add a parameter to an existing method call and it worked perfect.  It was not until I decided to show the other refactoring for this blog post did I run into the problem. 

I’m going to post this to the refactor dev’s and see if they can let me know where either I’ve gone astray, or there is a problem in their code.  At any rate, I’m running this on vs2008 and have not tried it on vs2010.

Hope this helps!

if (doDeficitCalc)

{

    throw 

        new ApplicationException("Need to implement deficit weight rating");

}

else

{

    // Linear interpolation from top of range to bottom for speed

    double x1 = rateBreakList[0];

    double x2 = rateBreakList[rateBreakList.Count - 1];

    double y1 = rateList[0];

    double y2 = rateList[rateList.Count - 1];

    double frac = weight/(x2 - x1);

    double yResult = y1 + (frac*(y2 - y1));

    retWeight = yResult;

}

ReSharper correctly warns me that the else statement is redundant as shown below:

So, if I hover over the “if” statement, I get the chance to invert the if clause

When I accept the invert if, I now get:

if (!doDeficitCalc)

{

    // Linear interpolation from top of range to bottom for speed

    double x1 = rateBreakList[0];

    double x2 = rateBreakList[rateBreakList.Count - 1];

    double y1 = rateList[0];

    double y2 = rateList[rateList.Count - 1];

    double frac = weight/(x2 - x1);

    double yResult = y1 + (frac*(y2 - y1));

    retWeight = yResult;

}

else

{

    throw

        new ApplicationException("Need to implement deficit weight rating");

}

Which has no warning!!!  Just what I wanted with less key strokes.

Thank you again ReSharper!