.NET

Unit testing on events

Anthony Trudeau — Thu, 26 Jun 2008 12:52:18 GMT

Here's a little method I came up with recently to test the execution of events. You may not ever need to test to see that an event fires, because you have some other state that you can check. However, that is not always the case. Here is how I approached it using the unit testing provided with the developer's team editon of Visual Studio.

The first thing I did was add a wait handle object inside the definition of my unit test class. Specifically, I chose a ManualResetEvent for the most control, but other types of wait handles may work fine.

        private static ManualResetEvent _waitHandle;

The next step was to add code for the class initialize and cleanup methods. I need to create my wait handle and after I finish running my tests I want to make sure that I release any resources tied-up by the wait handle. Additionally, after a test is run I want to make sure that the wait handle is in an unsignalled state. Therefore, I need to provide a test cleanup method.

        //Use ClassInitialize to run code before running the first test
        [ClassInitialize()]
        public static void MyClassInitialize(TestContext testContext)
        {
            _waitHandle = new ManualResetEvent(false);
        }
 
        //Use ClassCleanup to run code after all tests in a class have run
        [ClassCleanup()]
        public static void MyClassCleanup()
        {
            if (_waitHandle != null)
                _waitHandle.Close();
        }
 

        //Use TestCleanup to run code after each test has run
        [TestCleanup()]
        public void MyTestCleanup()
        {
            _waitHandle.Reset();
        }

That's pretty much it except for the logic in the code itself. In that code, you create your event handler, run the action that will trigger the event, and then wait for the ManualResetEvent to be signalled. It is advisable to provide an arbitrary yet realistic value for a timeout so that your test doesn't run forever if the event isn't fired.

        [TestMethod()]
        public void EventExecutedTest()
        {
            MyObject target = new MyObject();
           // TODO: add additional declarations as needed for test
 
            target.EventExecuted += (sender, e) => _waitHandle.Set();
           // TODO: perform actions that need to trigger the event
 
            bool result = _waitHandle.WaitOne(3000, true);
            Assert.IsTrue(result);                                  
        }

As you can see there's not too much to it. This is a simple mechanism to unit tests events when it makes sense.

Infragistics support with SCSF -- April 2008

Anthony Trudeau — Fri, 23 May 2008 08:03:25 GMT

I just recently installed the new version of the Smart Client Software Factory (SCSF) and wanted to utilize the Composite UI Application Block (CAB) support within my Infragistics components with it within Visual Studio 2008. Luckily, the process is easy and these steps are all you have to do:

Open Visual Studio 2008
Open the Infragistics.CompositeUI.WinForms solution and allow the conversion
Add references to the following Microsoft libraries from the SCSF installation:
- Microsoft.Practices.CompositeUI.dll
- Microsoft.Practices.CompositeUI.Winforms.dll
- Microsoft.Practices.ObjectBuilder.dll
Specify a key file for signing in the project settings if desired
Build the solution

The Infragistics composite UI solution is located in the C:\Documents and Settings\All Users\Shared Documents\Infragistics\NetAdvantage for .NET 2008 Vol. 1 CLR 2.0\CAB Extensibility Kit folder (folder may vary based on the version of the Infragistics controls). You must have at least 2008 Vol 1. controls.

Catching General Exceptions

Anthony Trudeau — Sat, 26 Apr 2008 07:02:08 GMT

Probably all of us know now that you shouldn't catch general exceptions (CA1031). There are practical reasons for this rule such as the fact that you really cannot handle an OutOfMemoryException or StackOverflowException for example. Here is an example of catching a general exception for those that might not know what I'm talking about.

   try
   {
   }
   catch (Exception ex)
   {
   } 

There are also more intrinsic design reasons why you shouldn't catch a general exception. And if there is no other reason, if you're catching a general exception can you say you really know your code? And if you don't know your code maybe it's time to step back and put a little more thought into what you're doing.

But, wait, what if you know your code but the code your try block is nesting isn't known -- such as calling an abstract member within a base class? Still, I say no general exceptions. Its better to let the application come tumbling down then the possible side effects of catching and either handling or swallowing an exception that you really don't know how to properly handle. Okay you say, what if its imperative that the application stay alive despite the possibility of ill-behaving code in a concrete class? Fine you got me there, its time to catch the general exception -- with the caveat that you still need to properly handle the exception.

How do you handle a general exception, because by its definition it could be virtually anything? You really cannot, but you can handle quite a bit and remember that by virtue of this application that must have high reliability (be up all of the time). When you have an application like that you probably have some type of service managing the class. Therefore, what I do is add an event to my class called UnhandledException.

The service class can subscribe to that event and choose to handle it or not via a Handled property on a concrete implementation of the EventArgs class. With that in mind you just need to address your initial error handler and make sure that anything that isn't handled by the service class is then re-thrown which will and should take down the whole shebang.

   try
   {
       // some process that can raise an unknown exception
   }
   catch (Exception ex)
   {
       ExceptionEventArgs args = new ExceptionEventArgs(ex);
       OnUnhandledException(args);
 
       if (!args.Handled)
          throw;
   }
 

