Service Station, by Aaron Skonnard

My latest article on BizTalk Services

aaron-skonnard — Wed, 28 May 2008 16:24:00 GMT

Jon Flanders and I coauthored an article on BizTalk Services that just went live on the MSDN Magazine web site. We begin the article by discussing ESB's and the trends towards SaaS, and then we describe how BizTalk Services embodies the best of these different worlds through what Microsoft likes to call the Internet Service Bus (ISB). Then we show you how to begin using BizTalk Services within your WCF applications through the new RelayBinding.

If you haven't touched it yet, there's plenty of sample code within the article to help you get started with BizTalk Services on your own. Simply browse to http://labs.biztalk.net, create your own user account, download/install the SDK, and you'll be good to go. Enjoy.

Double Feature: WCF + WF

aaron-skonnard — Fri, 23 May 2008 15:22:00 GMT

We still have a few seats left for our upcoming Double Feature: WCF + WF events. For those new to our Double Feature offerings, the concept is simple: we cover almost two complete 4-day courses (WCF + WF) in one extended hours 5-day week. We call it the firehose methodology.

If you're looking to ramp-up on both of these emerging Connected Systems technologies in the most efficient way possible, take a look at this offering. It's a great way to maximize the ROI on your limited training/travel dollars, especially in today's economy.

The next event is in Irvine on 6/16. If that doesn't work for you, we're also holding one in London on 7/14, another in Chicago on 8/4, and another in Waltham on 9/22. You can save yourself a seat right now without any obligation (simply click “Save a Seat“ instead of “Register Now“).

I will be teaching the Irvine course with Jon Flanders and Chicago with Matt Milner.

Disabling WcfSvcHost.exe when debugging projects

aaron-skonnard — Wed, 21 May 2008 13:17:00 GMT

One of the many new WCF features in Visual Studio 2008 SP1 is a mechanism to control whether the built-in WCF test host application (WcfSvcHost.exe) should automatically launch when debugging other projects in a solution. Prior to this release, there was no way to control this without disabling WcfSvcHost.exe by removing the special ProjectTypeGuid that controls this feature from the .csproj file.

Now, you can simply right click on your WCF Service Library and select Properties. Then in the project properties area you should find a tab called WCF Options, which looks like this:

Simply uncheck the box to disable the WcfSvcHost.exe from starting when debugging other projects within your solution (such as your own custom host application). However, if you attempt debug the WCF Service Library directly (as the startup project), the WcfSvcHost.exe will still launch in that case.

XML Schema Explorer in Visual Studio 2008 SP1

aaron-skonnard — Tue, 20 May 2008 19:34:00 GMT

In case you didn't notice, the XML Schema Designer that was made available as a downloadable CTP back in August 2007 made it into Visual Studio 2008 SP1.

It's now called the XML Schema Explorer. You can read more about it here.

The Ogden Marathon

aaron-skonnard — Mon, 19 May 2008 16:50:00 GMT

Well, like I mentioned back in January, one of my major personal goals for this year has been to complete my first marathon. I started training back in December and followed Hal Hidgon's novice training program. I only missed a few runs here and there but was able to stay pretty consistent throughout the 18 week program. Sometimes it got a little tricky while traveling but thanks to the GMaps Pedometer, LogYourRun.com, and my Garmin Forerunner 305, I was able to figure out decent routes on the fly.

I trained for the Ogden Marathon, which was held this past Saturday. We had to get up at 3:45am to drive into downtown Ogden to catch the buses at 5:00am that shuttled us up the canyon and into the mountains. We arrived at the start line around 6:00am where we found some bon fires and about 50 green porta-potties lined up in a row. There were about 2000 runners, which is max-capacity for this marathon.

My wife and I found our friends we'd been training with and joked around until the start of the race, trying to reduce the nerves as much as possible, hitting the porta-potties occassionally, while trying to stay warm. It was very cold up in the starting area -- cold enough to see our breath. But we also heard we we're going to have record-breaking heat later in the day, somewhere in the 80-90 F range.

