Net Knowledge

RUAlive 0.2 released

admin — Tue, 02 Oct 2007 22:39:00 GMT

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

admin — Sun, 30 Sep 2007 18:14:00 GMT

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.

admin — Thu, 27 Sep 2007 04:27:00 GMT

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

admin — Mon, 12 Mar 2007 18:50:00 GMT

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!

admin — Thu, 01 Mar 2007 00:29:00 GMT

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

admin — Sat, 24 Feb 2007 17:44:00 GMT

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.

admin — Wed, 24 Jan 2007 19:27:00 GMT

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

admin — Mon, 22 Jan 2007 20:54:00 GMT

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

admin — Sun, 21 Jan 2007 22:00:00 GMT

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

admin — Thu, 18 Jan 2007 18:56:00 GMT

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

admin — Thu, 18 Jan 2007 17:11:00 GMT

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

admin — Sat, 16 Dec 2006 21:48:00 GMT

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!

admin — Sun, 19 Nov 2006 20:54:00 GMT

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

admin — Tue, 07 Nov 2006 02:09:00 GMT

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

admin — Tue, 07 Nov 2006 01:32:00 GMT

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);
        }

Getting Started with WCF in Vista RC1

dfoderick — Tue, 26 Sep 2006 20:58:00 GMT

At my current gig, we're getting ready to use Windows Communications Framework as the platform for our middle tier. Here's the simplified instructions on how to get rolling.

On a pristine machine with XP SP2 and .NET 2.0 installed, do the following.
1. Install Vista RC1, 3.0 Runtime and the Visual Studio extensions
2. Follow the instructions for the One Time WCF Samples Setup
3. If you installed IIS after installing .NET, register IIS by running aspnet_regiis -i in the .NET 2.0 directory
4. Explode the WCF samples from C:\Program Files\Microsoft SDKs\Windows\v6.0\Samples and run the Getting Started sample in WCFSamples\TechnologySamples\Basic\GettingStarted\CS\GettingStarted.sln

If the project runs then you're all ready to roll.

Fixing the "There is already an open DataReader associated with this Command which must be closed first." exception in Entity Framework

dfoderick — Wed, 20 Sep 2006 20:18:00 GMT

Once you get your model, database and mapping metadata files configured correctly for Entity Framework, one of the first exceptions that you're likely to face is the DataReader already open exception. It will normally surface when you're iterating over a result set and then lazy loading a child collection. In the following example I have a Contact entity that has a Phone collection. If I lazy load the Phones then I'll get the DataReader exception.

                var contacts = from c in db.Contact
                                select c;

                foreach (Contact c in contacts)
                {
                    if (c.Phones.IsLoaded == false)
                        c.Phones.Load();

                    if (c.Phones.Count > 0)
                    {
                        Console.WriteLine(c.LastName);
                        foreach (ContactPhone p in c.Phones)
                        {
                            Console.WriteLine("\t"+p.ContactPhoneId);
                        }
                    }
                }

The reason for the exception is that there is an open data reader while reading in the contacts and then the loading of the child Phone collection is attempting to open another DataReader. By default, the SqlClient ADO.NET driver does not allow this.

There are two ways to fix this. First, if you are using SQL Server 2005, you can just enable MARS in your connection string.

	
	
add name="YourDBConnectionString" connectionString="metadata=.;
	provider=System.Data.SqlClient;provider connection string="Data Source=irv-dev-vms05;Initial Catalog=YourDB;Integrated Security=True;
	MultipleActiveResultSets=true"" providerName="System.Data.Mapping" /

A second option is to read all the results into memory in one shot and close the connection. Then you are free to open another connection to the database to read in the child entities. So how do you control this? The trip to the database does not happen when the LINQ statement is assigned to the var in the code above. Instead, the query to the database happens during the inplicit call to the enumerator of the contacts collection. To force all the contacts to be loaded, simply copy them to a list in memory using the ToList method and then continue the normal processing.

                var contacts = from c in db.Contact
                                select c;

                List results = contacts.ToList();

                foreach (Contact c in results)
                {
                    if (c.Phones.IsLoaded == false)
                        c.Phones.Load();

                    if (c.Phones.Count > 0)
                    {
                        Console.WriteLine(c.LastName);
                        foreach (ContactPhone p in c.Phones)
                        {
                            Console.WriteLine("\t"+p.ContactPhoneId);
                        }
                    }
                }

