Pluralsight Blogs

DataContracts and object references

Aaron Skonnard — Wed, 14 May 2008 17: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 22: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 23: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.

Is support coming for BizTalk builds on TFS?

Matt Milner — Tue, 13 May 2008 01:54:00 GMT

According to Brian Harry[1] , he has been working with the BTS folks to get this put in place. He has been assured that this will be part of the R3[2] release of BizTalk Server that is due out next year. Finally, automated builds for BizTalk without all the hassle, I hope this definitely makes it into the product, as right now it is one more thing that makes people think BizTalk is not for .NET developers.

[1] BizTalk Support with TFS

[2] http://blogs.msdn.com/stevemar/archive/2008/04/23/biztalk-server-platform-updates.aspx

Not just a service pack (VS 2008 and .NET 3.5 SP 1)

Matt Milner — Tue, 13 May 2008 01:50:00 GMT

Microsoft has rolled out the beta of SP1 for .NET Framework version 3.5 and Visual Studio 2008. Now don't get confused, this is not just a simple set of bug fixes, this thing is big!

Entity Framework and LINQ to entities
ADO.NET Data Services (formerly project "Astoria")
Dynamic data web sites (highly RAD data driven web sites)
Performance improvements across the board (WCF, WPF, AJAX, debugging, etc.)
New client profile (not quite the slimmed down CLR of silverlight, but gives you a smaller footprint without server technologies you don't need). Now, if they could do the opposite and remove the Windows UI stuff so I could run Windows Server 2008 Server Core with IIS and ASP.NET.
a bunch of perf and usability improvements in VS 2008

I think the Entity stuff, plus the Dynamic data and data services is a killer combination for many web site developers to get their data modeled and quickly expose an admin tool for data maintenance and service endpoints for interaction.

Check out Soma's blog for some high level details and download links:Visual Studio 2008 and .NET FX 3.5 SP1 Beta available now

Scott Gu has details on many of the new features in the IDE and framework: http://weblogs.asp.net/scottgu/archive/2008/05/12/visual-studio-2008-and-net-framework-3-5-service-pack-1-beta.aspx

Brian Harry has the details on the TFS improvements in the SP: Team Foundation Server 2008 SP1 Preview

A metric b*#&load of enhancements for a service pack - awesome job folks, I can't wait for the released bits this summer.

Spaghetti Code Podcast - Connected Systems

Matt Milner — Mon, 12 May 2008 23:56:00 GMT

I got a chance a few weeks ago to sit down with Jeff Brand at the local Microsoft office and talk about something I love - Connected Systems. We discussed Workflow and Biztalk, WCF and web services and how it all fits together. Jeff is fun to talk to and does a good job of asking questions that developers are interested in. The issues most developers face when building connected systems and trying to pick technologies were especially fun to discuss. If you are interested, check out the audio - http://www.slickthought.net/post/2008/05/Spaghetti-Code-Podcast---Matt-Milner-on-Connected-Systems.aspx.

You can also check out some of his other podcasts with more Minneapolis folks on a range of topics: http://www.slickthought.net/category/SpaghettiCode.aspx

Enjoy!

Matt

WCF Strategies for Windows Mobile Webcast

Jim Wilson — Sun, 11 May 2008 15:27:00 GMT

Due to a last minute scheduling problem, my planned appearance on geekSpeak last week to talk about Windows Communications Foundation (WCF) Strategies for Windows Mobile had to be rescheduled.

I realize it's a bit of short notice but I wanted to let everyone know that it is now scheduled for Monday 12-May at 12-noon PDT (3PM EDT, 19:00 UTC). The URL to register for the webcast is still the same.

I really encourage you to come by and checkout this webcast. Although, our initial point of reference is WCF on Windows Mobile, most of what we talk about applies equally to all mobile-oriented applications whether running on a Windows Mobile device, or laptop/notebook computer.

One of the key areas we'll address is the Store and Forward transport and its usefulness in applications that may be intermittently online or that may switch between wired, wireless, or cellular networks.

Remember that geekSpeak webcasts are more interactive than most, allowing an opportunity for you to ask questions and for us to share a very interactive dialog. As always though, I'll be showing some demos so that you can see some real code at work.

I hope to see you there. If you're not yet doing mobile application development, you almost definitely will be doing so very soon and this is a great way to learn about some of the common considerations and solutions for communicating in this loosely-connected environment.

Fowler's DSL Book

Don Box — Sat, 03 May 2008 19:17:00 GMT

I talked to Neal Ford a week or two ago and he mentioned that Martin Fowler is working on a DSL book.

Just found the site here.

Pretty skeletal so far, but I think the underlying ideas are pretty spot on.

Can't wait to see the final manuscript!

Steve Yegge on Emacs

Don Box — Sat, 03 May 2008 19:06:00 GMT

Via Stefan Tilkov:

http://steve-yegge.blogspot.com/2008/04/xemacs-is-dead-long-live-xemacs.html

I've got no opinion on the GNU-vs-XEmacs analysis. I never used XEmacs for more than a day. I stopped using GNU Emacs in November 2003. I'm sure both version of emacs are even gotten better over the past 4+ years.

Had this just been another installment in the GNU-vs-XEmacs soap opera, there'd be nothing to see here.

Sandwiched between this however are some observations that I think are relevant to anyone who writes programs (start reading from “the dubious future of emacs“).

It's hard to argue with the value of self-hosting.

It's even harder to argue with the momentum of the browser and dynamic environments.

MSDN Updates

Craig Andera — Wed, 30 Apr 2008 20:00:00 GMT

Yesterday was a big day for me with respect to MSDN. There were a pair of "the new replaces the old" moments.

The first event was the one Larry Jordan amusingly subtitles "There will be only one!" What happened was, the old MSDN finally got turned off - the MTPS-based version of MSDN is now the only version running. http://msdn2.microsoft.com now redirects to http://msdn.microsoft.com. That means no more fun URLs like https://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/shell/programmersguide/shell_basics/shell_basics_extending/fileassociations/fileassoc.asp. Now it's http://msdn2.microsoft.com/en-us/library/bb776847.aspx. Ahh - that's better.

Since I helped write the Microsoft/TechNet Publishing System (MTPS), which sits behind the new, one-and-only MSDN website (and the TechNet and Expression websites, for that matter), it was sort of cool to see it "take over".

The other thing we did yesterday was to update the MTPS REST API. It's still very much a prototype (i.e. things are broken) but we wanted to push a version out there that has some of our latest thinking in it. Most notably, this release sketches out what we think we want to do for writes. That's right - we intend to support community-authored changes to MSDN (the website supports that now in the form of tags and wiki-like annotations, in case you didn't know).

Although I should point out that the writes aren't implemented yet in the REST API because we haven't fleshed out the story for authentication. But you can see the idea. For example, to add a new tag to an item you'll be able to PUT to http://labs.msdn.microsoft.com/restapi/content/b8a5e1s5/en-us;vs.90/tags/add-tag. And to delete a the foo tag added by user candera you'd DELETE http://labs.msdn.microsoft.com/restapi/content/b8a5e1s5/en-us;vs.90/tags/foo/users/candera. For convenience, we're also planning to support POST to those endpoints with a hidden form parameter of _method, which is set to PUT or DELETE as appropriate. It's just too convenient to be able to drive the service from a browser during development not to do that.

Another big change is what lives at ~/content. In this release it's a link to the ~/sites part of the API. In MTPS parlance, a "site" is the host part of a URL (e.g. the "msdn" in http://msdn.microsoft.com). Underneath those are "iroots", which is a lot like a vdir (e.g. the "academic" in http://msdn.microsoft.com/academic). The reason ~/content links to ~/sites is that via ~/sites you can find your way into the TOC tree of any of the content in MTPS…or at least you could if it were hooked up properly everywhere. Still, you can see the idea.

That said, we've decided that the link to ~/sites is ugly and we hate it. :) So we'll have to figure something else out there. Maybe a set of virtual TOC nodes that unifies all the TOCs - one node to bring them all and in the API bind them. Or something - we're still noodling on that one.

Other changes: we've added ETags and Expires headers to all resources (currently everything is hardcoded to expire 24 hours in the future), fixed some of the encoding problems, added an XHTML DTD where appropriate, and of course there are the obligatory bunch of minor bugfixes. We've also done some slight reorganization of the URLs to fit our evolving understanding of the model, but most things have remained unchanged. I'm curious to hear if anyone has played with the service at all - if you have any questions or feedback, do feel free to contact me.

Work

Don Box — Wed, 30 Apr 2008 06:14:00 GMT

Doug's posted another “we're hiring” missive.

Doug's been running my team for coming up on a year.

Doug has more passion and energy than anyone I've ever worked with.

Getting to work on a team that's building a language and a tool is both exciting and intimidating.

The three most “personal” choices a developer makes are language, tool, and OS.

Working on 2/3rds of that equation is pretty thrilling.

Way more fun than anything else I've ever done with a computer.

Way more fun than blogging, hence the relative silence for the past year or so.

A Whirlwind of Webcasts

Jim Wilson — Tue, 29 Apr 2008 00:23:00 GMT

It looks like Webcast season is upon us J …

Between now and Tech Ed, Maarten Struys and I will be presenting a combined total of 7 webcasts.

This Wednesday, 30-April and next Wednesday, 7-May I'll be the guest on MSDN's geekSpeak.

Then starting next week (week of 5-May), Maarten Struys and I will be co-presenting a multi-part webcast series on a variety of Windows Mobile topics as a lead-in to Tech Ed Developer 2008.

geekSpeak

This Wednesday (30-April) I'll be talking about SQL Server Compact Tips and Tricks (both devices and desktop).

I'm really looking forward to this talk. Those of you who have followed my blog or who have seen my whitepapers or webcasts know that I'm a big fan of SQL Server Compact. Although it provides excellent code & SQL compatibility with SQL Server, the details of the underlying architecture sometimes require a different approach. That's what we'll be talking about … how to get the most out of SQL Server Compact.

Next Wednesday (7-May), I'll be talking about Windows Communication Foundation (WCF) Strategies for Windows Mobile.

Although not the focus of the entire webcast, we'll definitely be talking a bunch about using Store-and-Forward messaging. Whether you're targeting Windows Mobile devices or focus more on desktop applications, you'll want to be there.

Most of the same strategies we use for Windows Mobile applications apply equally to applications running on a laptop/notebook computer with Store-and-Forward messaging being a great example. Any application (Windows Mobile or Laptop-based) that needs to be away from connectivity periodically faces communications challenges that Store-and-Forward messaging addresses as it allows your app to simply send messages and the Store-and-Forward mechanism caches the messages automatically sending them whenever connectivity becomes available.

Bring your questions: If you haven't been to a geekSpeak webcast before, you don't know what you're missing.

These are much more two-way than traditional webcasts. Don't get me wrong, I love traditional webcasts where I get to show you a bunch of code but geekSpeak provides a great adjunct. On geekSpeak we engage much more in a conversation; the discussions are very listener driven with much of the time focused on addressing those things that you ask about.

Countdown to Tech Ed Developer 2008

We don't have all of the details posted yet but staring next week (week of 5-May), Maarten and I will be doing webcasts each week covering a different aspect of Windows Mobile development.

The webcasts are aimed at people who are new to Windows Mobile or who may be looking to gain a deeper understanding of the tools and capabilities of Windows Mobile application development. Keep a watch here on my blog and I'll provide further details on these webcasts as we get them published.

BizTalk Server 2006 R3 just announced

Aaron Skonnard — Wed, 23 Apr 2008 15: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.

Using LINQ to Access SQL Server Compact Directly – A follow up

Jim Wilson — Fri, 18 Apr 2008 20:37:00 GMT

You may recall my webcast from about 6/7 weeks ago where I talked about how to use custom extension methods to allow your mobile device applications to efficiently query a SQL Server Compact (SSC) databases directly.

I received a question today regarding the webcast. The question relates to the verbosity of returning anonymous types when using the technique discussed in the webcast. For example…

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select new
{
ShipName = (string)order["Ship Name"],
ShipAddress = (string)order["Ship Address"],
ShipCity = (string)order["Ship City"],
ShipPostalCode = (string)order["Ship Postal Code"],
ShipCountry = (string)order["Ship Country"],
ShipVia = (int)order["Ship Via"]
};

The verbosity is necessary because "order" in the above LINQ statement is of type SqlCeUpdatableRecord. Although Visual Studio supports generating typed-wrappers for SqlCeResultSet, it doesn't generate wrappers for the SqlCeUpdatableRecord corresponding to the SqlCeResultSet. With that being the case, specifying the individual column values within the anonymous type declaration requires you to use either the indexer (or Getxxx functions).

Ultimately there's nothing we can do about the way the column values are accessed (unless you write your own typed-wrapper generator for SqlCeUpdatableRecord). What we can do is move the code that creates the anonymous type into a separate function.

private object ShippingColumns(SqlCeUpdatableRecord order)
{
return new
{
ShipName = (string)order["Ship Name"],
ShipAddress = (string)order["Ship Address"],
ShipCity = (string)order["Ship City"],
ShipPostalCode = (string)order["Ship Postal Code"],
ShipCountry = (string)order["Ship Country"],
ShipVia = (int)order["Ship Via"]
};
}

With that, the LINQ statement becomes very simple.

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select ShippingColumns(order);

Once we move the anonymous type declaration to a separate function we can take things one step further and optimize the column access by caching the column ordinals and then retrieving the column values using the Getxxx functions.

private object ShippingColumns(SqlCeUpdatableRecord order)
{
if (_nameIndex == -1)
InitializeIndexes(order);

return new
{
ShipName = order.GetString(_nameIndex),
ShipAddress = order.GetString(_addressIndex),
ShipCity = order.GetString(_cityIndex),
ShipPostalCode = order.GetString(_postalCodeIndex),
ShipCountry = order.GetString(_countryIndex),
ShipVia = order.GetInt32(_viaIndex)
};
}

private void InitializeIndexes(SqlCeUpdatableRecord record)
{
_nameIndex = record.GetOrdinal("Ship Name");
_addressIndex = record.GetOrdinal("Ship Address");
_cityIndex = record.GetOrdinal("Ship City");
_postalCodeIndex = record.GetOrdinal("Ship Postal Code");
_countryIndex = record.GetOrdinal("Ship Country");
_viaIndex = record.GetOrdinal("Ship Via");
}

private int _nameIndex = -1;
private int _addressIndex = -1;
private int _cityIndex = -1;
private int _postalCodeIndex = -1;
private int _countryIndex = -1;
private int _viaIndex = -1;

Although not a huge performance increase, storing the column indices does eliminate the overhead of the indexer looking up the column name each time. More importantly, using the strongly-typed Getxxx functions eliminates the overhead of boxing any column values that are value-types. As you know, excessive boxing creates a lot of scrap objects which leads to increased memory and garbage collection overhead.

Using regular class methods like those above work just fine; however, if you find that you use a common anonymous type throughout different parts of your application, you may want to use an extension method – extension methods are also nice just because of their class-member-like syntax.

public static class ResultSetExtension
{
public static IEnumerable<SqlCeUpdatableRecord> Where(
this SqlCeResultSet resultSet, Func<SqlCeUpdatableRecord, bool> theFunc)
{
return new PrepAwareEnumerableWrapper(resultSet, theFunc);
}

public static object ShippingColumns(this SqlCeUpdatableRecord order)
{
if (_nameIndex == -1)
InitializeIndexes(order);

return new
{
ShipName = order.GetString(_nameIndex),
ShipAddress = order.GetString(_addressIndex),
ShipCity = order.GetString(_cityIndex),
ShipPostalCode = order.GetString(_postalCodeIndex),
ShipCountry = order.GetString(_countryIndex),
ShipVia = order.GetInt32(_viaIndex)
};
}

private void InitializeIndexes(SqlCeUpdatableRecord record) { ... }

With the extension method, the LINQ statement becomes…

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select order.ShippingColumns();

A couple of notes before I finish up…

One thing to keep in mind is that all of these functions that create the anonymous type have a return type of object. This means that the IEnumerable<T> collection that is created by the LINQ statement will be of type IEnumerable<object> rather than IEnumerable<compiler_generated_type>. In most cases this difference does not matter but it is something to be aware of.

And for a final note, if you do find yourself returning the same anonymous type construct from a number of LINQ statements, you might want to consider defining an explicit type and then constructing instances of that type within the LINQ statement. In my experience, anytime I find myself using an anonymous type/function/etc. more than once or twice that I ultimately end up needing access to it in my code in a non-anonymous fashion.

To return a specific type from a LINQ statement, simply define a type that has a constructor that accepts a SqlCeUpdatableRecord and assigns the desired columns to the corresponding type members – basically the constructor will look like the ShippingColumns methods shown above. Assuming that you've defined a class named ShipInfo with the appropriate constructor, your LINQ statement would look like the following…

var records = from order in resultSet
where (string)order["Ship Country"] == "UK"
select new ShipInfo(order);

I've updated one of the samples from the original webcast to include examples of what we've talked about in this post. If you'd like the updated sample, you can download it from here. The methods you'll want to look at in the download are menuRedefineType_Click, menuDynamicType_Click, menuDynamicTypeExtMethod_Click all of which are in the Form1.cs source file.

Randomizing rows in a DataTable

Fritz Onion — Wed, 16 Apr 2008 13:38:00 GMT

I've been working on a project recently where I had the need to randomly shuffle all of the rows in a DataTable. I wanted to do it with the DataTable itself instead of in the act of populating the DataTable for a couple of reasons: 1) I wanted to keep the DataTable in memory and shuffle it in place multiple times without going back to the source, and 2) I had multiple sources where data was coming from (SQL and XML) so I preferred to keep the randomization logic in one place. I also didn't want to copy all of the data (even though it was not a large amount) each time I shuffled, so I decided to use a DataView to display the data shuffled each time I needed it.

Here's the utility function I came up with - each time you call RandomizeDataTable it will return a newly shuffled DataView of all the data passed in through the DataTable. Note that because I reuse the added column "rndSortId" each time, any DataViews retrieved from previous calls to the method will have the new shuffle order. You could change this behavior by adding a new column each time with its own unique sort sequence.

As always, comments/improvements welcome – enjoy!

public static class DataSetUtilities

{

static Random _rand = new Random();

public static DataView RandomizeDataTable(DataTable dt)

{

// Create array of indices and populate with ordinal values

int[] indices = new int[dt.Rows.Count];

for (int i = 0; i < indices.Length; i++)

indices[i] = i;

// Knuth-Fisher-Yates shuffle indices randomly

for (int i = indices.Length - 1; i > 0; i--)

{

int n = _rand.Next(i + 1);

int tmp = indices[i];

indices[i] = indices[n];

indices[n] = tmp;

}

// Add new column to data table (if it's not there already)

// to store shuffle index

if (dt.Columns["rndSortId"] == null)

dt.Columns.Add(new DataColumn("rndSortId", typeof(int)));

int rndSortColIdx = dt.Columns["rndSortId"].Ordinal;

for (int i = 0; i < dt.Rows.Count; i++)

dt.Rows[i][rndSortColIdx] = indices[i];

DataView dv = new DataView(dt);

dv.Sort = "rndSortId";

return dv;

}

Password Minder 1.5.0.10 Released

Keith Brown — Sat, 12 Apr 2008 23:49:00 GMT

This is a minor update. Here's what was changed (from the readme file):

      Incorporated a patch from Richard Howells to give
      you the option to turn on/off the "Always On Top" behavior
      of the main form. I still recommend not keeping PWM in
      memory all the time - only run it when you need it to keep
      your master key safe. I also used adjusted the Auto-gen
      password dialog to be more reasonable: it now by default
      specifies a 12-char password, not the 20 it used to - most
      websites can't handle a password that long. I also removed
      the lower case 'l' and punctuation, with a button that allows
      you to add back in the puncutation marks if you want.
      One last minor thing - I added AcceptsReturn=true to the
      notes editor so it won't disappear when you press Enter :)

You can access the latest version from our tools page.

Applied BTS R2 in the Windy City

Matt Milner — Thu, 10 Apr 2008 22:00:00 GMT

I've been teaching mostly WF and WCF lately, so I'm excited that in a couple of weeks (April 22) I'll be getting a chance to teach our core BizTalk course again in the lovely city of Chicago. I'm excited because there is a lot of cool stuff for this particular open enrollment.

1) R2 - need I say more? I will. We will be using the latest bits to teach the core course from now on so you'll be learning BizTalk Server fundamentals using the latest and greatest version. This is still a class for developers new to BizTalk, so if you have taken this class, you might be interested in the R2 features class that Jon is teaching in May and August.

2) Dual Monitors! Our crack sales team has negotiated dual monitors from the hardware vendor so you'll be able to see the lab manual and Visual Studio each in full screen glory!

3) It's in downtown Chicago right on Wacker Drive near all sorts of cool stuff for the evenings.

4) It's BizTalk and we'll cover all the three letter acronyms (TLA) BRE, BAM, WCF,WSE,ASMX (ok that's four letters), CSV, HAT, PUB (actually a technical term, but maybe where we'll be in the evenings as well), SUB, EAI, ESB, SOA. I could go on, but you get the picture.

5) As if all the above are not enough, we have some seats available and the course is in a week and half, so the sales guys are "ready to deal". Actually, their just ready to cut you some discounts :) , especially if you sign up two or three people together, but even if you are just signing up one developer. Talk to our fabulous sales team to get more information or register with a discount. Just tell them you read about it on my blog.

Hope to see you there, and once I get back from the class, I promise some more technical content. I've been working on some demos and samples that I'll be posting over the next couple of months.