After a short motivational speach by Jeff Galloway, the race started promptly at 7:00am and there was no turning back. The first 8 miles of the race was mostly downhill, running down a small canyon into the valley of Pineview Reservoire. The next 10 miles required us to run around the reservoire. There were several long stretches that never seemed to end and only one hill worth mentioning. The route took us to the top of Ogden Canyon, where we began our decent into downtown Ogden. This final canyon decent was about 6 miles long (from miles 17-23), at which point we got on the Ogden River Parkway running path for the next few miles until we emerged onto Grant Street and could see the finish line a mile down the road. So the course was mostly downhill -- and is generally considered easy -- but it didn't turn out that way for me.

There was a great deal of excitement, energy, and adrenaline in the air when the race began. So like an inexperienced first-time-marathoner I started out way too fast. My normal long run pace is a little under 9:00/mile and I ran the first 3-4 miles at a 7:30/mile pace. I knew I was probably running a little too fast for my own good so I slowed it down to an 8:00/mile pace, which I held for most of the first half. At mile 13, my time was about 1:48 so I was totally on pace to crush the 4:00 mark, which was my main time goal.

Going out too fast was my first mistake but not the only one. I also ate and drank too much early in the race. I had a banana, a gatoraide, and a Gu before the race began. Then at the first few aid stations I ate whatever they gave me. I think this amounted to a few more cups of Poweraide, another Gu, and an orange slice. In the end, it was too much stuff, and I started feeling sick to my stomach. So for like the next 10 miles or so all I could handle taking was water, and I could feel my energy levels depleting. At mile 13, it was also starting to get hot, much hotter than the weather we were used to training in.

I hit my first major wall around mile 15 and knew I was in trouble. After the half-way mark, I slowed my pace down to my normal 9:00/mile pace but after mile 15, I was having trouble even maintaining that pace. I still felt a bit nauseus but I also knew I had to get more carbs in my body or I would never make it. So I put some more Gu down and took some fruit at the next aid station and did my best to keep it in. I also started using Jeff Galloway's run/walk technique at this point where I'd run for a mile and then walk for 30 seconds. This helped conserve what little energy I had left until I got to mile 20, where I hit an even bigger wall.

After mile 20, I felt like my body was completely depleted and wasn't sure if I'd be able to propel myself to the finish line. When you start feeling like this, your mind starts playing funny games on you. It's weird. And to top it off, all the running downhill started to hurt my right hip and knee, so I was dealing with some occasional sharp pains, which forced me to stop a stretch periodically. My intervals between run/walk started evening out, and my overall pace slowed down dramatically...closer to a 12:00/mile pace, but that didn't bother me any more, because at this point my newly revised goal was to simply finish.

When I finally emerged into downtown Ogden and saw the finish line, all I could think about was collapsing on the ground. When I got close to the end I saw my family and my son Michael joined me to the finish line. It was an amazing feeling to cross the finish line after such a long internal battle.

My final time was 4:19. So I didn't reach my 4:00 goal but I was very happy to finish. I placed #826, which means that there were more people behind me than in front of me so I felt good about that. ;-)

The heat definitely tooks its toll on me and many of the other runners. Over the last 5-6 miles, it was so hot that several runners collapsed off to the side of the course. I saw 3 groups of policemen trying to revive runners along the way, so I was glad to still have been dragging myself along to some degree. Before the race, Jeff Galloway said that when the temperature is over 60 F, most runners slow down about 30-45 sec per mile. Everyone I talked to after the race, ran somewhere between 20-30 minutes slower than they wanted to so Jeff's estimate was pretty close given my limited sampling.

But heat aside, I think my other two mistakes of 1) going out too fast, and 2) eating too much early on had already done me in. I have much more respect for the race now, the difficulty level, and the importance of training properly and running the race smartly. If there's one thing I learned, it's the importance of running the race just like the long runs in training. There were some amazing athletes out there zooming by me with plenty of energy left at the end of the race and I couldn't help but admire them.

In the end, it was a lot of pain but I'm glad I did it. Although I didn't win any prize money, I did lose 25 lbs, which was the real purpose behind the goal. I feel much healthier now than I have in a long time.

Now the million dollar question: will I ever do another one?

DataContracts and object references

aaron-skonnard — Wed, 14 May 2008 15:44:00 GMT