This works as expected. Another important realization here is that there is an open connection to the database as long as you are reading in records through that enumerator! A novice programmer may unwittingly include a massive number of time consuming operations within the foreach loop (calling a web service, for example, comes to mind) which will keep the connection to the database open for an inordinate length of time. Of course, you won't fall into that trap.

Lifecycle of a WorkItem

dfoderick — Sun, 10 Sep 2006 18:01:00 GMT

An important facet of programming with the Composite UI Application Block is understanding the sequence of events that fire during the lifetime of a WorkItem. For example, in the Activate event for your WorkItem you may want to enable some toolbar or menu items and then show a view.

WorkItem events fall into 3 categories. The startup event is RunStarted. The operating events are Activating, Activated, Deactivating and Deactivated. The shutdown events are Terminating and Terminated. These events follow the standard .NET conventions. For example, Activating fires before Activated and is cancelable.

RunStarted fires during the Run method. Activating fires before the WorkItem status changes to Active - Activated fires after. Deactivating fires before the WorkItem status changes to Inactive - Deactivated fires after the status change. Terminating fires before the WorkItem status changes to Terminated - Terminated fires after.

These WorkItem events are the foundation of WorkItemExtensions.

Catch First Chance Exceptions to debug CAB Pub/Sub Events

dfoderick — Sat, 02 Sep 2006 19:38:00 GMT

Debugging the Composite UI Application Block EventBroker can be a lesson in frustration. Often, an event subscription can do something substantial such as show a View or run a WorkItem. Should the event subscriber throw an exception, you get a not-so-helpful exception message caught at the publisher that reads something like "One or more exceptions occured while firing the topic 'YourEvent'". Gee, thanks. No stack. No inner exception. So how do you debug this sucker?

Of course, you could trace through your handler, line-by-line, but there is a better way. The trick is to catch first chance exceptions. Whenever you are running in debug mode in Visual Studio and an exception occurs you can control what happens. By default the exception will be thrown and handled by your application's code exactly as it would be at runtime in the production app. But, toggle a debugger setting and you can now tell Visual Studio to jump into the debugger at exactly where the exception occured with the stack at exactly the point BEORE the exception is thrown! This is a first chance exception because you have a chance to debug it before the exception happens. Its a great productivity tool, ESPECIALLY when you work on a team where some members love to eat exceptions!!! Now you can actually see the crap that your fellow programmers have swept under the rug and you can now properly debug your app.

Here's how to enable this magic.
1. In Visual Studio, press Control+Alt+E. You get the Exceptions window.
2. Notice that next to Common Language Runtime Exceptions, Thrown is not checked. Check it off at this level to debug into all CLS Exceptions or drill down if you are only interested in specific exception types.
3. Click Ok

Now you are in debugging bliss. Whenever an exception happens the Visual Studio debugger will be happily pointing you to exactly the source of the problem.

DataEventArgs: a generic EventArgs Class

dfoderick — Sat, 02 Sep 2006 19:36:00 GMT

Back in the bad old days, before generics, writing custom event handlers to pass additional data to the event subscriber was a pain in the butt. With the built in .NET 1.0 EventHandler you can signal that an event occured. Thats' fine except that the event handler usually needs more information about an event in order to do its job. Under .NET 1.0 you have a couple of solutions. You can cast the sender object to a specific known type and pull off the properties you need or you could define a delegate for the EventHandler and also subclass the EventArgs class to define the additional data to be passed to the handler. Casting the sender leads to brittle, highly coupled code. Creating the delegate and EventArgs subclass is not overly difficult but it does eat some brain cycles and leads to an explosion of classes.

Fortunately, with CAB and .NET 2.0 generics there is a much easier way called DataEventArgs. No casting, no delegate and no EventArgs subclass needed. Here's how you use it. First, define your event along with the custom data that will be send to the handler like this:

public event EventHandler<DataEventArgs<Account>> AccountSelected;

In this example I am defining an event called AccountSelected and the event publisher will pass an Account object to the event subscriber. Account is just one of my domain model classes but it could be any type of object including something like a string or int.

Whenever a new Account is selected I can raise the AccountSelected event with this code:

public void OnAccountSelected(Account a)
{
   if (AccountSelected != null)
   {
      AccountSelected(this, new DataEventArgs<Account>(a));
   }
}

