.NET

FireFox 3.0 Will Support Microsoft CardSpace

Shaun — Wed, 11 Jul 2007 22:11:37 GMT

That is great news as Microsoft and FireFox are really starting to work together:

Sweet App

Shaun — Tue, 10 Jul 2007 18:31:37 GMT

Control your Windows Mobile Device from your PC. I have been looking for something like this for quite some time and it is finally here:

http://www.mymobiler.com/

"One Millionnnn Dolllarrs...."

Shaun — Tue, 10 Jul 2007 08:41:28 GMT

Microsoft LifeCam Drivers Now Available for Windows Vista (32 and 64 bit)

Shaun — Wed, 24 Jan 2007 17:58:00 GMT

After a long wait period, the Microsoft LifeCam drivers are now available for Windows Vista including both 32-bit and 64-bit platforms. You can get them here:

http://www.microsoft.com/hardware/windowsvista/support.mspx

All of my hardware is now officially supported by Windows Vista. Nice.

Blogging for the Orlando Sentinel

Shaun — Thu, 11 Jan 2007 20:17:05 GMT

For those interested in reading things outside of programming and software architecture, I have started blogging for the Orlando Sentinel. You can read the posts here:

Orlando Sentinel Apopka Community

DVD+-RW / DVD-RW stops working or loses functionality in Windows Vista.

Shaun — Wed, 10 Jan 2007 09:15:00 GMT

I recently purchased a nice new Dell for my wife as her Christmas present. I installed Windows Vista Ultimate as the OS and everything was working great. Then, I realized that the TsstCorp DVD+-RW drive that came with the system was not being correctly recognized and only had functionality as a CD-ROM Drive.

That was very annoying.

After much research and attempting to delete UpperFilters/LowerFilters/AirFilters/VoiceFilters or whatever, I decided to look at what had been installed on the system since the original installation of Vista.

The culpit -- iTunes.

It turns out that Apple iTunes has its own CD/DVD Burning engine that comes with the entire package. This engine is not yet compatible with Windows Vista but the great people at Apple say they will have updated and compatible Vista drivers when Microsoft launches the new OS in the retail sector.

So, I uninstalled iTunes and all of a sudden my TsstCorp DVD+-RW drive was back.

Annoying.

Irena Kennedy: Tool Goddess

Shaun — Mon, 30 Oct 2006 06:25:00 GMT

I am a regular vistor of Irena Kennedy's blog 'Something You Should Know"

She knows to make the tools work for us. Check out her latest article:

http://blogs.msdn.com/irenak/archive/2006/10/27/sysk-228-get-table-columns-or-rows-with-single-key-press.aspx

One Set of Footprints in Your App

Shaun — Fri, 01 Sep 2006 00:30:00 GMT

Irena Kennedy has some interesting things to say about Sql Server 2005 Everywhere Edition and how "compact" it truly is. The footprint is larger than you think:

http://blogs.msdn.com/irenak/archive/2006/08/31/733527.aspx

MsBuild: Custom Task: Drive Mapper

Shaun — Fri, 18 Aug 2006 19:03:43 GMT

For those not familiar with MsBuild, it is Microsoft's Build Engine that comes with the .NET 2.0 Framework. It is a highly flexible and highly reusable framework that makes it possible to build almost any type of software and deploy any type of product. Personally, I think it is an excellent tool.

One common task that I have wanted to perform in MsBuild is drive mapping. If I could have a Custom MsBuild Task that would map a drive letter to a UNC path, I could deploy my application to anywhere within my subnet (testing, staging, and even production). So, recently, I set out to create that Custom MsBuild Task and here are the results and the code that I wrote.

First off, in order to create an Custom MsBuild Task, you have to inherit from Microsoft.Build.Utilities.Task and then implement the bool Execute() member method required by the base class.

In order to use the Win32 functions that map and unmap drives. We're going to have to use Platform Invoke (P/Invoke). The three platform methods that I use are (click on the function will take you to its documentation):

Take a look at my implementations of the above methods in C#

 [DllImport("mpr.dll")] 
 public static extern int WNetAddConnection2A
 ( 
      [MarshalAs(UnmanagedType.LPArray)] NETRESOURCEA[] lpNetResource, 
      [MarshalAs(UnmanagedType.LPStr)] string lpPassword, 
      [MarshalAs(UnmanagedType.LPStr)] string UserName, int dwFlags
 );