Another new WCF feature that's part of .NET 3.5 SP1 has to do with better support for object references. DataContractSerializer has always supported serializing object references and dealing with graphs, including cycles, and not just simple trees. But doing so is not the default behavior -- you have to tell DataContractSerializer that you want it to preserve object references when you instantiate it.

Let's look at a simple example. Supposed that you have the following cyclic object graph (I'm assuming the same Person type that I used in my previous post):

Person p = new Person();

p.Id = "123";

p.Name = "Aaron";

p.Spouse = new Person();

p.Spouse.Id = "456";

p.Spouse.Name = "Monica";

p.Spouse.Spouse = p;

...

And now let's supposed that you want to serialize it. If you create the DataContractSerializer using the default constructor, it will throw an exception when it identifies the cycle during serialization. However, you can tell DataContractSerializer to preserve object references using one of the other constructors:

DataContractSerializer dcs = new DataContractSerializer(typeof(Person),

null, int.MaxValue, false, true /* preserve object refs */, null);

using (FileStream fs = new FileStream("person.xml", FileMode.Create))

{

dcs.WriteObject(fs, p);

}

The resulting person.xml file now looks like this:

<Name z:Id="3">Aaron</Name>

<Name z:Id="6">Monica</Name>

</Spouse>

</Person>

Notice that each reference type has been given an “Id” attribute and the nested Spouse reference refers back to the containing Person via the Ref attribute, thereby preserving the references within the XML.

Now, as of SP1, the definitions for the Id/Ref attributes are now part of the generated schema. If you run SvcUtil.exe /dconly over the assembly containing Person, it will produce a schema file for the “http://schemas.microsoft.com/2003/10/Serialization” namespace. And within that schema, you'll find the following definitions for Id/Ref, which are defined as ID/IDREF types:

...

<xs:attribute name="Id" type="xs:ID" />

<xs:attribute name="Ref" type="xs:IDREF" />

...

ID and IDREF are standard DTD/XSD types that are widely supported across platforms.

One problem with employing this object-reference-preservation technique is that you don't have direct control over how the DataContractSerializer is constructed when defining your WCF services. You can, however, implement a behavior that intercepts the standard serializer creation process so that you can enable this feature. Sowmy provides a complete example of how to accomplish this over on his blog.

DataContracts without attributes (POCO support) in .NET 3.5 SP1

aaron-skonnard — Tue, 13 May 2008 20:50:00 GMT

One of the new WCF features in .NET 3.5 SP1 is that DataContractSerializer now supports serializing types that aren’t annotated with any serialization attributes like [DataContract] or [Serializable].