Now your subscriber (the event handler) simply reads the data off the passed DataEventArgs object.

public void AccountSelected(object sender, DataEventArgs<Account> e)
{
ShowView();
presenter.SelectAccount(e.Data);
}

This is much simpler than the equivalent 1.0 code. The passed data is exposed in the Data property of the EventArgs object and it doesn't need to be casted to use it.

If you want to use this class just include it in your own library.

//===============================================================================
// Microsoft patterns & practices
// CompositeUI Application Block
//===============================================================================
// Copyright © Microsoft Corporation.  All rights reserved.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE.
//===============================================================================

using System;
using System.Collections.Generic;
using System.Text;

namespace Microsoft.Practices.CompositeUI.Utility
{
    public class DataEventArgs<TData> : EventArgs
    {
        TData data;

        public DataEventArgs(TData data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            this.data = data;
        }

        public TData Data
        {
            get { return data; }
        }

        public override string ToString()
        {
            return data.ToString();
        }
    }
}

//===============================================================================
// Microsoft patterns & practices
// CompositeUI Application Block
//===============================================================================
// Copyright © Microsoft Corporation.  All rights reserved.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE.
//===============================================================================

using System;
using System.Collections.Generic;
using System.Text;

namespace Microsoft.Practices.CompositeUI.Utility
{
    public class DataEventArgs<TData> : EventArgs
    {
        TData data;

        public DataEventArgs(TData data)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            this.data = data;
        }

        public TData Data
        {
            get { return data; }
        }

        public override string ToString()
        {
            return data.ToString();
        }
    }
}

Workaround for Injecting menu items into CAB Shell MenuStrip

dfoderick — Wed, 30 Aug 2006 17:52:00 GMT

Anyone who has worked with CAB for a while has probably been bitten by a limitation of the UIExtensionSite when adding menu items into the shell from a module. The limitiation is that the UIExtensionSite only supports the Add method to add additional items to a UI element. Translated to a MenuStrip example, that means that you can only add menu items to the shell's menu. For example, in your shell you define the File menu with an Exit item. Registering the File menu as an extension site, you can now add menu items to the File menu and they will be added after the Exit item. The results are probably not what you want. What can you do if you want to insert new items before the Exit item? Read on.

The key to working around the problem is to realize that you have a great deal of flexibility in which UI elements you expose as extension sites. For a MenuStrip in the shell there are three basic choices for what to expose. I will call them Top level, Detail level and Individual item.

Expose the Top level menu items if you want to add more top level menu items from a module. For example if you have File and Edit menu itmes and you want to add a top level menu called "My Menu" then register the top level like this:

RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.MainMenu, this.Shell.MainMenuStrip.Items);

In your module, add the new top level menu item.

UIExtensionSites[UIExtensionSiteNames.MainMenu].Add(new ToolStripMenuItem("My Menu"));

"My Menu" will appear as the rightmost top level menu.

Expose a detail level menu collection to add additional menu items after any items that are already defined in the shell. For example if you have a File menu with an Exit item then registering it like this

ToolStripMenuItem fileItem = (ToolStripMenuItem)Shell.MainMenuStrip.Items[0];
RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.FileMenu, fileItem.DropDownItems);

and adding a menu item like this

UIExtensionSites[UIExtensionSiteNames.FileMenu].Add(new ToolStripMenuItem("New"));

will yield a File menu with Exit then New.

So it seems you can only add items to the end of the list! What if you wanted that New menu item to be placed before the Exit item? Ok, here the trick. The third option is to register an invisible individual menu item as the first menu item in the File menu. When you register this individual item and Add to it, items will appear after it in the list. So the registration code looks like this:

             //need a placeholder menu item to add items after
            ToolStripSeparator placeHolderTool = new ToolStripSeparator();
            placeHolderTool.Visible = false;
            fileItem.DropDownItems.Insert(0,placeHolderTool);
            RootWorkItem.UIExtensionSites.RegisterSite(UIExtensionSiteNames.FileMenu, placeHolderTool);

Now when you add the New menu item

UIExtensionSites[UIExtensionSiteNames.FileMenu].Add(new ToolStripMenuItem("New"));

You get a File menu with with New then Exit as a result.