[StructLayout(LayoutKind.Sequential)]
public struct NETRESOURCEA
{
     public int dwScope;
     public int dwType;
     public int dwDisplayType;
     public int dwUsage;
     [MarshalAs(UnmanagedType.LPStr)]
     public string lpLocalName;
     [MarshalAs(UnmanagedType.LPStr)]
     public string lpRemoteName;
     [MarshalAs(UnmanagedType.LPStr)]
     public string lpComment;
     [MarshalAs(UnmanagedType.LPStr)]
     public string lpProvider;
     public override string ToString()
     {
         string str = "LocalName: " + lpLocalName + " RemoteName: " + lpRemoteName
         + " Comment: " + lpComment + " lpProvider: " + lpProvider;
         return (str);
     }
 }

[DllImport("mpr.dll")]
public static extern int WNetCancelConnection2A
(
   [MarshalAs(UnmanagedType.LPStr)] string lpName,
   int dwFlags,
   bool fForce
);

[DllImport("Kernel32.dll")]
public static extern int FormatMessage
(
   int dwFlags,
   IntPtr lpSource,
   int dwMessageID,
   int dwLanguageID,
   StringBuilder lpBuffer,
   int nSize,
   IntPtr arguments
 );

Together, all of these methods will do the following:

Map a Drive
Unmap a Drive
Display an Error Message returned by the operating system if the map fails.

Now that we have all of these methods in place, we need to create properties to be used within the MsBuild Xml file for our task. Here is the code for those properties:

        [Required]
        public bool RemoveIfExists
        {
            get
            {
                return _RemoveIfExists;
            }
            set
            {
                _RemoveIfExists = value;
            }
        }


        [Required]
        public string Path
        {
            get
            {
                return _Path;
            }
            set
            {
                _Path = value;
            }
        }

        [Required]
        public string DriveLetter
        {
            get
            {
                return _DriveLetter;
            }
            set
            {
                _DriveLetter = value;
            }
        }

Then, we need to have some methods that will make calling the external methods above a little bit smoother:

        protected int MapDrive()
        { 
            NETRESOURCEA[] resources    = new NETRESOURCEA[1];
            resources[0]                = new NETRESOURCEA();
            resources[0].dwType = 1;
            int dwFlags = 1;
            resources[0].lpLocalName = _DriveLetter;
            resources[0].lpRemoteName = _Path;
            resources[0].lpProvider = null;

            int ret = WNetAddConnection2A(resources, null, null, dwFlags);
            return ret;
        }

        protected int UnmapDrive()
        {
            int ret = WNetCancelConnection2A(_DriveLetter, 0, true);
            return ret;
        }

Lastly, we need to implement the execute method because it is the method that will be executed by MsBuild:

        public override bool Execute()
        {
            int ret = MapDrive();
            int ret3 = 0;
            bool success = false;
            StringBuilder message = new StringBuilder(500);
            int messageId = FormatMessage(4096, IntPtr.Zero, ret, 0, message, 500, IntPtr.Zero);
            Log.LogMessage("Format Message Result:  {0}", new object[] { ret });
            Log.LogMessage("Mapping Result: {0}", new object[] { message.ToString() });

            if (ret == 85 && RemoveIfExists)
            {
                int ret2 = UnmapDrive();
                StringBuilder unmapMessage = new StringBuilder(500);
                FormatMessage(4096, IntPtr.Zero, ret2, 0, unmapMessage, 500, IntPtr.Zero);
                Log.LogMessage("Format Message Result:  {0}", new object[] { ret2 });
                Log.LogMessage("Unmapping Result: {0}", new object[] { unmapMessage.ToString() });

                ret3 = MapDrive();
                StringBuilder mapMessage = new StringBuilder(500);
                int mapMessageId = FormatMessage(4096, IntPtr.Zero, ret3, 0, mapMessage, 500, IntPtr.Zero);
                Log.LogMessage("Format Message Result:  {0}", new object[] { ret3 });
                Log.LogMessage("Second Mapping Result: {0}", new object[] { mapMessage.ToString() });
                success = !(ret3 > 85);
            }
            else
            {
                success = !(ret > 0);
            }

            return success;
           
        }

