David Foderick's Blog - OnMaterialize()

RUAlive 0.2 released

2007-10-02T22:39:00Z

A new version is available. See the end of the post for a link. Major enhancements are support for mutliple sites, ability to view the response and the beginnings of a Vista Gadget implementation.

Making Cuyahoga and Community Server play nice together

2007-09-30T18:14:00Z

I use Cuyahoga for my main website pages and relegate Community Server to be a subservient web app to take advantage of its blog and forums components. The latest Cuyahoga 1.5 upgrade threw a small wrinkle into the configuration process.

The basic setup is to have two virtual roots.
http://www.netknowledgenow.com/ has its own web.config for Cuyahoga.
http://netknowledgenow.com:81/CS is a virtual root under the main site with its own web.config for Community Server.

As this post describes, Cuyahoga adds some HttpModules to its site. These have to be removed in the Community Server web.config. You have to move the dll's from Cuyahoga's bin directory into Community Server's bin directory in order to remove the HttpModules. Starting with Cuyahoga version 1.5 there are also HttpHandlers registered by Cuyahoga. These HttpHandlers also have to be removed in CommunityServer's web config otherwise the Community Server pages do not function. No error message was being thrown but every subpage in Community Server was being redirected to the Community Server default home page. However, once you remove the Cuyahoga HttpHandler you have to re-enable Asp.Net's default handler (in machine.config). If anyone knows a cleaner way to remove this stuff and reset the HttpHandler to the default, please let me know!

A step-by-step recipe for making this work goes like this:
1. Copy the Cuyahoga dll's from the Cuyahoga bin directory into Community Server's bin directory.
2. Edit Community Server's web.config HttpModule and HttpHandler sections to look like this:

<httpModules>

                  
                  <remove name="AuthenticationModule" />
                  <remove name="CoreRepositoryModule" />
                  <remove name="NHibernateSessionWebModule" />

            <add name="CommunityServer" type="CommunityServer.CSHttpModule, CommunityServer.Components" />
            <add name="CSProfile" type="Microsoft.ScalableHosting.Profile.ProfileModule, MemberRole, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b7c773fb104e7562"/>
            <add name="CSRoleManager" type="Microsoft.ScalableHosting.Security.RoleManagerModule, MemberRole, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b7c773fb104e7562" />
            
        </httpModules>

        <httpHandlers>
            <remove verb="*" path="Error.aspx" />
            <remove verb="*" path="*.aspx" />
               <add verb="*" path="*.aspx" type="System.Web.UI.PageHandlerFactory" />

            <add verb="GET" path="Utility/redirect.aspx" type="CommunityServer.Components.Redirect, CommunityServer.Components" />
            <add verb="GET" path="aggbug.aspx" type="CommunityServer.Components.HttpHandler.AggBugHandler, CommunityServer.Components" />
            <add verb="GET" path="avatar.aspx" type="CommunityServer.Components.HttpHandler.AvatarHttpHandler, CommunityServer.Components" />
            <add verb="GET" path="vcard.aspx" type="CommunityServer.Components.HttpHandler.VCardHttpHandler, CommunityServer.Components" />
            <add verb="GET" path="r.ashx" type="CommunityServer.Components.HttpHandler.TinyUrlHttpHandler, CommunityServer.Components" />
        </httpHandlers>

RUAlive - a WPF tool to check if a website is running.

2007-09-27T04:27:00Z

RUAlive is a WPF utility that answers the question "Is my website still running?"

RUAlive is written using Visual Studio 2008 Beta 2 Orcas. Download the source here.

To run RUAlive, you can either run the solution or run RUAlive.exe. Of course you need .NET 3.5 Beta 2 installed.

To use RUAlive:
1. Enter the http address of the site you want to monitor
2. Click on Config to enter the contents of the page that you want to search for. Also enter the frequency to perform checks.
3. Close the configuration screen to go back to the main screen and press the Start button.
4. To see any errors hover over the line.
5. To clear the list right-click and select "Clear History".

RUAlive is not only a simple tool that performs a useful function. It is also demonstates some useful technologies such as Windows Presentation Framework and Domain Driven Design.

The backlog of feature enhancements include:
1. Implement persistence
2. Improve the overall look and feel with images, animation and themes.
3. Enhance the plug-in architecture (similar to the Composite Application Block)
4. Implement some sort of dependency injection
5. Send alerts
6. View response page
7. Make a Vista gadget
8. Lots of other goodies that I can't recall off the top of my head now.

Debugging WCF Serialization issues

2007-03-12T18:50:00Z

When serializing objects over WCF you might encounter the following not-so-helpful message.

System.ServiceModel.CommunicationException : The underlying connection was closed: The connection was closed unexpectedly.

And the Close method of your service proxy may complain that

System.ServiceModel.Security.MessageSecurityException : An unsecured or incorrectly secured fault was received from the other party. See the inner FaultException for the fault code and detail.

Which seems to indicate that there is a security exception. However, in my experience, the root problem has usually been a serialization issue.

To debug server-side issues, use a combination of the SvcTraceViewer.exe, an indispensible tool for debugging and tracing WCF messages, and simple tracing into the server-side code by attaching to the server process.

If indeed you have a serialization issue, you will be able to step through the Service method and the Server stack trace will end right at the point where you return from the service method.

Server stack trace:
   at System.ServiceModel.Channels.HttpChannelUtilities.ProcessGetResponseWebException(WebException webException, HttpWebRequest request, HttpAbortReason abortReason)
   at System.ServiceModel.Channels.HttpChannelFactory.HttpRequestChannel.HttpChannelRequest.WaitForReply(TimeSpan timeout)
   at System.ServiceModel.Channels.RequestChannel.Request(Message message, TimeSpan timeout)
...