If you were using DataContractSerializer prior to SP1, you had to follow the rules outline by Sowmy here. These rules illustrate that for custom classes you have a few choices. You can annotate the class with [DataContract] and [DataMember] to define an attribute-based mapping or implement IXmlSerializable to define a custom mapping. Or you can annotate the class with [Serializable] to automatically map all fields (like with .NET Remoting) or implement ISerializable to take things into your own hands (assuming IXmlSerializable wasn't used).

However, as you can see from the rules, there is no allowance for types that haven’t been annotated with one of these serialization attributes or that implement one of the serialization-related interfaces, or in other words, you can't serialize “plain old C# objects“ (POCO for short).

The support for [Serializable] provided a nice migration path for traditional .NET Remoting types, which was nice, but the lack of support for POCO types meant you couldn’t move your ASMX types over to the DataContractSerializer without sprinkling a bunch of new attributes on them.

With .NET 3.5 SP1 you can serialize any C# object even if it doesn’t come with any serialization attributes. For example, the following Person type is now serializable by default:

namespace SerializationSp1

{

public class Person

{

private string id;

public string Id { get { return id; } set { id = value; } }

public string Name;

public Person Spouse;

}

...

}

For POCO types, DataContractSerializer only includes the public read/write fields and properties into the resulting XML Infoset. So in our example above, the private “id” field won’t make it into the message. Also, these types must have a public default (no argument) constructor in order to be serialized. The Person type above works find because the compiler gives us a public default constructor but if you were to add a non-default constructor, it would no longer be serializable using this approach.

With this new support, you can use virtually any C# type (with a public default constructor) in your WCF service contracts and you don’t have to worry about changing the serializer back to XmlSerializer using [XmlSerializerFormat]. For example, the following service contract works as-is in .NET 3.5 SP1:

[ServiceContract]

public interface ILookupPerson

{

[OperationContract]

Person GetPerson(string id);

}

Now let’s take a look at the serialized XML for the Person type shown above. Here’s a simple console program that uses DataContractSerializer to serialize a Person object:

class Program

{

static void Main(string[] args)

{

Person p = new Person();

p.Id = "123";

p.Name = "Aaron";

p.Spouse = new Person();

p.Spouse.Id = "456";

p.Spouse.Name = "Monica";

DataContractSerializer dcs = new DataContractSerializer(typeof(Person));

using (FileStream fs = new FileStream("person.xml", FileMode.Create))

{

dcs.WriteObject(fs, p);

}

And here’s what the resulting person.xml file looks like:

<Person xmlns="http://schemas.datacontract.org/2004/07/SerializationSp1"

xmlns:i="http://www.w3.org/2001/XMLSchema-instance">

<Name>Aaron</Name>

<Name>Monica</Name>

</Spouse>

</Person>

The mapping algorithm is similar to what’s used with [DataContract] or [Serializable] – it uses the type name for the root element name, member names for the local element names, and it orders them alphabetically. It also produces a reasonable XML namespace based on the .NET namespace. The only difference is how it chooses what to put into the message – in this case it’s based on the public contract of the type. When you use this approach, you must be happy with the XML that DataContractSerializer gives you. In other words, you can’t customize the resulting XML in any way.

As soon as you place the [DataContract] attribute on the class, DataContractSerializer will only include fields/properties annotated with [DataMember] once again. For example, suppose I make the following change to the Person type by annotating it with [DataContract]:

[DataContract]

public class Person

{

private string id;

public string Id { get { return id; } set { id = value; } }

public string Name;

public Person Spouse;

}

If I run my console program again, the resulting person.xml now looks like this:

Notice that none of the fields were serialized because they weren’t annotated with [DataMember]. Once I applied [DataContract] to Person, DataContractSerializer no longer treated it like a POCO type. The same would hold true if I annotated the type with [Serializable]. If it finds the [Serializable] attribute, it falls back to the [Serializable] mapping and only includes the fields.

To summarize, the new DataContractSerializer provides several different mechanisms for defining the serialization mapping:

1. Simply rely on the public interface and take the default XML mapping

2. Use [Serializable] to only include fields in the mapping

3. Use [DataContract] and [DataMember] and apply some basic customization

4. Use IXmlSerializable or ISerializable for advanced mapping customization

I was actually surprised to learn that they added this feature because it goes against the main reason for the original [DataContract] design (“boundaries are explicit”), at least according to the team in early design reviews. I asked for this feature (an implicit mapping) but my request was dismissed for that very reason. Despite whatever principle it may violate, I like it, because it makes it simpler for folks to get started with WCF and it provides an easier migration path for ASMX.

WCF features/improvements in .NET 3.5 SP1 & VS 2008 SP1

aaron-skonnard — Mon, 12 May 2008 21:00:00 GMT

Scott Guthrie announced the availability of .NET 3.5 SP1 and Visual Studio 2008 SP1 today. If you read his entry, you'll see this release is packed with new features, many of which revolve around the Ajax, MVC, and ADO.NET improvements they've been working on.

However, this release also contains some new WCF nuggets including the following:

New Hosting Wizard for WCF Service projects.
Enhancements in Test Client such as support for RM Sessions, Message Contract and Nullable types enables testing of broader set of WCF-based services.
Expanding reach of DataContract Serializer by relaxing the need of having [DataContract]/ [DataMember] on types and by supporting an interoperable mechanism for dealing with object references.
Improved Partial Trust Debugging Experience with support for Event Log.
Support for ADO.NET Entity Framework entities in WCF contracts.
Improvements in writing REST based services ranging from easily supporting ServiceDocuments publication and consumption to providing greater control and usability of UriTemplate.
Significant performance improvements on large workflow-based projects in Visual Studio.
Considerable scalability increases for hosted WCF services in IIS7-integrated mode.

Update: Steve Maine provides more WCF details in this post and Omri gives his take over here.

You can read more about this release and grab the bits from here.

BizTalk Server 2006 R3 just announced

aaron-skonnard — Wed, 23 Apr 2008 13:50:00 GMT

Steve Martin, director of product management for Microsoft's Connected Systems Division (CSD), just announced their plans for the next version of BizTalk Server on his blog. It will be called BizTalk Server 2006 R3.

This new version will be updated to work with Windows Server 2008, SQL Server 2008, and Visual Studio 2008. It will also be updated with the following SOA-related features:

New web service registry capabilities with support for UDDI v3.0
Enhanced service enablement of applications through new and enhanced adapters
Enhanced service enablement of “edge” devices through BizTalk RFID Mobile
Enhanced interoperability and connectivity support for B2B protocols (like SWIFT, EDI, etc)
SOA patterns and best practices guidance to assist our customer’s implementations

From reading his blog, it doesn't look like they'll be adding official support for hosting WF workflows in this particular release. It looks like we may have to wait for that until Oslo.

DevWeek 2008 wrap-up

aaron-skonnard — Fri, 14 Mar 2008 21:39:00 GMT

I just wrapped up DevWeek 2008, a wonderful developer conference held each year in London. This show brings in some of the best attendees around...I always really enjoy my time here. I'm sitting in my hotel here decompressing before my long journey home. Here are the demos from my sessions:

Programming WCF (workshop)
The ABC's of Programming WCF
Message-Oriented WCF
SOAP, REST, POX, & RSS
Getting Started with BizTalk Server 2006 R2 (workshop)

Thanks again to the attendees for making this a great event once again, for all the thought provoking questions and discussions along the way. Hope to see you again next year!

I'm going to especially miss the Indian food and running along the Thames each morning. I had some Springbok one night while taking a break from India -- quite good actually.

.NET Rocks episode #308

aaron-skonnard — Thu, 17 Jan 2008 16:17:00 GMT

Richard and Carl had me on .NET Rocks today, show #308. Fun stuff.

Thinnovation

aaron-skonnard — Wed, 16 Jan 2008 16:03:00 GMT

This showed up in my inbox yesterday and it was one of those love at first sight moments. How is it that Apple always seems to produce things that I can't seem to live without? They're on a roll. However, I'll probably wait until v2 of this bad boy...hopefully the price of the solid state hard drives will come down a bit by then.

Another nice surprise yesterday -- Apple finally added multi-recipient SMS to iPhone 1.1.3! They also shipped a GPS-like feature into Google Maps that triangulates via cell towers. Plus home screen customization.

Extending WCF with Custom Behaviors

aaron-skonnard — Wed, 16 Jan 2008 15:28:00 GMT

My last Service Station column on Extending WCF with Custom Behaviors is online (it's actually been online for a little while now but I missed blogging about it with the holiday craze). Here's the abstract:

Windows^® Communication Foundation (WCF) provides numerous extensibility points that allow developers to customize the runtime behavior for service dispatching and client proxy invocation. You can tap into these extensibility points by writing custom behaviors that can be applied declaratively to your services. This month I'll show you how this process works.

Goals for 2008

aaron-skonnard — Wed, 16 Jan 2008 15:24:00 GMT

It's that wonderful time of the year again. I have four fundamental career goals for 2008:

Provide more value to customers through improved training content and products
Increase the effectiveness of our website
Publish more technical/training content on this blog
Follow the Oslo wave and explore new areas of interest

I also have one ~~crazy~~ personal goal for 2008:

Run my first marathon

I have a bunch of other personal goals that I won't bore you with but suffice it to say that 2008 is going to be an interesting year in a lot of ways -- a year of huge change (hmm, perhaps I should run for President).

BizTalk Blogs

aaron-skonnard — Tue, 18 Dec 2007 17:22:00 GMT

Microsoft just released a new Web site that aggregates a bunch of BizTalk blogs. However, I should also point out that when they say “BizTalk“ blogs, they are also covering .NET 3.x and other related technologies. Several of us from Pluralsight are included in the list of aggregated blogs.