c#

Visual Studio 2010 beta2 + Framework 4.0

Bill Tudor — Sun, 25 Oct 2009 22:48:55 GMT

Visual Studio 2010 beta2 + Framework 4.0

. . . with a few comments on Windows Virtual PC.

Installation

I don’t “work” on my laptop – mostly used for travel, library, watching Hulu and channel 9, etc. Since I will be out of town for a while, however, I decided to install VS20101b2 in a winVPC for the trip on the laptop. The only complaint about the new VPC offering from Microsoft is that when it is running, it takes forever for my notebook to initiate sleep mode. I don’t recall the old product having this issue.

Installation of 2010 was a breeze, especially Team Foundation Server (holy crap is that a different experience!). The new icon needs work – looks very bad in the new Windows 7 taskbar with the default theme.

First Impressions

The first thing I did was fire up the VM and connect to TFS server – all running on the laptop – in a 1GB VM, I might add. I create a new team project (‘TestProject’). This all worked. I seem to remember several days before I was able to accomplish this on tfs2005, and at least a few hours on tfs2008. Today’s elapsed time is a couple of minutes (for the TFS part).

Overall, I found a snappy IDE that has a finished feel to it. Nice. March release should be no problem.

Branching and Merging

I setup the TestProject with a typical branching and merging strategy (dev/main/prod), added a few work items and a bug, and got to work.

[ Note: I like the little ‘Save’ icon – saves a picture of the visualization] There seem to be lots of tools accessible from this UI, such as branch compare tools. Overall, this visualizer is a nice feature (the simple picture shown does not do justice). I’m still looking for the merge visualizations (update: found them!). I’d like to see merge arrows that are labeled per the changeset description and clickable to show history/changeset details for merges. It looks like I’ve got some exploring to do.

Team Web Access

I was not expecting this. Even in the Basic product running on a local client OS. Nice touch. It’s a beautiful source, work item, project browser web application. Who needs SharePoint?

New in Framework

I’ve already blogged a few times about changes in the Framework 4.0 beta. A few more in this release:

DLR library
Several more threading primitives
System.Collections.Concurrent namespace
MEF improvements
In-process side-x-side CLR

Static Reflection in .Net

Bill Tudor — Mon, 12 Oct 2009 17:08:21 GMT

Static Reflection in .Net

Where have I been?

I recently took a few minutes to look through the latest MSDN magazine and ran across a nice article by Jeremy Miller on “Functional Programming for Everyday .NET Development”. The section titled “Lambdas as Data” was my first introduction to static reflection in .Net. Where the heck have I been? I don’t write database persistence code, so I am not familiar with NHibernate (or fluent NHibernate) (which is where Jeremy’s sample comes from), but I am still surprised at how little I understand about everything Linq brought to the .Net party. A quick search around the internet reveals this topic is well-covered, and several years old.

Example Code

Suppose you have a need to dynamically discover properties on an object. Easy, right? After all, that’s what the System.Reflection namespaces is for! However..

Let’s look at a class named “SomeObject” with a property “SomeProperty”:

class SomeObject

    public string SomeProperty { get; set; }

You can use so-called “static reflection” like this:

   1: class Program

   2: {

   3:     static void Main(string[] args)

   4:     {

   5:         SomeObject o = new SomeObject()

   6:         {

   7:             SomeProperty = "Test"

   8:         };

   9:         staticReflection(o, e => e.SomeProperty);

  10:         Console.ReadKey();

  11:     }

  12:     static void staticReflection<T>(T o, Expression<Func<T,object>> expression)

  13:     {

  14:         MemberExpression me = expression.Body as MemberExpression;

  15:         if (me != null && me.Member.MemberType == System.Reflection.MemberTypes.Property)

  16:         {

  17:             Console.WriteLine("Property: '{0}' of type '{1}' has value '{2}'.",

  18:                 me.Member.Name,

  19:                 expression.Body.Type,

  20:                 expression.Compile().Invoke(o)

  21:                 );

  22:         }

  23:     }

  24: }

The output is:

Property: 'SomeProperty' of type 'System.String' has value 'Test'.

Very cool. Now I need to understand why the second argument has to be something like Expression<Func<T, object>> rather than simply Expression<T>. If the latter is used, the compiler rewards me with:

Error 1 Cannot convert lambda to an expression tree whose type argument 'StaticReflection.SomeObject' is not a delegate type

It’s the whole “return type” thing on the delegate that throws me as well – where does that come from? In my code sample I have declared the Func return type as type “object” (it is actually a string in my case). Why don’t I have to do something like “e => {return e.SomeProperty;}”, and how come a lambda expression with a statement body like that cannot be converted into an expression tree (compiler’s words, not mine)?

I still have a little more learning to do before really understanding what’s going on here. My suspicion is that Linq brought a heck of a lot more to the party than it might appear at first look.

Running Command Line Tools from .Net

Bill Tudor — Tue, 22 Sep 2009 09:36:27 GMT

The Process class in .Net makes it easy to run command line tools from within a .Net program. Here is an implementation with a couple of twists:

Environment variable expansion
Optional asynchronous execution
Transformation of output into an enumerable collection of objects

The implementation takes the form of an object named CommandLineTool with the following constructors:

public CommandLineTool(string command)
    : this(command, String.Empty, Environment.CurrentDirectory, _defaultTransform) { }
public CommandLineTool(string command, string arguments)
    : this(command, arguments, Environment.CurrentDirectory, _defaultTransform) { }
public CommandLineTool(string command, string arguments, string workingDirectory)
    : this(command, arguments, workingDirectory, _defaultTransform) { }
public CommandLineTool(string command, string arguments, string workingDirectory, Func<string, object> transform)
{
    this.Command = Environment.ExpandEnvironmentVariables(command);
    this.Arguments = Environment.ExpandEnvironmentVariables(arguments);
    this.WorkingDirectory = Environment.ExpandEnvironmentVariables(workingDirectory);
    this.Transform = transform;
    _isBusy = false;
}

The simplest form provides for an executable filename only, while the last constructor accepts arguments, working directory, and transformation function for the output lines. Note that environment variables, such as "%ComSpec%, may be included in any of the first three arguments.

Output Transformation

Each line of output (strings) can be sent to a transformation function, defined as a Func<string, object>, and returned as an enumerable collection of objects (IEnumerable<Object>) accessed via the OutputObjects property. Output can also be expressed as a single string (Output) or an array of lines of text (OutputLines). These are exposed as properties. The transformation function is free to return null to exclude an item from the OutputObjects collection.

   1: /// <summary>

   2: /// Command output.

   3: /// </summary>

   4: public string Output { get; private set; }

   5: /// <summary>

   6: /// Command output lines.

   7: /// </summary>

   8: public string [] OutputLines

   9: {

  10:     get

  11:     {

  12:         if (Output != null)

  13:         {

  14:             return Output.Split(_seperators, StringSplitOptions.RemoveEmptyEntries);

  15:         }

  16:         return null;

  17:     }

  18: }

  19: /// <summary>

  20: /// Output Objects.

  21: /// </summary>

  22: /// <remarks>

  23: /// Output lines are converted to output objects using the transform

  24: /// function. The default transform functions results in an enumeration

  25: /// of the out lines (strings).

  26: /// </remarks>

  27: public IEnumerable<Object> OutputObjects

  28: {

  29:     get

  30:     {

  31:         if (Transform != null)

  32:         {

  33:             return OutputLines.Select(Transform).Where(o => o != null);

  34:         }

  35:         return null;

  36:     }

  37: }

Asynchronous and Synchronous Operation