Here's a look at all of the code combined:

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Build.Utilities;
using Microsoft.Build.Framework;
using System.Runtime.InteropServices;

namespace ExcellenceInSoftware.MsBuild.Tasks
{
    [StructLayout(LayoutKind.Sequential)]
    public struct NETRESOURCEA
    {
        public int dwScope;
        public int dwType;
        public int dwDisplayType;
        public int dwUsage;
        [MarshalAs(UnmanagedType.LPStr)]
        public string lpLocalName;
        [MarshalAs(UnmanagedType.LPStr)]
        public string lpRemoteName;
        [MarshalAs(UnmanagedType.LPStr)]
        public string lpComment;
        [MarshalAs(UnmanagedType.LPStr)]
        public string lpProvider;
        public override string ToString()
        {
            string str = "LocalName: " + lpLocalName + " RemoteName: " + lpRemoteName
            + " Comment: " + lpComment + " lpProvider: " + lpProvider;
            return (str);
        }
    } 


    public class MapDriveTask : Microsoft.Build.Utilities.Task
    {
        protected string _Path              = String.Empty;
        protected string _DriveLetter       = String.Empty;
        protected bool _RemoveIfExists      = false;

        [DllImport("mpr.dll")] 
        public static extern int WNetAddConnection2A
            ( 
                [MarshalAs(UnmanagedType.LPArray)] NETRESOURCEA[] lpNetResource, 
                [MarshalAs(UnmanagedType.LPStr)] string lpPassword, 
                [MarshalAs(UnmanagedType.LPStr)] string UserName, int dwFlags
             );

        [DllImport("mpr.dll")]
        public static extern int WNetCancelConnection2A
            (
                [MarshalAs(UnmanagedType.LPStr)] string lpName,
                int dwFlags,
                bool fForce
            );

        [DllImport("Kernel32.dll")]
        public static extern int FormatMessage
            (
            int dwFlags,
            IntPtr lpSource,
            int dwMessageID,
            int dwLanguageID,
            StringBuilder lpBuffer,
            int nSize,
            IntPtr arguments
            ); 


        [Required]
        public bool RemoveIfExists
        {
            get
            {
                return _RemoveIfExists;
            }
            set
            {
                _RemoveIfExists = value;
            }
        }


        [Required]
        public string Path
        {
            get
            {
                return _Path;
            }
            set
            {
                _Path = value;
            }
        }

        [Required]
        public string DriveLetter
        {
            get
            {
                return _DriveLetter;
            }
            set
            {
                _DriveLetter = value;
            }
        }

        protected int MapDrive()
        { 
            NETRESOURCEA[] resources    = new NETRESOURCEA[1];
            resources[0]                = new NETRESOURCEA();
            resources[0].dwType = 1;
            int dwFlags = 1;
            resources[0].lpLocalName = _DriveLetter;
            resources[0].lpRemoteName = _Path;
            resources[0].lpProvider = null;

            int ret = WNetAddConnection2A(resources, null, null, dwFlags);
            return ret;
        }

        protected int UnmapDrive()
        {
            int ret = WNetCancelConnection2A(_DriveLetter, 0, true);
            return ret;
        }

        public override bool Execute()
        {
            int ret = MapDrive();
            int ret3 = 0;
            bool success = false;
            StringBuilder message = new StringBuilder(500);
            int messageId = FormatMessage(4096, IntPtr.Zero, ret, 0, message, 500, IntPtr.Zero);
            Log.LogMessage("Format Message Result:  {0}", new object[] { ret });
            Log.LogMessage("Mapping Result: {0}", new object[] { message.ToString() });

            if (ret == 85 && RemoveIfExists)
            {
                int ret2 = UnmapDrive();
                StringBuilder unmapMessage = new StringBuilder(500);
                FormatMessage(4096, IntPtr.Zero, ret2, 0, unmapMessage, 500, IntPtr.Zero);
                Log.LogMessage("Format Message Result:  {0}", new object[] { ret2 });
                Log.LogMessage("Unmapping Result: {0}", new object[] { unmapMessage.ToString() });

                ret3 = MapDrive();
                StringBuilder mapMessage = new StringBuilder(500);
                int mapMessageId = FormatMessage(4096, IntPtr.Zero, ret3, 0, mapMessage, 500, IntPtr.Zero);
                Log.LogMessage("Format Message Result:  {0}", new object[] { ret3 });
                Log.LogMessage("Second Mapping Result: {0}", new object[] { mapMessage.ToString() });
                success = !(ret3 > 85);
            }
            else
            {
                success = !(ret > 0);
            }

            return success;
           
        }
    }
}