As you can see from this implementation we leave it up to the service class to determine what to do with the exception. You still may have tasks to do with specific exceptions and in theses cases you should have blocks for those specific exceptions. However, this cleanly delegates the work to the service allowing it to make the determination of what to do -- which may include tearing down and recycling the instance that raised the exception.

Funny Little Logic Errors

Anthony Trudeau — Mon, 10 Mar 2008 08:48:37 GMT

I received an email this morning from my manager saying that I need to look at this one utility, because it's showing a high CPU utilization and preventing another application from running. The utility runs on a Terminal Server so the problem is exaserbated by multiple users in different sessions.

Keep in mind that this utility has been in production for several months and there have been zero bug reports. But, sure enough using the information I was able to duplicate the problem and based on the details of the problem I knew what function was causing the problem and I quickly saw the problem:

      // wait for a signal from AddRequest, ClearError, or the Stop method
      if (_disposed)
          _waitHandle.WaitOne(timeout, false);

A half a day of work lost, because I messed up the logic and should have said, "if (!_disposed)". Oh well, it seems that no matter how well you think you test the code that there's always the possibility of something funny like this that you don't look for. I feel comfortable saying that the utilty is still well tested since its not a trivial utility and I've only had one bug report. But, I still feel like slapping myself for that funny little logic error.

Anyone else do these funny little logic errors?

Overview of custom attributes

Anthony Trudeau — Wed, 16 Jan 2008 14:51:56 GMT

Attributes are elements of metadata that you can attach to entities such as assemblies, classes, methods, properties, et al. The .NET Framework makes use of many attributes that allow you to affect the behavior of the compiler or how the Framework uses an entity. For example, you can assign attributes to properties of a control object that allow a friendly name and description to be shown in the property browser in Visual Studio.

At some point, you'll come into a situation where you'll want to use a custom attribute. Defining and using attributes are very easy and in this article I will provide a very simple setup using a few attributes defined at the class level. Defining and using attributes at other levels vary only slightly and I'll make note when there is a difference.

Read the rest of the article

Book review: Introducing Microsoft LINQ

Anthony Trudeau — Tue, 08 Jan 2008 12:30:08 GMT

I got this book as a Christmas present and quickly read through it cover to cover. The primary focus of the book is to provide an introduction to LINQ (language integrated query) that is available in the Microsoft .NET Framework 3.5. In this end the book does a good job. Just don't look for anything comprehensive.

The book starts out talking about what LINQ is and follows that up with a few chapters that talk about the new language features in C# and VB that make LINQ possible. I found the information to give me a good understanding about how LINQ works if only at a very high level. However, these chapters take up about 20% of the book. I feel the author would have been better off shortening these chapters and adding more meat to other sections.

The syntax fundamentals follow the introduction. The chapter starts out good, but seems to become a regurgitation of product documentation towards the end. The fundamentals chapter is followed by chapters on the different flavors of LINQ that is LINQ to SQL, LINQ to Entities, etc. The one part of the book that I felt was really lacking is the LINQ to Entities section which was given a whopping three pages.

That all said, the book did a good job of getting me familiar with what the technology is and can do, and what options I have for using the technology in different areas. The information is based on the beta, and although I didn't look for differences I didn't run into any either. You could get the same information this book provides by reading the production documentation as well as several online articles on the subject of LINQ, but if you're like me you like it in one place in a convenient format to sit back and work through.

The list price on the book is way out there, but Amazon has it for a much more reasonable price of $23. I would recommend this book based on its ability to provide a good introduction keeping in mind that it doesn't offer advanced or in-depth coverage.

Custom dictionary at the project level

Anthony Trudeau — Thu, 27 Dec 2007 00:58:14 GMT

The MSDN documentation indicates that the custom dictionary for the naming rules in the Visual Studio code analysis can be applied at the project level. I prefer a local scope for terms that don't have a scope global to all my projects (e.g. the company name is good to have global but a product name doesn't really need to be in the global dictionary). Unfortunately, it doesn't tell you all the information you need to actually use the custom dictionary.

The first thing to do is create the custom dictionary that you want to use for the project. The MSDN documentation provides the file format for the file. The easiest way to do this would be to click Add New Item from the Project menu. Select XML file and change the name to CustomDictionary.xml and then copy the format from the MSDN documentation. Next add your words and acronyms as needed.

The final steps are all done from within Visual Studio and is where the MSDN documentation lets you down. Select the file in the Solution Explorer and change its properties as follows:

Build Action = CodeAnalysisDictionary
Copy to Output Directory = Do not copy

These steps basically add the /dictionary switch to the build action for calling FxCopCmd. I've added user content to the MSDN documentation online, but hopefully this article will help those that don't notice it.

Example: Regular Expression Alternation

Anthony Trudeau — Tue, 11 Sep 2007 16:40:35 GMT