Both asynchronous and synchronous modes of operation are provided. An event (ExecuteCompleted) is raised following the completion of an asynchronous execution. Overloads are provided for both the Execute() and ExecuteAsync() methods to allow for an alternate transformation function to be applied in successive calls. Only one asynchronous operation at a time is allowed. The asynchronous version simply calls on the synchronous version using a background thread from the thread pool. Error output is provided in a similar manner to standard output, except that there is no option for transformation of lines of text on the error output to objects.

   1: /// <summary>

   2: /// Execute the command.

   3: /// </summary>

   4: /// <param name="transform">Transform to apply to the output.</param>

   5: /// <returns>Command result.</returns>

   6: public int Execute(Func<string, object> transform)

   7: {

   8:     this.Transform = transform;

   9:     return Execute();

  10: }

  11: /// <summary>

  12: /// Executes the command.

  13: /// </summary>

  14: /// <returns>Command result.</returns>

  15: public int Execute()

  16: {

  17:     ProcessStartInfo info = new ProcessStartInfo();

  18:     info.FileName = this.Command;

  19:     info.Arguments = this.Arguments;

  20:     info.WorkingDirectory = this.WorkingDirectory;

  21:     info.CreateNoWindow = true;

  22:     info.UseShellExecute = false;

  23:     info.RedirectStandardError = true;

  24:     info.RedirectStandardOutput = true;

  25:     Process p = Process.Start(info);

  26:     Output = p.StandardOutput.ReadToEnd();

  27:     ErrorOutput = p.StandardError.ReadToEnd();

  28:     return p.ExitCode;

  29: }

  30: /// <summary>

  31: /// Execute the command asynchronously.

  32: /// </summary>

  33: /// <param name="transform">Transform to apply to the output.</param>

  34: public void ExecuteAsync(Func<string, object> transform)

  35: {

  36:     this.Transform = transform;

  37:     ExecuteAsync();

  38: }

  39: /// <summary>

  40: /// Execute the command asynchronously.

  41: /// </summary>

  42: public void ExecuteAsync()

  43: {

  44:     lock (this)

  45:     {

  46:         if (!_isBusy)

  47:         {

  48:             _isBusy = true;

  49:             ThreadPool.QueueUserWorkItem((WaitCallback)((state) =>

  50:             {

  51:                 int result = Execute();

  52:                 if (ExecuteCompleted != null)

  53:                 {

  54:                     ExecuteCompleted(this, EventArgs.Empty);

  55:                 }

  56:                 lock (this)

  57:                 {

  58:                     _isBusy = false;

  59:                 }

  60:             }));

  61:         }

  62:         else

  63:         {

  64:             throw new InvalidOperationException("Async operation in progress.");

  65:         }

  66:     }

  67: }

Using the Code

Using the code is fairly easy. Just create a new CommandLineTool object and call either the Execute() or ExecuteAsync() methods. Here is a snippet from one of the unit tests:

   1: string command = "cmd.exe";

   2: string arguments = "/c dir";

   3: CommandLineTool target = new CommandLineTool(command, arguments);

   4: int expected = 0;

   5: int actual;

   6: actual = target.Execute();

   7: Assert.AreEqual(expected, actual);

A more involved example (somewhat contrived) includes transformation of the results and asynchronous operations. [Results are transformed into FileObject objects].

   1: // The FileObject class ...

   2: internal class FileObject

   3: {

   4:     public DateTime ModifiedDate { get; set; }

   5:     public string Name { get; set; }

   6: }

7:

   8: // Code ...

9:

  10:     string command = "cmd.exe";

  11:     string arguments = "/c dir /s";

  12:     Func<string, object> transform = new Func<string, object>(s =>

  13:         {

  14:             DateTime modified = DateTime.MaxValue;

  15:             if (s.Length > 39 && DateTime.TryParse(s.Substring(0, 20), out modified))

  16:             {

  17:                 return new FileObject()

  18:                 {

  19:                     ModifiedDate = modified,

  20:                     Name = s.Substring(39)

  21:                 };

  22:             }

  23:             return null;

  24:         });

  25:     CommandLineTool target = new CommandLineTool(command, arguments);

  26:     target.ExecuteAsync(transform);

  27:     while (target.IsBusy) Thread.Sleep(0);

28:

  29:     List<FileObject> files = target.OutputObjects.Cast<FileObject>().ToList();

30:

  31:     ... etc ...

Hope this comes in handy for someone. Let me know if you see any errors/problems or room for improvement.