1public class Artist

  2{

  3    public int ArtistId { get; set; }

  4    public string Name { get; set; }

  5    public int Rank { get; set; }

  6}

Put the cursor somewhere in the body of a class that needs a constructor and press Alt/Ins (or use the Resharper>Code>Generate menu option). This displays Resharper’s Generate context menu (as shown below). Click “Constructor.”

Coding with Resharper is almost like pair programming but minus the gum-chewing, Jonas Brother-listening, obnoxious coder next to you.

This shows the Generate constructors dialog below. Select the members you want as arguments to the constructor with the checkboxes (selecting the class name selects all of the fields for use as constructor parameters). You can also select the access rights (public, private, et al) as well as whether you want an XML comment block added. Resharper is context sensitive–when using it to inject a constructor in an abstract class it’s smart enough to mark that constructor protected. Why? Read this. For my money, providing this level of awareness is how Resharper elevates itself from being a simple code paster to being a true ally in helping you write better code. It’s almost like pair programming but minus the gum-chewing, Jonas Brother listening, obnoxious coder next to you.

The “Advanced” button lets you specify what arguments are passed on to a base constructor (if any are available).

Assuming that the ArtistId and Name fields were selected, when you click “Finish” the constructor shown below is immediately added to the class.

  1public class Artist

  2{

  3    public Artist( string name, int artistId )

  4    {

  5        Name = name;

  6        ArtistId = artistId;

  7    }

  8

  9    public int ArtistId { get; set; }

 10    public string Name { get; set; }

 11    private int Rank { get; set; }

 12}

As you can see, Resharper makes it ridiculously easy to automate constructor creation, with optional parameters and value assignments. Although my examples show Resharper working with C#, there is a VB.NET version of Resharper available.

I once heard someone way that once you really get Linq, you’ll won’t ever need to write a For/Each loop again. Probably an overstatement, but still I was intrigued. I set out last night to see how Linq could negate the need for For/Each.

I set out to find a way to create ADO.NET connection strings. In the past, I would have probably used foreach to iterate over a collection using StringBuilder and String.Format to build up the connection string. I dispensed with all that old-school thought and created the connection string as shown below in Figure 1. As a bonus, I also learned (thanks to a little prompting from Resharper) a shortcut for initializing a collection.

The Linq code in lines 10 and 11 is where the cool stuff happens. Each element from the dictionary is selected to create a value pair and the Linq Aggregate() operator is used to concatenate all of the value pairs. All very sweet!

  1var o = new Dictionary< string, string >()

  2	{

  3		{ "Data Source",           "DUFFSQLSERVER2008" },

  4		{ "Initial Catalog",       "Chinook" },

  5		{ "Persist Security Info", "True" },

  6		{ "User ID",               "xxxxx" },

  7		{ "Password",              "xxxxx" }

  8	};    

  9

 10var ConnectionString = o.Select( i => i.Key + "=" + i.Value ).

 11                         Aggregate( ( a, b ) => a + ";" + b );

 12

 13Console.WriteLine( ConnectionString );

I used LinqPad to create and test this code. I just started using LinqPad and can’t believe I ever coded without it. Beyond being a great test bed for Linq, it is a superb snippet compiler. LinqPad is a free download and should be in every coder’s toolbox.

For example, the other day I worked on a task where the requirement was to be able to batch print documents (Word and Excel mostly, but also images). In this case, the PrintDialog wasn’t much help. I wanted to provide an easy way for users to select the target printer without all of the ceremony of the PrintDialog.

To perform this task, I wrote the code shown in Figure 1. It provides two classes:

• PrinterCommon. This class provides a GetInstalledPrintersList() method that returns an instance of a class that provides a string array of printer names and an integer value indicating which of the printers in the list is the default printer. (I named this class PrinterCommon because I intend later to add other common print tasks to it.)
• InstalledPrinters. This class is the result type returned from from GetInstalledPrinterList(). While I typically don’t like to put more than one class in a source member, given the tight coupling between PrinterCommon and InstalledPrinters, that seemed like an OK shortcut for this simple task.

  1using System;

  2using System.Drawing.Printing;

  3

  4namespace rp

  5{

  6    /// <summary>

  7    /// Common print and printer tasks.

  8    /// </summary>

  9    internal class PrinterCommon

 10    {

 11        /// <summary>

 12        /// Get the list of installed printers.

 13        /// </summary>

 14        /// <returns>An instance of InstalledPrinters.</returns>

 15        public static InstalledPrinters GetInstalledPrinterList()

 16        {

 17            // Get default printer name.

 18            string currentPrinter = new PrinterSettings().PrinterName;

 19

 20            // Declare a string array to store the list of installed printers.

 21            var installedPrinters =

 22                new string[ PrinterSettings.InstalledPrinters.Count ];

 23

 24            // Copy the list of installed printers into the installedPrinters

 25            // array (starting at element zero).

 26            PrinterSettings.InstalledPrinters.CopyTo( installedPrinters, 0 );

 27

 28            // Get index of default printer.

 29            int i = Array.IndexOf( installedPrinters, currentPrinter );

 30

 31            // Return with a new instance of InstalledPrinters.

 32            return new InstalledPrinters() { PrinterNames = installedPrinters, 

 33                                             SelectedPrinterIndex = i };

 34        }

 35    }

 36

 37    /// <summary>

 38    /// A simple class used to list the installed printers

 39    /// and the index in that list of the default printer.

 40    /// </summary>

 41    class InstalledPrinters

 42    {

 43        public string[] PrinterNames { get; set; }

 44        public int SelectedPrinterIndex { get; set; }

 45    }

 46}

The code to use the GetInstalledPrinterList() is very easy; it is shown below in Figure 2. Note that the Item’s AddRange() method is used to assign the array of printer names to the ComboBox (which also works with ListBox). While the code in Figure 2 is specific to Windows, a simple variation of it works just fine with browser-based applications.

  1rp.InstalledPrinters pl = rp.PrinterCommon.GetInstalledPrinterList();

  2

  3comboBox1.Items.AddRange( pl.PrinterNames );

  4comboBox1.SelectedIndex = pl.SelectedPrinterIndex;