However, at no point do you actually see the true source of the exception. It seems to get eaten somewhere in the channel. The best way that I have discovered to track down any serialization issues is to write unit tests that manually serialize the objects that pass through the WCF service. My serialization helper is a generic method like this:

        public static void LogDTO<TDTO>(TDTO dto)
        {
            DataContractSerializer ser =
                new DataContractSerializer(typeof(TDTO));
            FileStream writer = new FileStream(@"C:\log\"+dto.GetType().Name+".xml", FileMode.Create);
            ser.WriteObject(writer, dto);
            writer.Close();
        }

The unit test simply calls the LogDTO method for each serializable object.

Serializer.LogDTO<myDTO>(myDTOInstance);

And now you can resolve any serialization issues with an appropriate stack trace and exception message.

Don't serialize your delegates!

2007-03-01T00:29:00Z

This point is pretty obvious: when serializing objects in order to pass them through a service boundry, you should not bother to serialize the delegates. Since a delegate is a pointer to some method on some object in your memory space, that target object that the delegate points to probably doesn't exist in the memory space of the other machine! You will encounter this scenario if you create custom events on your business objects and then serialize them through WCF. Remember that a .NET event is just a list of delegates (commonly called the event's invocation list).

There are two issues that make this problem particularly onerous. First, if there are no subscribers to the event, the serialization works just fine! So your unit tests may work perfect - unless you are the one anal fool that unit tests subscribing to events and serializing those objects. Second, back in the UI, it may not be your code - it may be framework code - that is subscribing to these events and you will only get the SerializationException after you have databound the objects to UI controls and then try to serialize the databound objects. This will happen if for some crazy reason you want to implement INotifyPropertyChanged on your business entities.

Fortunately, the problem is pretty obvious when you encounter it. The excetpion message you get in the .NET 3.0 DataContractSerializer is :

"Type 'System.DelegateSerializationHolder+DelegateEntry' with data contract name 'DelegateSerializationHolder.DelegateEntry:http://schemas.datacontract.org/2004/07/System' is not expected. Add any types not known statically to the list of known types - for example, by using the KnownTypeAttribute attribute or by adding them to the list of known types passed to DataContractSerializer."

Forget .NET's advice. The way to fix it simple. Just mark your event as NonSerialized.

[field: NonSerialized]
public event PropertyChangedEventHandler PropertyChanged;

The bottom line rule is to always mark events with the [field:NonSerialized] attribute on classes whose objects will be serialized accross a service boundry.

Reference: Do not serialize delegates and events blindly.

Upgrade Winforms 2005 project to WPF

2007-02-24T17:44:00Z

Lately I've been upgrading my Winforms CAB applications to use the Windows Presenation Framework version of the Composite Application Block. This post will explain how you can do an "in place" conversion of your Winform project to WPF.

The normal way to convert a project to WPF would be backup your Winform project, create a new WPF project, recreate all your screens as WPF Windows (or UserControls) and copy and paste the non-visual code from the backup into the new WPF project. That would be the recommended way for most projects, especially if you have many forms or user controls to upgrade. However, I have several projects that have but one view and all that copying and renaming and adding projects seemed like too much rigamarole. Besides, I liked the names of my projects and didn't want to create new projects with new namespaces and get all the naming right. Plus, I would have to add references, etc. So I decided to perform a manual conversion of some projects to use WPF. Here is how I did it.

First, I will assume that you have your WPF version of your Shell project already created (use the BankTeller WPF example as a guide). This post will only cover the conversion of a module project because its simpler and it shows the general philosophy and gotchas of the conversion.

First, start by ripping out the references to Winforms. Remove the references to System.Windows.Forms and System.Drawing. Add references to WindowsBase, PresentationCore and PresentationFramework. Rename your winforms views to get them out of the way. Create new WPF UserContols to replace the old Winforms views. Recreate your new UI using WPF controls. This could take some effort but if your views are simple and slim then most of your code will be in the Presenter/Controller and it will be a reasonably easy task to recreate the new UI in WPF. Remove the Winform view from the project when you no longer need it.

You can now attempt to build. You should get a cryptic compilation error message that says "The name 'InitializeComponent' does not exist in the current context". Don't worry, you didn't do anything wrong. There is one additional step to complete. In order for msbuild to compile your .NET 3.0 project, it needs to know about the WinFX build configuration. This step, which you will do manually, would normally be done automatically when you create a new WPF project instead of converting in-place like I am showing. With one of the files from your project open for editing, right click the name of the file in the editing tab and select "Open Containing Folder". This will open Windows Explorer in your project folder. Open your .proj file with your favorite editor such as Notepad. Down near the bottom of the file, you will see a line that says:

Add the following line right below it:

Save the change and reload the project. Build succeeded!

Assembly '' was not found. The 'clr-namespace' URI refers to an assembly that is not referenced by the project.

2007-01-24T19:27:00Z

It almost seems like a cruel joke. Innumerable WPF samples indicate that you can implement databinding in a particular way. However, doing so breaks designer support and you have to rearrange code to reflect the reality of current limitations with Cider. Let me explain what I mean.

When you create XAML markup you are declaratively creating objects with XML. Normally, the XAML tags will create controls like textboxes and labels, etc. But there is nothing to stop you from instantiating model objects in XAML. So, instead of writing

Person p = new Person();

in your code behind, you can instantiate a person like this

<Window.Resources>
<local:Person x:Key="myDataSource" Name="Joe"/>

or like this

<Window.Resources>
<ObjectDataProvider x:Key="myDataSource" ObjectType="{x:Type local:Person}" />

The XML namespaces (local and x above) have to be registered at the top of your file like this:

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:YourProjectNamespace"

You can then databind to the person object like this:

Make sure you put the Window.Resource element above the TextBlock element otherwise your datasource won't exist at the time you are databinding and you will get a null reference exception. Finally, can run the sample and it will execute perfectly. But don't venture into the designer! If you do, you get a nasty error in the error list:

Assembly '' was not found. The 'clr-namespace' URI refers to an assembly that is not referenced by the project.

There is no designer support for declaratively created model object in the current release that I know of. To get designer support for these types of pages, rip out the dynamically created object and change the codebehind to instantiate and object explicitly and bind up the object to the context.

        public Window1()
        {
            InitializeComponent();
            Parent p = new Parent();
            this.DataContext = p;
        }

January 2007 Orcas CTP: Don't bother

2007-01-22T20:54:00Z