If you compile this code, you can then use this task in your MsBuild Xml file like so:

<?xml version="1.0" encoding="utf-8" ?>
<Project DefaultTargets="MyTarget" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <UsingTask AssemblyFile="ExcellenceInSoftware.MsBuild.Tasks.dll" TaskName="ExcellenceInSoftware.MsBuild.Tasks.MapDriveTask" />
    <Target Name="MyTarget">
        <MapDriveTask Path="\\coke\Projects" DriveLetter="Z:" RemoveIfExists="true" />
    </Target>
</Project>

There you have it. MsBuild is going to make life a whole alot easier when it comes to building, compiling, and deploying.

Anonymous Predicates :: Anonymous Actions - Pred's a Whaticate extra.

Shaun — Tue, 15 Aug 2006 08:08:00 GMT

A commentator on my last series of posts requested some information on how to use anonymous methods within predicates. So, here goes:

For the sake of review, let's take a quick look at what an anonymous method is in .NET 2.0 (a strict 2.0 feature).

Basically, an anonymous method is a method that has no name and therefore it is anonymous. That should wrap this post up. Tune in tomorrow.

Just kidding.

First off, you need to have a good understanding of delegates to know what an anonymous method can do for you. In short, a delegate is a pointer to a method that is typically used within events or executing code across different threads.

However, the downside to a delegate is that sometimes I found myself creating a method just for the purpose of being referenced by a delegate. That got annoying because the method served no purpose outside of its respective delegate. So, let's check out how we can use an anonymous method within the declaration of a predicate:

private Predicate<Employee> accounting = delegate(Employee e)
{
   return (e.Department == "Accounting");
};

This almost looks the same as what we had previously declared in part 1 of my previous post except you can see that rather than have the accounting Predicate point to the 'IsInAccountingDepartment' method, we actually have the method code inside that accounting Predicate itself using the brackets. Thus, the code used in the IsInAccountDepartment method is now actually part of the Predicate signature.

This exact same design can be used within Actions as well.

TickSpot - By the Mole Hill

Shaun — Mon, 14 Aug 2006 18:45:00 GMT

I am never ceased to be amazed by my friend Tom Rossi who runs a company called The Mole Hill out of Jacksonville, Florida.

Honestly, when he told me that he was switching to the Ruby on Rails development platform I knew he had lost it.

He proved me wrong 100 times over.

Their first application called 'TickSpot' has taken off. Tick is a simple time tracking application that helps you hit your budgets. It has received recognition from CNET and is already running over 2000 users in its current beta state. It is a thoroughly impressive application that makes use of some extremely agile technologies.

Not only is Tick an application but I think it will soon become a leader of a new development philosophy. Check out some of these posts at their blog:

How Should We Think About Time in the Service Industry

Beginner's Guide: Model - View - Controller Architecture

Beginner's Guide: Setting Up Ruby on Windows

I, for one, believe The Mole Hill is going to create a new software paradigm for us developers because of the innovative ideas of its owners. Sooner or later it is very possible for Enterprise Applications to be developed within Ruby (especially as computers become faster and can handle larger footprints).

As .NET Developers it is critical we move outside of our application domains as to not hinder our own innovation. People want new ideas and desire to participate in products such as Tick because ... well ... it's just fun.

Another Sweet Tool

Shaun — Mon, 14 Aug 2006 18:27:00 GMT

An incredible tool for your VPC's (Hat Tip: Andrew Connell):

http://andrewconnell.com/blog/archive/2006/08/14/3361.aspx

SQL Express Backups

Shaun — Mon, 14 Aug 2006 04:22:00 GMT

I have been looking for something like this for a long time:

http://www.whiteknighttechnology.com/cs/blogs/brian_knight/archive/2006/08/13/215.aspx

White Knight Technology finally created one that is actually quite useful.

Pred is a whaticate? Generics on Steroids - Part II of II

Shaun — Sun, 13 Aug 2006 18:32:00 GMT