The little magic that makes this possible is in the ToolStripUIAdapterFactory. It looks at what kind of ui element you are exposing and creates the correct adapter for it. The adapter knows how to handle each situation and performs the correct implementation for you.

    public class ToolStripUIAdapterFactory : IUIElementAdapterFactory
    {
        /// <summary>
        /// See <see cref="IUIElementAdapterFactory.GetAdapter"/> for more information.
        /// </summary>
        public IUIElementAdapter GetAdapter(object uiElement)
        {
            if (uiElement is ToolStrip)
                return new ToolStripItemCollectionUIAdapter(((ToolStrip)uiElement).Items);

            if (uiElement is ToolStripItem)
                return new ToolStripItemOwnerCollectionUIAdapter((ToolStripItem)uiElement);

            if (uiElement is ToolStripItemCollection)
                return new ToolStripItemCollectionUIAdapter((ToolStripItemCollection)uiElement);

            throw new ArgumentException("uiElement");
        }
...

What is a WorkItemExtension?

dfoderick — Fri, 25 Aug 2006 17:41:00 GMT

The Composite UI Application Block (CAB) is all about writing loosely coupled plug-in modules for Smart Client apps. What happens when someone has written a module and you want to enhance its behavior without modifying the original code? You write a WorkItemExtension.

First a little background. A WorkItem represents a particular use case, like editing a customer, for example. As a container for the use case, it contains a view and a presenter. In the bank teller sample, the CustomerWorkItem displays a CustomerView that allows the user to edit customer data. Now someone else comes along and they want to display additional information to extend the original use case. Of course, subclassing the CustomerWorkItem would not work because there would be no way to tell the original caller of the work item (probably a ModuleInit) to run your subclass instead of the parent. Instead, they would write a CustomerWorkItemExtension to extend the CustomerWorkItem without modifying original CustomerWorkItem code. The WorkItemExtension hooks into all the events of the extended WorkItem (Initialized, Activated, Deactivated, Terminated). The code looks like this:

     [WorkItemExtension(typeof(CustomerWorkItem))]
   public class CustomerWorkItemExtension : WorkItemExtension
   {
        protected override void OnActivated()
       {
                WorkItem.Workspaces[workspace].Show(aditionalView);
        }
   }

Notice that the attribute defines which workitem we are extending and that the WorkItem member variable in this code snippet is the extended WorkItem (CustomerWorkItem in our example).

Another cool trick is to extend your work item base class and include logging or performance metrics for all your work items. The Smart Client Software Factory does this for infrastucture testing.This is a simple example of Aspect Oriented Programming.

Entity SQL Quick Reference Guide: Get your copy

dfoderick — Thu, 24 Aug 2006 21:15:00 GMT

After you install the ADO.NET vNext August 2006 CTP, check out the eSQL quick reference guide in C:\Program Files\Microsoft SDKs\ADO.NET vNext CTP\Docs. It lists some of the more common keywords for building entity queries.

Fixing Smart Tags after installing LINQ/Entity Framework preview

dfoderick — Thu, 24 Aug 2006 20:34:00 GMT

If you're going to play around with the new Entity Framework August 2006 CPT, you'll have to install the May CTP of LINQ. A nasty side affect of that installation is that it wipes out some of your smart tags. To get your VS 2005 environment back in order, you should see the list of known issues and this blog entry from Harmut.

One additional snag that you might encounter is getting a Visual Studio error message when running the devenv /setup /resetuserdata /resetsettings command.The reset does not complete and smart tags are still stunted. In my case, the error was caused by an unruly addin (TestDriven .NET). Uninstalling the addin before resetting Visual Studio should fix it.

Installing HP 6310 All-in-one on a server

dfoderick — Sat, 22 Jul 2006 19:14:00 GMT

Although intended for a desktop environment, the software for the HP 6310 Printer can be installed on a server machine (win2k or win2k3). Just follow these instructions:

1. Copy all the contents of the CD to the computer.

2. Locate autorun.inf file and open it in notepad.

3. Scroll down the notepad until you find "Overide" (sic) parameter under "[SystemRequirements]" and change it from "No" to "Yes", then save.

4. " OSList=410, 490, 500, 501 " ----------------> "OSList=410, 490, 500, 501,502"

5.Now run Setup.exe.

And, if you have other issues installing the software for reasons that appear to have something to do with minimum requirements, just remove the lines from autorun.inf that refer to "warnproduct" or "blockproduct". As always, do this at your own risk!