So, the scenario is that you want to do some specific validation or matching, but part of what you're validating or matching will decide how the rest is validated or matched. For example, in my scenario I have a field in the database that will store a report destination in the URI format that can be either for e-mail, FTP, or a file (mailto://, ftp://, or file://). You could create three regular expressions and evaluate each, but that can be klunky especially if you're doing on the fly validation through a control like the Infragistics UltraWinGrid which allows you to set a regular expression as a validator on the column.

Alternations for expressions are what you need. Specifically, the .NET Framework specifies the following format for the alternation expression:

(?(expression)yes|no)

The easiest way to specify the expression is as a named group. And then yes and no become the remaining patterns to match if the named group specified in the expression has a match. Therefore, for my scenario I could write the shell of my regular expression as (ignore case option is set):

^((?<isMail>mailto)|(?<isFtp>ftp)|(?<isFile>file)):\/\/(?(isMail)yes|(?(isFtp)yes|no))$

This basically could be read as:

Match the protocol as "mailto", "ftp", or "file"
If we matched the protocol as "mailto" then
- Match the rest of the string as an e-mail address
Else if we matched the protocol as "ftp" then
- Match the rest of the string as an FTP address
Else
- Match the rest of the string as a file

From this point, you need to determine the regular expressions to match the mail, FTP, and file format. I used the following:

e-mail: ([\w\-\.]+)@((\[([0-9]{1,3}\.){3}[0-9]{1,3}\])|(([\w\-]+\.)+)([a-zA-Z]{2,4}))
ftp: (?:[\w.]+\/?)|(([A-Z]:\\[^/:\*\?<>\|]+\.\w{2,6})
file: (\\{2}[^/:\*\?<>\|]+\.\w{2,6})

At this point, it's just a matter of putting the values into the format I came up with earlier and I have a single regular expression to match the URIs that I care about.

^((?<isMail>mailto)|(?<isFtp>ftp)|(?<isFile>file)):\/\/(?(isMail)([\w\-\.]+)@((\[([0-9]{1,3}\.){3}[0-9]{1,3}\])|(([\w\-]+\.)+)([a-zA-Z]{2,4}))|(?(isFtp)(?:[\w.]+\/?)|(([A-Z]:\\[^/:\*\?<>\|]+\.\w{2,6})|(\\{2}[^/:\*\?<>\|]+\.\w{2,6}))))$

Making your assemblies visible to Visual Studio

Anthony Trudeau — Thu, 21 Jun 2007 15:43:55 GMT

So, you created your super cool library and you want to be able to use it within your application. You maybe even installed it in the GAC. But, it doesn't show up in the Add Reference dialog unless you browse to it. What are you to do?

There are two approaches:

Copy the assemblies to the C:\Windows\Microsoft.NET\Framework\v2.0.50727 folder (version may vary) or the C:\Program Files\Microsoft Visual Studio8\Common7\IDE folder.
Add a special assembly folder key to the Registry

Personally, I believe the latter option is the best option and seems to be the method that third party vendors use. This method will cause Visual Studio to search the folder you specify in addition to the default folders. Here's what you need to do:

Browse to the HKLM\Software\Microsoft\.NETFramework\AssemblyFolders key
Add a new key with whatever name you want (keep in mind that you'll need a key for separate folders)
Set the default value of the key to the folder where the assemblies are installed

Exposing a collection in your object model

Anthony Trudeau — Mon, 18 Jun 2007 21:15:28 GMT

Sometimes it's necessary to expose an internal collection from an object to a hosting object. However, usually your object wants to control the changes to the collection. You can easily pass an array to the hosting object using the ToArray method, but that array is static to the hosting object. What if the hosting object needs updates?

The best way to illustrate the problem is with an example. In this example, I have a simple Windows Forms project with a Form that has an Infragistics UltraWinGrid (although any data grid will work that supports binding to an IList). I prefer not to expose internal controls to objects such as presenters in an MVP pattern, so that means my data which is not based on a database needs to be stored in another class or within the Form class, and I certainly don't like the latter option.

It just so happens that my object which I'll call a manager is responsible for the collection and for performing work based on the contents of the collection. The work being done is irrelevant for this article, but if you're curious I am spawning a separate thread which contacts a legacy application via TCP and submits jobs/requests for printing (after they've been processed through a workflow). The manager exposes some modification methods such as AddRequest, CancelRequest, et al. And those methods are the only way I want the outside world to modify the collection. But, at the same time the data grid needs to have access to the current data without needing to requery the property.

Enter the AsReadyOnly method. This method exposed by the List<T>, Set<T>, Array, and others generates what is basically an adapter to your collection. The return value is a System.Collections.ObjectModel.ReadOnlyCollection<T> that is the best of both worlds -- it shows live data from the internal collection and it doesn't let the consumer modify the collection contents.

Here's an example of the implementation

public class MyManagerClass
{
     private List<MyObject> _objects = new List<MyObject>();

     public ReadOnlyCollection<MyObject> Objects
     {
          get { return _objects.AsReadOnly(); }
     }
}