If your application has a requirement that a certain number of user's need to be selected and then all of them promoted/demoted to a certain position within the company you would probably, again, have to iterate through your pre-filtered EmployeeCollection and change each user's department while performing the iteration. Although this is not difficult, it isn't something that is highly reusable and the code just looks plain nasty. This is where .NET 2.0 Actions come into play nicely and also allow for some reusability of business processes throughout your code. First, let's create a method that our Action will point to:

private void PromoteEmployeeToExecutive(Employee e)
{
    Console.WriteLine("Promoting Employee {0} to CEO.", new object[] { e.Id });
    e.Department = "CEO";
}

This is fairly simple method. It takes the Employee object that is receives and changes the department property to CEO. Nothing to it. Now, take a look at the .NET 2.0 Action we need to create to that points to this method:

private Action<Employee> promoteToExecutive = new Action<Employee>(PromoteEmployeeToExecutive);

Here we are instantiating an Action of type Employee called promoteToExecutive. This action is then pointed to the method we created above called PromoteEmployeeToExecutive. Thus, anytime our code uses the promoteToExecutive Action, the PromoteEmployeeToExecutive is called. Take a look at the implementation:

 [Test]
 public void PromoteAllToExecutives()
 {
      EmployeeCollection employees = FromXml();
      employees.ForEach(promoteToExecutive);
 }

The FromXml() method is just a method that is importing the xml file from the previous article into my custom EmployeeCollection object. When the data has been imported, we then call the ForEach method on the EmployeeCollection and pass it the promoteToExecutive Action instance. By doing this, every single Employee within the EmployeeCollection will have their respective Department properties set to CEO. Simple as that.

Pred is a whaticate? Generics on Steroids - Part I of II

Shaun — Sat, 12 Aug 2006 18:14:00 GMT

I mean: What is a predicate?

To be honest, at the beginning I got tired of all of the hype of .NET Generics. Yes, they are pretty neat but I could never see their use outside of creating strongly typed collections with a few lines of code.

Was I wrong.

So, I set out to prove to people some of the sweet things that .NET Generics can do for us programmers; to be honest, the possibilities are limitless when one takes reflection and anonymous methods into the picture.

Let's see what .NET Generics can do in the real life of a programmer by starting with this class:

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;

namespace ExcellenceInSoftware.Examples.Generics.EmployeeServices
{
    public class Employee
    {
        private int _Id;
        private string _FirstName      = String.Empty;
        private string _MiddleInitial  = String.Empty;
        private string _LastName       = String.Empty;
        private string _Department     = String.Empty;

        [XmlAttribute]
        public int Id
        {
            get
            {
                return _Id;
            }
            set
            {
                _Id = value;
            }
        }

        [XmlAttribute]
        public string FirstName
        {
            get
            {
                return _FirstName;
            }
            set
            {
                _FirstName = value;
            }
        }

        [XmlAttribute]
        public string MiddleInitial
        {
            get
            {
                return _MiddleInitial;
            }
            set
            {
                _MiddleInitial = value;
            }
        }

        [XmlAttribute]
        public string LastName
        {
            get
            {
                return _LastName;
            }
            set
            {
                _LastName = value;
            }
        }

        [XmlAttribute]
        public string Department
        {
            get
            {
                return _Department;
            }
            set
            {
                _Department = value;
            }
        }
    }
}

So, that is just a simple class that contains information about a virtual Employee. I have prepared the class for Xml Serialization because I plan to populate the data from an xml file. So, the [XmlAttribute] class is really a side note here.

Now, back in the day before .NET 2.0 if one wanted to have a custom collection of Employees that might create a class called EmployeeCollection that inherited from a System.Collections.ArrayList. The downside to this method was that the collection was not strongly typed and therefore, the possibilities for more runtime errors exist. However, in .NET 2.0 generics solved this problem. Here is my EmployeeCollection class that inherits from a Generic List:

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Xml.Serialization;

namespace ExcellenceInSoftware.Examples.Generics.EmployeeServices
{
    [Serializable]
    [XmlRoot("Employees")]
    public class EmployeeCollection : System.Collections.Generic.List<Employee>
    {
    }
}