I spent the better part of a day downloading and setting up the new Orcas in anticipation of playing with .NET 3.0 and 3.5 (Greenbits). Unless you want to play with Entity Framework in its "Raw" format (no visual designer) stay away from this download - its problems are detailed here. The bottom line is its not configured to do .NET 3.0 development. I just don't really see any reason why this CTP release was even attempted. Let's hope the February CTP is a lot better.

New project for 2007

2007-01-21T22:00:00Z

Next week I start a new project for one of my clients. Its a premier project for the company that will be using the latest .NET 3.0 technologies: Windows Presentation Foundation, Windows Workflow Foundation and Windows Communication Foundataion. The best part of it is that the team will be comprised of a small number (6) of incredibly smart developers - some of the best in the region. Architecturally speaking, the most interesting piece will be designing and implementing the Enterprise Service Bus.

Stay tuned throughout the year as I share through my blog any insights that I gain - at least anything that's not proprietary.

Control WCF Serialization of Collections with IXmlSerializable

2007-01-18T18:56:00Z

WCF doesn't always serialize custom collections of objects the way that you would like. For example, a Family may have a collection of Members.

    public class SerializeObjectModel
    {
        [DataContract(Name = "Family")]
        public class Family
        {
            [DataMember(Name = "Members")]
            public FamilyMembers MembersList = new FamilyMembers();
        }

        public class FamilyMembers : List<string>
        {
        }
}

If you load up the list with some data and serialize it through WCF (WCF uses the DataContractSerializer by default to serialize objects so you can simulate serialization in a test harness by calling the class directly)

            Family f = new Family();
            f.MembersList.Add("A");
            f.MembersList.Add("B");
            f.MembersList.Add("C");
            f.MembersList.Add("D");
            ...
            DataContractSerializer ser = new DataContractSerializer(typeof(Family));
            ser.WriteObject(cwriter, f);

It will serialize like this:

  <Family xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schema/

s.datacontract.org/2004/07/ObjectModel">

  <Members xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays

">

    <d2p1:string>A</d2p1:string>

    <d2p1:string>B</d2p1:string>

    <d2p1:string>C</d2p1:string>

    <d2p1:string>D</d2p1:string>

  </Members>

</Family>