Now, again, ignore the Xml Serialization attributes because they have nothing to do with these examples. What we have here is a simple class that inherits from System.Collections.Generic.List using the type (<T>) of Employee. Thus, all methods contained within the EmployeeCollection class and its base classes will automatically require me to pass an Employee object to them in order to be successfully compiled. But that is not the point of this highly instructionable post. Take a look at the data I am going to populate my EmployeeCollection with:

<?xml version="1.0" encoding="utf-8"?>
<Employees>
  <Employee Id="2002"  FirstName="Jonathan" MiddleInitial="C" LastName="Stewart" Department="Accounting" />
  <Employee Id="2003" FirstName="Michael" MiddleInitial="X" LastName="Thadson" Department="Accounting" />
  <Employee Id="2004" FirstName="Habib" MiddleInitial="M" LastName="Sedieri" Department="Accounting" />
  <Employee Id="2005" FirstName="Michelle" MiddleInitial="B" LastName="Lawson" Department="Human Resources" />
  <Employee Id="2006" FirstName="Tyra" MiddleInitial="K" LastName="Whitaker" Department="Human Resources" />
  <Employee Id="2007" FirstName="Bethany" MiddleInitial="F" LastName="Moore" Department="Risk Management" />
  <Employee Id="2008" FirstName="Jonathan" MiddleInitial="C" LastName="Stewart" Department="Risk Management" />
  <Employee Id="2009" FirstName="Ponce" MiddleInitial="C" LastName="DeLeon" Department="Legal" />
</Employees>

Simple data used for an example. Let's take a look at some of the 'real-life' tasks that we might be required to perform in a production environment. One of our virtual requirements is to find all Employees that are in the Accounting department after the EmployeeCollection has been populated with this data above. In .NET 1.1 we could have easily created another EmployeeCollection and added Employee objects to it while looping through a for-each statement, but that was always a tad tedious and actually consumed more memory than I'd like it to.

Enter .NET 2.0 Predicates and Actions.

If you take a look at the documentation for a System.Collections.Generic.List it has 2 methods that I want to demonstrate here - FindAll and ForEach.

The FindAll method takes a .NET 2.0 Predicate as a parameter and the ForEach method takes a .NET 2.0 Action as a parameter.

A .NET 2.0 Predicate is pretty much the same thing as a delegate but it's signature is a little bit different. A Predicate is basically a pointer to a method that will perform a task on each item within the collection. So, let's declare our Predicate:

First, we need the method that the Predicate will point to -

private bool IsInAccountingDepartment(Employee e)
{
     return (e.Department == "Accounting");
}

All this method does is check to see if the respective Employee is in the Accounting department and returns 'true' if so. Now, we need to declare the instance of the predicate that points to the above method:

private Predicate<Employee> accounting = new Predicate<Employee>(IsInAccountingDepartment);

Here, we create a new Predicate of type Employee called accounting. Then, within the constructor of the Predicate, we point it to the method created above called 'IsInAccountingDepartment'. Therefore, any method that references the 'accounting' predicate will automatically be pointed to the 'IsInAccountDepartment' method. Let's take a look at the implementation:

        [Test]
        public void FindTotalAccountingEmployees()
        {
            EmployeeCollection employees = FromXml();
            List<Employee> accountingEmployees = employees.FindAll(accounting);
            Console.WriteLine("Total Accounting Employees:  " + accountingEmployees.Count.ToString());
        }

In this method FindTotalAccountingEmployees I first populate my EmployeeCollection using a method called FromXml() that basically reads the xml file above into the collection of Employee objects. Then, I create an instance of the 'List' generic called accountingEmployees that is populate from the FindAll method of the EmployeeCollection. Notice how I passed in our Predicate instance called 'accounting' into the FindAll method.

Amazing as it is, it returns 3 employees which is the correct number of Employees in the accounting department per the Xml file shown previously in this document.

So, what is happening here? Basically, when the FindAll method is called on the EmployeeCollection object using the accounting Predicate, each Employee contained with the EmployeeCollection is sent to the 'IsInAccountingDepartment' method and if that method returns true, the respective Employee object is added to the accountingEmployees list. Therefore, the accountingEmployees list only contains Employees who are in the Accounting department.

A real-life scenario that doesn't use foobars. Makes sense to me.

Tomorrow, I will demonstrate what a .NET 2.0 Action is and how to promote all Employees within an EmployeeCollection to the same department. Until then...

stop programming and start developing the business.