That's fine. Now you add some additional members to the FamilyMembers class, maybe a list of family members that have been deleted fromt the list (granny passed away, RIP).

        public class FamilyMembers : List <string>
        {
            //DKF: added this list
            public List<string> DeletedList = new List<string>();

You run it through the WCF Serializer

            Family f = new Family();
            f.MembersList.Add("A");
            ...
            //WANT TO GET THIS SERIALIZED TOO!
            f.MembersList.DeletedList.Add("Dave Foderick");

and you don't see the deleted list! It looks exactly like the previous output. If the deleted list never gets to the other end of the wire then they never get removed from the database.

To get the list to serialize the way we would like, we have to get control of how WCF serialized it. This post is the golden nugget that describes the precedence of how lists are serialized. You see that what is serializing our list is #6 which apparently iterates through the collection and spits out the members, ignoring anything else that may be of interest to us on the list iteself. The only hook into the serialization process that has higher prececedence and will allow us the flexibility (CollectionDataContractAttribute won't do!) is IXmlSerializable. So modify the collection class to implement that interface.

        public class FamilyMembers : List<string> , IXmlSerializable
        {
            //DKF: added this list
            public List<string> DeletedList = new List<string>();

            #region IXmlSerializable Members

            public System.Xml.Schema.XmlSchema GetSchema()
            {
                return null;
            }

            public void ReadXml(XmlReader reader)
            {
                throw new Exception("The method or operation is not implemented.");
            }

            public void WriteXml(XmlWriter writer)
            {
                //First, serialize all the items in the base list
                writer.WriteStartElement("Items");
                foreach (string item in this)
                {
                    writer.WriteElementString("Member", item);
                }
                writer.WriteEndElement();

                //now, serialize all the items in the deleted list
                writer.WriteStartElement("DeletedItems");
                foreach (string deletedItem in DeletedList)
                {
                    writer.WriteElementString("Member", deletedItem);
                }
                writer.WriteEndElement();
            }

More code to write for sure but victory is ours!

<Family xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schema
s.datacontract.org/2004/07/ObjectModel">
<Members>
    <Items>
      <Member>A</Member>
      <Member>B</Member>
      <Member>C</Member>
      <Member>D</Member>
    </Items>
    <DeletedItems>
      <Member>Dave Foderick</Member>
    </DeletedItems>
</Members>
</Family>

To get this working right in a real app, you have to write the deserialization logic too. Here is a more realistic implementation (TDto is a generic parameter for a custom class that replaces string in the above samples).

        #region IXmlSerializable Members

        /// 
        /// Get xml schema
        /// In this case, we don't have any
        /// 
        /// 
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }

        private DataContractSerializer GetSerializer()
        {
            Type dtoType = typeof(TDto);
            DataContractSerializer ser = new DataContractSerializer(dtoType);
            return ser;
        }

        /// 
        /// Deserialize the object
        /// 
        /// 

        public void ReadXml(XmlReader reader)
        {
            DataContractSerializer ser = GetSerializer();

            //read past the first element. This is the outermost element for the list
            reader.ReadStartElement();

            //read in the undeleted objects
            ReadXmlObjects(reader, "Items", this);

            //now read in the deleted list
            ReadXmlObjects(reader, "DeletedItems", this._deletedList);
        }

        private string PrefixedElementName(XmlReader reader, string elementName)
        {
            string retval = reader.Prefix;
            if (reader.Prefix.Length > 0)
            {
                retval += ":";
            }
            retval += elementName;
            return retval;
        }

        /// 
        /// read objects into list
        /// 
        /// 

        /// 

        /// 

        private void ReadXmlObjects(XmlReader reader,string elementName, IList list)
        {
            DataContractSerializer ser = GetSerializer();

            Type dtoType = typeof(TDto);
            string prefixedCollection = PrefixedElementName(reader,elementName);
            if (reader.IsStartElement(prefixedCollection))
            {
                reader.ReadStartElement();
                //TODO: very tricky!
                //element name must match classname. Is this always true???
                //another strategy is to embed a count of the number of object to 
                //read inside the xml. Then this code can be a foreach
                string prefixedClassName = PrefixedElementName(reader,dtoType.Name);
                while (reader.IsStartElement(prefixedClassName))
                {
                    TDto dto = (TDto)ser.ReadObject(reader);
                    list.Add(dto);
                }
                if (reader.IsStartElement() == false)
                {
                    reader.ReadEndElement();
                }
            }
        }

        /// 
        /// Serialize the object
        /// 
        /// 

        public void WriteXml(System.Xml.XmlWriter writer)
        {
            //This is the WCF default Serializer
            DataContractSerializer ser = new DataContractSerializer(typeof(TDto));

            //First, serialize all the items in the base list
            writer.WriteStartElement("Items");
            foreach (TDto item in this)
            {
                ser.WriteObject(writer, item);
            }
            writer.WriteEndElement();
            //ser.WriteObject(writer, this.Items);

            //now, serialize all the items in the deleted list
            writer.WriteStartElement("DeletedItems");
            foreach (TDto deletedItem in _deletedList)
            {
                ser.WriteObject(writer, deletedItem);
            }
            //ser.WriteObject(writer, _deletedList);
            writer.WriteEndElement();

        }

        #endregion

Download my test harness with sample code.

NHibernate on ASP 2.0 Web Site Project and 2005 Web Developer Express

2007-01-18T17:11:00Z

Many people (including myself) have had difficulties getting NHibernate to work with ASP.NET 2.0. The usual problem centers around how to get NHibernate to read in the configuration files for your entites and the problem is exacerbated by ASP.NET 2.0's new dynamic compilation model. I can tell you that it is possible to make it work and here is how I did it.

In ASP.NET 1.1 you could specify that configuration files, such as hbm.xml files, could be embedded resources which meant that they would get baked into the single dll produced from building your web site. You could let NHibernate know about all your entities by simply pointing it to the single dll

Configuration cfg = new Configuration();
cfg.AddAssembly("MySite.dll");

This technique also works in 2.0 if you use the Web Application Project compilation model because it works like 1.1 and builds a single dll and allows you to embed resources into that dll. But it won't work if you use the default Web Site Project compilation model or Express. Both of the latter use a dynamic compilation model where you can just copy .cs to the web site and it automatically compiles. And, as far as I know, there is no way to embed the xml configuration files into the resultant dll.

So to make it work in 2.0 here is the most direct solution. First, put all your hbm.xml files into the same directory on the server. This could be App_Code or App_Data or whevever you keep your entity classes (which should be somewhere under App_Code) or anywhere else on the web site. I put them in App_Code\Resources. Then, configure NHibernate with the AddXmlFile method giving it each and every configuration file that you have, like this:

Configuration cfg = new Configuration(); 
string basePath = System.Web.HttpContext.Current.Server.MapPath(@"~/App_Code/Resources/"); 
cfg.AddXmlFile(basePath+"Customer.hbm.xml");
cfg.AddXmlFile(basePath+"Order.hbm.xml");

Note that you have to add a line for each configuration file, which kinda sucks when you have to add more hbm.xml files to your project.

The last trick to get this working is to fix up the hbm.xml files themselves. Had you have been building a site to one specific dll (Web Project compilation, VS2003) then all your types live in that dll and it is easy to tell the xml file where the type lives. With dynamic compilation in ASP.NET 2.0 where does your entity type live? Well, if you put your entity class anywhere under the Add_Code directory it will be compiled into the App_Code.dll. Therefore, just make sure you place your entity classes somewhere under the App_Code directory and then modify your hbm.xml files to reference your entity types in App_Code.dll. Here is what my hbm.xml file starts with.

<?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.0"> 
<class name="Domain.Portfolio, App_Code" table="PortfolioHead"> 
...

Note that this is for NHibernate 1.0. Your mapping version may need to be something different. Use whatever is appropriate for your version of NHibernate. NHibernate and ASP.NET are now one with each other.

This topic was discussed on the NHibernate forum.

Study Links for 70-553: Upgrade to Enterprise Developer

2006-12-16T21:48:00Z

Since I have a couple of exam certificates that are expiring at the end of the year, I've decided to use them to get certified as an Enterprise Developer. The upgrade is spread over two exams 70-553 and 70-554. On 70-553 there are three parts that correspond to three other microsoft exams: Fundamentals, Web and Windows. Since I already have links for the Fundamentals and Web exams elsewhere on my blog, I'm just going to list the ones covered here for the Windows portion.

Section 3
Creating a UI for a Windows Forms Application by Using Standard Controls

Manage control layout on a Windows Form.

•

Group and arrange controls by using the Panel control, GroupBox control, TabControl control, FlowLayoutPanel control, and TableLayoutPanel control.

•

Use the SplitContainer control to create dynamic container areas.

Add and configure a Windows Forms control.

•

Use the integrated development environment (IDE) to add a control to a Windows Form or other container control of a project at design time.

•

Add controls to a Windows Form at run time.

•

Configure controls on a Windows Form at design time to optimize the UI.

•

Modify control properties.

•

Configure controls on a Windows Form at run time to ensure that the UI complies with best practices.

•

Create and configure command controls on a Windows Form.

•

Create and configure text edit controls on a Windows Form.

•

Create and configure text display controls on a Windows Form.

•

Use the LinkLabel control to add Web-style links to Windows Forms applications.

•

Provide a list of options on a Windows Form by using a ListBox control, a ComboBox control, or a CheckedListBox control.

•

Configure the layout and functionality of a Windows Form to display a list of items.

•

Implement value-setting controls on a Windows Form.

•

Configure a WebBrowser control.

•

Add and configure date-setting controls on a Windows Form.

•

Display images by using Windows Forms controls.

•

Configure the NotifyIcon component.

•

Create access keys for Windows Forms controls.

Create and configure menus.

•	Create and configure a MenuStrip component on a Windows Form.
•	Change the displayed menu structure programmatically.
•	Create and configure the ContextMenuStrip component on a Windows Form.

Integrating Data in a Windows Forms Application

Implement data-bound controls.

•

Use the DataGridView control to display and update the tabular data contained in a data source.

•

Use a simple data-bound control to display a single data element on a Windows Form.

•

Implement complex data binding to integrate data from multiple sources.

•

Navigate forward and backward through records in a DataSet in Windows Forms.

•

Define a data source by using a DataConnector component.

•

Create data forms by using the Data Form Wizard.

Manage connections and transactions.

•	Configure a connection to a database by using the Connection Wizard.
•	Configure a connection to a database by using Server Explorer.
•	Configure a connection to a database by using the Connection class.
•	Connect to a database by using specific database Connection objects.
•	Enumerate through instances of Microsoft SQL Server.
•	Open an ADO.NET connection to a database.
•	Close an ADO.NET connection to a database by using the Close method of the Connection object.
•	Protect access to data source connection details.
•	Create a connection designed for reuse in a connection pool.
•	Control a connection pool by configuring ConnectionString values based on database type.
•	Use the Connection events to detect database information.
•	Handle exceptions when connecting to a database.
•	Perform transactions by using the Transaction object.

Read, write, and validate XML by using the XmlReader class and the XmlWriter class.

•	Read XML data by using the XmlReader class.
•	Read all XML element and attribute content.
•	Read specific element and attribute content.
•	Read XML data by using the XmlTextReader class.
•	Read node trees by using the XmlNodeReader class.
•	Validate XML data by using the XmlValidatingReader class.
•	Write XML data by using the XmlWriter class.

Enhancing Usability

Create, configure, and customize user assistance controls and components.

•	Configure the PropertyGrid component.
•	Configure the ProgressBar control to indicate progress graphically.
•	Display status information by using the StatusStrip control.
•	Configure the ToolTip component.
•	Configure the ErrorProvider component.
•	Configure the HelpProvider component.
•	Play system sounds and audio files by using the SoundPlayer.
•	Configure the Timer component to raise an event at regular intervals.
•	Enable scrolling by using the HScrollBar and VScrollBar controls.

Implementing Asynchronous Programming Techniques to Improve the User Experience

Manage a background process by using the BackgroundWorker component.

•	Run a background process by using the BackgroundWorker component.
•	Announce the completion of a background process by using the BackgroundWorker component.
•	Cancel a background process by using the BackgroundWorker component.
•	Report the progress of a background process by using the BackgroundWorker component.
•	Request the status of a background process by using the BackgroundWorker component.

Configuring and Deploying Applications

Configure the installation of a Windows Forms application by using ClickOnce technology.

•	Install a Windows Forms application on a client computer by using ClickOnce deployment.
•	Install a Windows Forms application from a server by using ClickOnce deployment.
•	Configure the required permissions of an application by using ClickOnce deployment.

Manage control layout on a Windows Form.

•

Group and arrange controls by using the Panel control, GroupBox control, TabControl control, FlowLayoutPanel control, and TableLayoutPanel control.

•

Use the SplitContainer control to create dynamic container areas.

Add and configure a Windows Forms control.

•

Use the integrated development environment (IDE) to add a control to a Windows Form or other container control of a project at design time.

•

Add controls to a Windows Form at run time.

•

Configure controls on a Windows Form at design time to optimize the UI.

•

Modify control properties.

•

Configure controls on a Windows Form at run time to ensure that the UI complies with best practices.

•

Create and configure command controls on a Windows Form.

•

Create and configure text edit controls on a Windows Form.

•

Create and configure text display controls on a Windows Form.

•

Use the LinkLabel control to add Web-style links to Windows Forms applications.

•

Provide a list of options on a Windows Form by using a ListBox control, a ComboBox control, or a CheckedListBox control.

•

Configure the layout and functionality of a Windows Form to display a list of items.

•

Implement value-setting controls on a Windows Form.

•

Configure a WebBrowser control.

•

Add and configure date-setting controls on a Windows Form.

•

Display images by using Windows Forms controls.

•

Configure the NotifyIcon component.

•

Create access keys for Windows Forms controls.

Create and configure menus.

•	Create and configure a MenuStrip component on a Windows Form.
•	Change the displayed menu structure programmatically.
•	Create and configure the ContextMenuStrip component on a Windows Form.

Integrating Data in a Windows Forms Application

Implement data-bound controls.

•

Use the DataGridView control to display and update the tabular data contained in a data source.

•

Use a simple data-bound control to display a single data element on a Windows Form.

•

Implement complex data binding to integrate data from multiple sources.

•

Navigate forward and backward through records in a DataSet in Windows Forms.

•

Define a data source by using a DataConnector component.

•

Create data forms by using the Data Form Wizard.

Manage connections and transactions.

•	Configure a connection to a database by using the Connection Wizard.
•	Configure a connection to a database by using Server Explorer.
•	Configure a connection to a database by using the Connection class.
•	Connect to a database by using specific database Connection objects.
•	Enumerate through instances of Microsoft SQL Server.
•	Open an ADO.NET connection to a database.
•	Close an ADO.NET connection to a database by using the Close method of the Connection object.
•	Protect access to data source connection details.
•	Create a connection designed for reuse in a connection pool.
•	Control a connection pool by configuring ConnectionString values based on database type.
•	Use the Connection events to detect database information.
•	Handle exceptions when connecting to a database.
•	Perform transactions by using the Transaction object.

Read, write, and validate XML by using the XmlReader class and the XmlWriter class.

•	Read XML data by using the XmlReader class.
•	Read all XML element and attribute content.
•	Read specific element and attribute content.
•	Read XML data by using the XmlTextReader class.
•	Read node trees by using the XmlNodeReader class.
•	Validate XML data by using the XmlValidatingReader class.
•	Write XML data by using the XmlWriter class.

Enhancing Usability

Create, configure, and customize user assistance controls and components.

•	Configure the PropertyGrid component.
•	Configure the ProgressBar control to indicate progress graphically.
•	Display status information by using the StatusStrip control.
•	Configure the ToolTip component.
•	Configure the ErrorProvider component.
•	Configure the HelpProvider component.
•	Play system sounds and audio files by using the SoundPlayer.
•	Configure the Timer component to raise an event at regular intervals.
•	Enable scrolling by using the HScrollBar and VScrollBar controls.

Implementing Asynchronous Programming Techniques to Improve the User Experience

Manage a background process by using the BackgroundWorker component.

•	Run a background process by using the BackgroundWorker component.
•	Announce the completion of a background process by using the BackgroundWorker component.
•	Cancel a background process by using the BackgroundWorker component.
•	Report the progress of a background process by using the BackgroundWorker component.
•	Request the status of a background process by using the BackgroundWorker component.

Configuring and Deploying Applications

Configure the installation of a Windows Forms application by using ClickOnce technology.

•	Install a Windows Forms application on a client computer by using ClickOnce deployment.
•	Install a Windows Forms application from a server by using ClickOnce deployment.
•	Configure the required permissions of an application by using ClickOnce deployment.

Manage control layout on a Windows Form.

•

Group and arrange controls by using the Panel control, GroupBox control, TabControl control, FlowLayoutPanel control, and TableLayoutPanel control.

•

Use the SplitContainer control to create dynamic container areas.

Add and configure a Windows Forms control.

•

Use the integrated development environment (IDE) to add a control to a Windows Form or other container control of a project at design time.

•

Add controls to a Windows Form at run time.

•

Configure controls on a Windows Form at design time to optimize the UI.

•

Modify control properties.

•

Configure controls on a Windows Form at run time to ensure that the UI complies with best practices.

•

Create and configure command controls on a Windows Form.

•

Create and configure text edit controls on a Windows Form.

•

Create and configure text display controls on a Windows Form.

•

Use the LinkLabel control to add Web-style links to Windows Forms applications.

•

Provide a list of options on a Windows Form by using a ListBox control, a ComboBox control, or a CheckedListBox control.

•

Configure the layout and functionality of a Windows Form to display a list of items.

•

Implement value-setting controls on a Windows Form.

•

Configure a WebBrowser control.

•

Add and configure date-setting controls on a Windows Form.

•

Display images by using Windows Forms controls.

•

Configure the NotifyIcon component.

•

Create access keys for Windows Forms controls.

Create and configure menus.

•	Create and configure a MenuStrip component on a Windows Form.
•	Change the displayed menu structure programmatically.
•	Create and configure the ContextMenuStrip component on a Windows Form.

Integrating Data in a Windows Forms Application

Implement data-bound controls.

•

Use the DataGridView control to display and update the tabular data contained in a data source.

•

Use a simple data-bound control to display a single data element on a Windows Form.

•

Implement complex data binding to integrate data from multiple sources.

•

Navigate forward and backward through records in a DataSet in Windows Forms.

•

Define a data source by using a DataConnector component.

•

Create data forms by using the Data Form Wizard.

Manage connections and transactions.

•	Configure a connection to a database by using the Connection Wizard.
•	Configure a connection to a database by using Server Explorer.
•	Configure a connection to a database by using the Connection class.
•	Connect to a database by using specific database Connection objects.
•	Enumerate through instances of Microsoft SQL Server.
•	Open an ADO.NET connection to a database.
•	Close an ADO.NET connection to a database by using the Close method of the Connection object.
•	Protect access to data source connection details.
•	Create a connection designed for reuse in a connection pool.
•	Control a connection pool by configuring ConnectionString values based on database type.
•	Use the Connection events to detect database information.
•	Handle exceptions when connecting to a database.
•	Perform transactions by using the Transaction object.

Read, write, and validate XML by using the XmlReader class and the XmlWriter class.

•	Read XML data by using the XmlReader class.
•	Read all XML element and attribute content.
•	Read specific element and attribute content.
•	Read XML data by using the XmlTextReader class.
•	Read node trees by using the XmlNodeReader class.
•	Validate XML data by using the XmlValidatingReader class.
•	Write XML data by using the XmlWriter class.

Enhancing Usability

Create, configure, and customize user assistance controls and components.

•	Configure the PropertyGrid component.
•	Configure the ProgressBar control to indicate progress graphically.
•	Display status information by using the StatusStrip control.
•	Configure the ToolTip component.
•	Configure the ErrorProvider component.
•	Configure the HelpProvider component.
•	Play system sounds and audio files by using the SoundPlayer.
•	Configure the Timer component to raise an event at regular intervals.
•	Enable scrolling by using the HScrollBar and VScrollBar controls.

Implementing Asynchronous Programming Techniques to Improve the User Experience

Manage a background process by using the BackgroundWorker component.

•	Run a background process by using the BackgroundWorker component.
•	Announce the completion of a background process by using the BackgroundWorker component.
•	Cancel a background process by using the BackgroundWorker component.
•	Report the progress of a background process by using the BackgroundWorker component.
•	Request the status of a background process by using the BackgroundWorker component.

Configuring and Deploying Applications

Configure the installation of a Windows Forms application by using ClickOnce technology.

•	Install a Windows Forms application on a client computer by using ClickOnce deployment.
•	Install a Windows Forms application from a server by using ClickOnce deployment.
•	Configure the required permissions of an application by using ClickOnce deployment.

Manage control layout on a Windows Form.

•

Group and arrange controls by using the Panel control, GroupBox control, TabControl control, FlowLayoutPanel control, and TableLayoutPanel control.

•

Use the SplitContainer control to create dynamic container areas.

Add and configure a Windows Forms control.

•

Use the integrated development environment (IDE) to add a control to a Windows Form or other container control of a project at design time.

•

Add controls to a Windows Form at run time.

•

Configure controls on a Windows Form at design time to optimize the UI.

•

Modify control properties.

•

Configure controls on a Windows Form at run time to ensure that the UI complies with best practices.

•

Create and configure command controls on a Windows Form.

•

Create and configure text edit controls on a Windows Form.

•

Create and configure text display controls on a Windows Form.

•

Use the LinkLabel control to add Web-style links to Windows Forms applications.

•

Provide a list of options on a Windows Form by using a ListBox control, a ComboBox control, or a CheckedListBox control.

•

Configure the layout and functionality of a Windows Form to display a list of items.

•

Implement value-setting controls on a Windows Form.

•

Configure a WebBrowser control.

•

Add and configure date-setting controls on a Windows Form.

•

Display images by using Windows Forms controls.

•

Configure the NotifyIcon component.

•

Create access keys for Windows Forms controls.

Create and configure menus.

•	Create and configure a MenuStrip component on a Windows Form.
•	Change the displayed menu structure programmatically.
•	Create and configure the ContextMenuStrip component on a Windows Form.

Integrating Data in a Windows Forms Application

Implement data-bound controls.

•

Use the DataGridView control to display and update the tabular data contained in a data source.

•

Use a simple data-bound control to display a single data element on a Windows Form.

•

Implement complex data binding to integrate data from multiple sources.

•

Navigate forward and backward through records in a DataSet in Windows Forms.

•

Define a data source by using a DataConnector component.

•

Create data forms by using the Data Form Wizard.

Manage connections and transactions.

•	Configure a connection to a database by using the Connection Wizard.
•	Configure a connection to a database by using Server Explorer.
•	Configure a connection to a database by using the Connection class.
•	Connect to a database by using specific database Connection objects.
•	Enumerate through instances of Microsoft SQL Server.
•	Open an ADO.NET connection to a database.
•	Close an ADO.NET connection to a database by using the Close method of the Connection object.
•	Protect access to data source connection details.
•	Create a connection designed for reuse in a connection pool.
•	Control a connection pool by configuring ConnectionString values based on database type.
•	Use the Connection events to detect database information.
•	Handle exceptions when connecting to a database.
•	Perform transactions by using the Transaction object.

Read, write, and validate XML by using the XmlReader class and the XmlWriter class.

•	Read XML data by using the XmlReader class.
•	Read all XML element and attribute content.
•	Read specific element and attribute content.
•	Read XML data by using the XmlTextReader class.
•	Read node trees by using the XmlNodeReader class.
•	Validate XML data by using the XmlValidatingReader class.
•	Write XML data by using the XmlWriter class.

Enhancing Usability

Create, configure, and customize user assistance controls and components.

•	Configure the PropertyGrid component.
•	Configure the ProgressBar control to indicate progress graphically.
•	Display status information by using the StatusStrip control.
•	Configure the ToolTip component.
•	Configure the ErrorProvider component.
•	Configure the HelpProvider component.
•	Play system sounds and audio files by using the SoundPlayer.
•	Configure the Timer component to raise an event at regular intervals.
•	Enable scrolling by using the HScrollBar and VScrollBar controls.

Implementing Asynchronous Programming Techniques to Improve the User Experience

Manage a background process by using the BackgroundWorker component.

•	Run a background process by using the BackgroundWorker component.
•	Announce the completion of a background process by using the BackgroundWorker component.
•	Cancel a background process by using the BackgroundWorker component.
•	Report the progress of a background process by using the BackgroundWorker component.
•	Request the status of a background process by using the BackgroundWorker component.

Configuring and Deploying Applications

Configure the installation of a Windows Forms application by using ClickOnce technology.

•	Install a Windows Forms application on a client computer by using ClickOnce deployment.
•	Install a Windows Forms application from a server by using ClickOnce deployment.
•	Configure the required permissions of an application by using ClickOnce deployment.

Welcome, PJ!

2006-11-19T20:54:00Z

My first son was born to us this week, entering into the world happy and alert. What a change! Now my days are filled with baby bottles and diaper changing. Here's a look at him during the weigh in.

Create a custom IWorkItemActivationSerivce for the Composite UI Application Block

2006-11-07T02:09:00Z

Sooner or later, I'm convinced that most advanced implementations of CAB will have to write their own version of the IWorkItemActivationService. The WorkItemActivationService is closely tied into the lifecycle of the CAB WorkItem so please make sure you understand about WorkItem.Status otherwise this post will make no sense!

The concept of IWorkItemActivationSerice is simple. Everytime a WorkItem changes status it registers the status change with an implementation of IWorkItemActivationService by calling the ChangeStatus method as in the following code from the WorkItem class:

if (ActivationService != null)
{
	ActivationService.ChangeStatus(this);
}

The default implementation of IWorkItemActivationService is found in the SimpleWorkItemActivationClass:

public void ChangeStatus(WorkItem item)
{
   lock (syncroot)
   {
      if (item != activeWorkItem && item.Status == WorkItemStatus.Active)
      {
         if (activeWorkItem != null && activeWorkItem.Status != WorkItemStatus.Terminated)
            activeWorkItem.Deactivate();

         activeWorkItem = item;
      }
   }
}

The purpose of this code is to ensure that only one WorkItem at a time is active (if a new WorkItem is being activated it simply deactivates the previously active one). Besides the bug (which I'll point out in a minute), this code may not suit your needs. In my case, when a child WorkItem activates I don't want to deactivate the parent WorkItem because the WorkItem is programmed to disable (hide) certain toolbars when the WorkItem deactivates. Hiding and showing toolbars caused too much flicker. The bug is subtle and would only cause a problem in rare instances. The bug is that during the execution of activeWorkItem there are two WorkItems with a status of Active! Obviously item.Status is Active but so is activeWorkItem.Status (using the object references from the code sample above). If you were to query the activation service for active work item inside the Deactivate event it should point to the workitem that just became active, not the workitem that is being activated.

So, to implement my custom activation service, I had to follow a couple of steps. First, subtype the IWorkItemActivationService to expose the currently active WorkItem. Sometimes its nice for client code to know which workitem is active:

    public interface IMyWorkItemActivationService : IWorkItemActivationService
    {
        /// 
        /// The currently active work item
        /// 
        WorkItem ActiveWorkItem { get; set; }
    }

Then implement the new interface with the bug fix in place.

    /// 
    /// An implementation of IWorkItemActivationService that tracks the 
    /// last activated work item
    /// 
    [Service]
    public class WorkItemActivationSerivce : IMyWorkItemActivationService
    {
        private object syncroot = new object();
        private WorkItem activeWorkItem;

        /// 
        /// The currently active work item
        /// 
        public WorkItem ActiveWorkItem
        {
            get
            {
                return activeWorkItem;
            }
            set
            {
                activeWorkItem = value;
            }
        }

        /// 
        /// Initializes a new instance of the  class.
        /// 
        public WorkItemActivationSerivce()
        {
        }

        #region IWorkItemActivationService Members

        public void ChangeStatus(WorkItem item)
        {

            lock (syncroot)
            {
                if (item != activeWorkItem && item.Status == WorkItemStatus.Active)
                {
                    WorkItem previouslyActiveWorkItem = activeWorkItem;

                    //update the currently active work item
                    //this needs to be set BEFORE the deactivate is called
                    //so that during the execution of deactivate this service knows which work item is active
                    activeWorkItem = item;

                    //deactivate the currently active work item
                    //ONLY if the newly active work item is not a child work item
                    //TODO: may have to recursively descend through workitem containership hierarchy
                    //to look for descendants
                    if (previouslyActiveWorkItem != null 
                        && previouslyActiveWorkItem.Status != WorkItemStatus.Terminated
                        && previouslyActiveWorkItem.WorkItems.ContainsObject(item) == false)
                    {
                        previouslyActiveWorkItem.Deactivate();
                    }

                }
            }

        }

        #endregion
    }

Next, update your app.config to add the service.

serviceType="Microsoft.Practices.CompositeUI.IWorkItemActivationService, Microsoft.Practices.CompositeUI" instanceType="YourNamespace.WorkItemActivationSerivce, YourDll" />

I like to be able to query the system for the ActiveWorkItem from my WorkItem base class.

        /// 
        /// The currently active work item
        /// 
        public WorkItem ActiveWorkItem
        {
            get
            {
                IMyWorkItemActivationService wias = this.RootWorkItem.Services.Get() as IMyWorkItemActivationService;
                if (wias == null) return null;
                return wias.ActiveWorkItem;
            }
            set
            {
                IMyWorkItemActivationService wias = this.RootWorkItem.Services.Get() as IMyWorkItemActivationService;
                if (wias != null)
                {
                    wias.ActiveWorkItem = value;
                }
            }
        }

Finally, I had to create a new implementation of the WorkItem.Activate method to deactivate (and then reactivate) the workitem in case a WorkItem outside of the currently active WorkItem hierarchy becomes active. This is a bit of a hack but it worked for my immediate purposes.

        public new void Activate()
        {
            //because of the new workitemactivationservice, more than two work items can be active at a time
            //Activate may now have to fire the activating work item events 
            // even if it is already activated.
            //only suppress the deactivate if the previously activated work item was a child work item
            if (this.Status == WorkItemStatus.Active 
                && this.WorkItems.ContainsObject(this.ActiveWorkItem) == false)
            {
                Deactivate();
            }
            this.ActiveWorkItem = this;
            base.Activate();
        }

Unit testing Composite UI Application Block modules

2006-11-07T01:32:00Z

Unit testing of CAB modules can be difficult because of all the dependency injection going on. Typically you will unit test at least all your presenters. The problem is that you will probably need the presenter to be built up by Objectbuilder which injects the references to WorkItem and State objects on the presenter. What you need is some mock object that takes the place of the RootWorkItem providing a context under which to run your WorkItems and presenters. Take a cue from the PAG team and borrow their TestableRootWorkItem from the nUnit project that comes with CAB.

Although you may be able to use it out of the box, the reality is that you will probably need to modify it to add services that your WorkItems require. Just add these in the TestableAddServices method.

using Microsoft.Practices.CompositeUI.BuilderStrategies;
using Microsoft.Practices.CompositeUI.Commands;
using Microsoft.Practices.CompositeUI.EventBroker;
using Microsoft.Practices.ObjectBuilder;
using Microsoft.Practices.CompositeUI.Services;

namespace Microsoft.Practices.CompositeUI.Tests
{
    public class TestableRootWorkItem : WorkItem //WorkItemBase
    {
        public TestableRootWorkItem()
        {
            InitializeRootWorkItem(CreateBuilder());

            Services.AddNew<CommandAdapterMapService, ICommandAdapterMapService>();
            Services.AddNew<TraceSourceCatalogService, ITraceSourceCatalogService>();

            TestableAddServices();

            BuildUp();
        }

        protected virtual void TestableAddServices()
        {
            //Do these module loaders really need to be added?
            Services.AddNew<ModuleLoaderService, IModuleLoaderService>();
        }

        public Builder Builder
        {
            get { return InnerBuilder; }
        }

        public IReadWriteLocator Locator
        {
            get { return InnerLocator; }
        }

        private Builder CreateBuilder()
        {
            Builder builder = new Builder();

            builder.Strategies.AddNew<EventBrokerStrategy>(BuilderStage.Initialization);
            builder.Strategies.AddNew<CommandStrategy>(BuilderStage.Initialization);
            builder.Strategies.AddNew<ObjectBuiltNotificationStrategy>(BuilderStage.PostInitialization);

            builder.Policies.SetDefault<ObjectBuiltNotificationPolicy>(new ObjectBuiltNotificationPolicy());
            builder.Policies.SetDefault<ISingletonPolicy>(new SingletonPolicy(true));

            return builder;
        }
    }
}

Using the TestableRootWorkItem is easy. The key is to realize that ObjectBuilder builds up an object when you add the object to a ManagedObjectCollection such as WorkItem.Items. The simple act of adding the object to the collection causes all dependent objects to be injected. Here's a sample test.

        [Test]
        public void RunBatchClose()
        {
            TestableRootWorkItem root = new TestableRootWorkItem();
            BatchCloseWorkItem wi = root.WorkItems.AddNew<BatchCloseWorkItem>();
            BatchCloseController controller = wi.Items.AddNew<BatchCloseController>();
            DataImportDTO batch = GetFirstOpenBatch();
            Assert.IsNotNull(batch);
        }