/bill's House O Insomnia : .NET 3.0 Framework

WF Persistence - Where [DataContract] != [Serializable]

William — Sat, 01 Nov 2008 07:27:07 GMT

Let's say you were using Workflow Foundation (WF) and Windows Communication Foundation (WCF). Assume you wanted to use WF's Persistence mechanism (which requires types to be Serializable). And assume that all the objects you were using in the workflow were decorated with the [DataContract] attribute. Would you expect any problems related to Serialization? (I can but to the chase really quickly here if you don't want my belabored background information and explanation. If you're creating a type to use w/ Workflow Foundation that will be saved via the Workflow Foundation Persistence Service which makes use of the SqlWorkflowPersistenceService class, marking the class as a [DataContract] alone will not work for WF's persistence mechanism. It does make the class serializable in a literal sense and will suffice [provided you meet the other requirements of a [DataContract] for WCF's serialization needs, but it is insufficient for WF (see the References section at the end of this post for more details on WF Serialization) - so make sure you use the Serializable attribute on any type that'll be consumed by the Persistence Service).

MSDN describes the DataContract class the following way:

Specifies that the type defines or implements a data contract and is serializable by a serializer, such as the DataContractSerializer. To make their type serializable, type authors must define a data contract for their type.

If you spend a lot of time in WCF, you'd likely assume that b/c types decorated with the DataContract attribute would satisfy any requirement for the type to be Serializable. But you'd likely be wrong. Yes, a type that is a [DataContract] is serializable in the literal sense, but it's serialized by the DataContractSerializer (see the References section at the end of this post for more details on WF Serialization)

So why is this an issue and what do you do about it? Often, non-trivial workflows span an amount of time that exceeds any given user's session. In fact, it's not uncommon for a non-trivial workflow to span as much as 30 days. Using a simple example, let's say that you are writing a Workflow to manage new employees. Further assume that there are several document requirements and that any deficiencies would result in severe penalties or liability risks. Just to make it clear, assume that each of the following must be procured before a new employee can start working. Further, assume that b/c of fees associated with each, if any previous one fails, that the whole process terminates (if someone's reference checks don't pass, there's no need to spend the money for a full background investigation as you know you're not going to hire them). [Also, this isn't a post on workplace hiring guidelines and is solely used for illustration - no need to point out why 'its bad business to drug test or whatever else].

Employment Application
Proof of Citizenship or ability to work in the U.S.
State withholding form
Federal withholding form
Reference check
License check
Completed Drug Screen
Full Background check

Implementation policies will vary from company to company but assume that all of these tasks wouldn't be completed within the user session that first created the entity. If you couldn't persist the workflow somehow and come back to it later, it would be of very little use. Workflow foundation provides an out-of-the-box solution named not surprisingly - Windows Workflow Persistence Service to help with long running workflows

Since Workflow Foundation is still in its infancy in terms of user adoption, many shops don't have well established design rules in place specifically for Workflow items. This can have some profound (although easily addressed in most cases) effects on Workflow development. It's common for a workflow to start out small in terms of steps and happen relatively quickly. When this is the case, there's little need for a persistence mechanism for the workflow. But as people get comfortable with WF and are willing to try more involved solutions, steps get added that often increase the time span the workflow could run to a point that's longer than the user session. For people new to WF, adding that first activity that'll possibly span a large amount of time is the first time they actually think seriously about the persistence service. And that's the point at which they often go back and try to retrofit things. In many cases, the number of "things" will be fairly substantial so it's quite easy to overlook something. Once you implement the persistence service, you'll typically go through the testing phase and make sure everything persist and can be retrieved correctly. And this is the time serialization problems with show themselves - often in a manner that's hard to isolate b/c the number of items involved.

In some cases, if there's a serialization problem, a fault will result. Unhandled faults in WF cause behavior that deviates from what you'd typically expect. So depending on your logging and tracing, you may or may not find the issue quickly. in many cases, you'll find the fault is related to serialization and you'll address it on the specific type, then go back and try to find every other type and make it serializable as well. This is likely to be overkill though - b/c you're likely to have some types that aren't involved in anything that's persisted and consequently don't require persistence. So you try to only make the items that will be persisted serializable. Until you get to the point where you're addressing everything in the planning and design stages, you're likely to run into situations like this and the only way out typically involves a lot of trial-and-error. That's why this post is relevant. If you go back and define each type that will be persisted as a [DataContract] , it'll take you some time to do, may necessitate you adding new references to some projects and ultimately, after all that's done, won't fix the problem. The following type may work all day long when just dealing with WCF's serialization requirements...

namespace Ger911.HCStandard.Core.Shared
{
    [DataContract]
    public class MatrixItem
    {
        [DataMember]
        public String EntityName { get; set; }
        [DataMember]
        public String ContactName { get; set; }
        [DataMember]
        public Int32 BedCount { get; set; }
        [DataMember]
        public String HospitalStatus { get; set; }
        [DataMember]
        public DateTime ModifiedDateTime { get; set; }
    }
}

But unless you modify it like this, you'll be in for some unpleasant surprises in WF:

namespace Ger911.HCStandard.Core.Shared
{

    [Serializable]
    [DataContract]
    public class MatrixItem
    {
        [DataMember]
        public String EntityName { get; set; }
        [DataMember]
        public String ContactName { get; set; }
        [DataMember]
        public Int32 BedCount { get; set; }
        [DataMember]
        public String HospitalStatus { get; set; }
        [DataMember]
        public DateTime ModifiedDateTime { get; set; }
    }
}

References:

Using Red Gate's Reflector, here's what you'll see under the hood of the WorkflowPesistenceService class's RestoreFromDefaultSerializedForm and GetDefaultSerializedForm. For further insight into this, use Reflector and examine the SqlWorkflowPersistenceService:

RestoreFromDefaultSerializedForm

protected static Activity RestoreFromDefaultSerializedForm(byte[] activityBytes, Activity outerActivity)
{
            Activity activity;
            DateTime now = DateTime.Now;
            MemoryStream stream = new MemoryStream(activityBytes);
            stream.Position = 0L;
            using (GZipStream stream2 = new GZipStream(stream, CompressionMode.Decompress, true))
            {
                activity = Activity.Load(stream2, outerActivity);
            }
            TimeSpan span = (TimeSpan)(DateTime.Now - now);
            WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Deserialized a {0} to length {1}. Took {2}.",
                new object[] { activity, stream.Length, span }); return activity;
}

GetDefaultSerializedForm

protected static byte[] GetDefaultSerializedForm(Activity activity)
{
          DateTime now = DateTime.Now;
          using (MemoryStream stream = new MemoryStream(0x2800))
          {
              stream.Position = 0L;
              activity.Save(stream);
              using (MemoryStream stream2 = new MemoryStream((int)stream.Length))
              {
                  using (GZipStream stream3 = new GZipStream(stream2, CompressionMode.Compress, true))
                  {
                      stream3.Write(stream.GetBuffer(), 0, (int)stream.Length);
                  }
                  ActivityExecutionContextInfo info = (ActivityExecutionContextInfo)activity.GetValue(Activity.ActivityExecutionContextInfoProperty);
                  TimeSpan span = (TimeSpan)(DateTime.Now - now);
                  WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0, "Serialized a {0} with id {1} to length {2}. Took {3}.", new object[] { info, info.ContextGuid, stream2.Length, span });
                  byte[] array = stream2.GetBuffer();
                  Array.Resize<byte>(ref array, Convert.ToInt32(stream2.Length));
                  return array;
              }
          }
}

DataContractSerializer

public sealed class DataContractSerializer : XmlObjectSerializer
{
    // Fields
    private IDataContractSurrogate dataContractSurrogate;
    private bool ignoreExtensionDataObject;
    internal Dictionary<XmlQualifiedName, DataContract> knownDataContracts;
    private ReadOnlyCollection<Type> knownTypeCollection;
    internal IList<Type> knownTypeList;
    private int maxItemsInObjectGraph;
    private bool needsContractNsAtRoot;
    private bool preserveObjectReferences;
    private DataContract rootContract;
    private XmlDictionaryString rootName;
    private XmlDictionaryString rootNamespace;
    private Type rootType;

    // Methods
    public DataContractSerializer(Type type);
    public DataContractSerializer(Type type, IEnumerable<Type> knownTypes);
    public DataContractSerializer(Type type, string rootName, string rootNamespace);
    public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace);
    public DataContractSerializer(Type type, string rootName, string rootNamespace, IEnumerable<Type> knownTypes);
    public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes);
    public DataContractSerializer(Type type, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    public DataContractSerializer(Type type, string rootName, string rootNamespace, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    public DataContractSerializer(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    internal static DataContract GetDataContract(DataContract declaredTypeContract, Type declaredType, Type objectType);
    internal override Type GetDeserializeType();
    internal override Type GetSerializeType(object graph);
    internal static Type GetSurrogatedType(IDataContractSurrogate dataContractSurrogate, Type type);
    private void Initialize(Type type, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    private void Initialize(Type type, XmlDictionaryString rootName, XmlDictionaryString rootNamespace, IEnumerable<Type> knownTypes, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences, IDataContractSurrogate dataContractSurrogate);
    internal override bool InternalIsStartObject(XmlReaderDelegator reader);
    internal override object InternalReadObject(XmlReaderDelegator xmlReader, bool verifyObjectName);
    internal override void InternalWriteEndObject(XmlWriterDelegator writer);
    internal override void InternalWriteObject(XmlWriterDelegator writer, object graph);
    internal override void InternalWriteObjectContent(XmlWriterDelegator writer, object graph);
    internal override void InternalWriteStartObject(XmlWriterDelegator writer, object graph);
    public override bool IsStartObject(XmlDictionaryReader reader);
    public override bool IsStartObject(XmlReader reader);
    public override object ReadObject(XmlReader reader);
    public override object ReadObject(XmlDictionaryReader reader, bool verifyObjectName);
    public override object ReadObject(XmlReader reader, bool verifyObjectName);
    internal static object SurrogateToDataContractType(IDataContractSurrogate dataContractSurrogate, object oldObj, Type surrogatedDeclaredType, ref Type objType);
    public override void WriteEndObject(XmlDictionaryWriter writer);
    public override void WriteEndObject(XmlWriter writer);
    public override void WriteObject(XmlWriter writer, object graph);
    public override void WriteObjectContent(XmlDictionaryWriter writer, object graph);
    public override void WriteObjectContent(XmlWriter writer, object graph);
    public override void WriteStartObject(XmlDictionaryWriter writer, object graph);
    public override void WriteStartObject(XmlWriter writer, object graph);

    // Properties
    public IDataContractSurrogate DataContractSurrogate { get; }
    public bool IgnoreExtensionDataObject { get; }
    internal Dictionary<XmlQualifiedName, DataContract> KnownDataContracts { get; }
    public ReadOnlyCollection<Type> KnownTypes { get; }
    public int MaxItemsInObjectGraph { get; }
    public bool PreserveObjectReferences { get; }
    private DataContract RootContract { get; }
}

Looking for some .NET Developers

William — Sat, 07 Jun 2008 02:19:26 GMT

A client of mine located in the Aiken/Columbia South Carolina Area has asked me if I had any friends who are .NET Developers and looking for a job. They are looking for at least one Junior Developer, on Mid-Level Developer and several Senior developers. I know these folks quite well and I can vouch for the following:

They pay extremely well
Generous benefits package
There's plenty of cool people on their staff
They are growing at an explosive rate so there's plenty of room for upward mobility. There's also a very strong focus on learning/teaching and career development.
They are an Agile/SCRUM shop
Currently developing with the following technologies:

Visual Studio Team System 2008 / .NET 3.5 Framework
Windows Communication Foundation
Windows Presentation Foundation
ASP.NET
LINQ
Silverlight
Windows Mobile 5/ Windows Mobile 6/ .NET Compact Framework
Sql Server 2005 / Sql Server 2008
Windows Installer for XML
Sandcastle

If you're in the area and looking for a job... if you know someone who looking for a job.... or if you're willing to move, please drop me a line using the Contact option on my blog or emailing me directly at WilliamRyan@gmail.com and I'll put you in contact with them. They are looking to hire folks immediately so I can probably get you an interview within a few days.

Junior Developer:

Ideal candidate will be a recent college graduate with a Computer Science of MIS degree. No experience is necessary for this position. The main soft-skill qualifications for this position are:

A true love for development
Strong desire to learn
A desire to stand out among one's peers

The hard-skill qualifications include a good theoretical understanding of at least two of the following:

Object Oriented Design and Analysis
Relational Database theory
Design Patterns
Familiarity with at least two of the following: C, C++, Java, C#, VB.NET

This is essentially a dream job for recent college grads b/c the job is being offered "no experience required". Since they are a SCRUM/Agile shop, you'll get to work extensively with their Senior and Mid level devs via Pair Programming. You'll be able to pick an area to specialize in which you will decide on for yourself. Additionally, you'll be using some of the most sought after Microsoft technologies available. Go to Monster.com or Dice.com and see for yourself how much demand there is for the above technologies and how much those jobs pay. You'll get to work with these on day 1 and essentially carve out a path for yourself using whichever technologies you like the best. If you want to be a "UI" expert, that's where you'll be put. If you want to be a Web Services dev, again, that's what you can focus on. If you want to be an expert buildmaster who specializes in installers, that's what you'll get to do. The company is looking for some excellent candidates and willing to offer a really fun and great paying job with plenty of training and career development available.

Mid-Level Developer:

The ideal candidate will have a computer science or MIS degree and 1-3 years of development experience. The ideal candidate will have two or more the following abilities:

Solid command of OOP/OOD using C++, C#, Java or VB.NET
Test Driven Design
Service Oriented Architecture
Familiarity with MySql, Sql Server (T-SQL), Oracle (PL/SQL)
Basic understanding of both Winforms and ASP.NET
Basic familiarity with Web Services, MSMQ, Enterprise Services/COM+, .NET Remoting, DCOM, J2EE, Java Beans

Just like the Junior development positions, these ones will provide a great deal of flexibility to learn and specialize the area of your choice. These are considered 'fast track' positions to move into the Senior Developer or Architect roles

Senior Developer:

The ideal candidate will be someone with at least 4 years experience. This person will love challenges and love coming up with solutions to problems that other people run from. They will be people that love figuring out how to do things that everyone else said can't be done. They will be the stereotypical Alpha-Geek, Someone that spends their spare time answering quiz questions like these:

All of the requirements for the Mid-Level Developer as well as several of the following skills:

Proficiency with T-Sql or PL/SQL. You should be able to write a 5 table join on your own. You should have written several stored procedures that were > 100 lines long.
Strong command of query tuning and ability to easily spot design flaws
Ability to design 'real' objects.

Someone who pays meticulous attention to the scope modifiers of their classes/functions/properties
Someone who understands the problems associated with coupling and strives to avoid it.
Someone who can write and use events in their classes without thinking twice about it.
Someone with a solid understanding of thread safety and thread synchronization
Someone who is comfortable using several different design patterns
Someone who is comfortable implementing several different interfaces in one object, using combinations of interface implementation and inheritance and someone who can use inheritance responsibly

Keeps up with technology, reads computer books regularly, has favorite blogs in multiple disciplines and/or blogs themselves, attends or speaks at user's groups, is active in one or more online forum or newsgroup
Someone who answers "Which is better, C# or VB.NET?" with "Either can be better depending on the circumstances but I'm comfortable writing in either of them" and then "But I've been learning F# lately and it's really been growing on me"
Experience with .NET Remoting, Web Services & Web Services Enhancements, MSMQ, Enterprise Services and/or WCF
Ability to create syntactically correct UML diagrams (meaning they can do more than write the letters "UML" on their resume) and if not, they are willing to learn to do this.
Understands data structures solidly and could easily implement their own HashTable or LinkedList
Someone who's always looking to come up with a newer, cooler, faster, and more secure way to do implement something
Experienced with either Biztalk server or Sharepoint
Takes pride in their code without falling in love with it or getting all defensive about it. Ability to acknowledge the fact that everyone makes mistakes and can talk about their mistakes/bugs without getting defensive.
Someone who is the first to raise their hand whenever the boss says "I need someone to learn ____________, do I have any volunteers"

Basically, if you love development, love creating new cutting edge solutions all the while making a lot of money and having a lot of fun you definitely should talk to these folks. If you're interested...... Please drop me a line using the Contact option on my blog or emailing me directly at WilliamRyan@gmail.com and I'll put you in contact with them.

Filtering data ADO.NET Synchronization Services

William — Wed, 14 Nov 2007 02:20:57 GMT

If you dabble in Orcas or are a data aficionado, then you have probably at least heard of Synchronization Services. If you haven't heard of it, let me try to pique your interest.

The business case for Sync Services is simple. You have data in one place and you want to sync it with Data in another place. This is an old school problem that has been dealt with many times before by many different people. That should clue you in to the realization that such problems should probably be approached using design patterns and Data Oriented Design Patterns in particular. My memory is a little foggy but I don't specifically remember reading any 'data movement patterns' in the seminal design pattern book, Design Patterns: Elements of Reusable Object-Oriented Software by the Gang of Four. (As a slight digression, I've found quite a few superb design pattern books and a few stinkers. The GOF book is by far the best one I've come across in terms of being understandable and easy to follow and can say with comfort that it won't disappoint).

So you can roll your own code, you can use an existing mechanism like Replication, or you can go new school and try SS. I don't claim to be an expert at SS but so far, I've found it shocking easily to use and learn. Of all the zillions of new MS products rolling out of Microsoft, SS is one of the easiest I've come across, at least in terms of getting up and running.

Now, chances are that if you have the need to sync data back and forth (for instance, moving data from a database server to your salesforce's Tablet PC's), you will have a lot more data on your server than you'd need or be able to use on the remote machine. Even if you wanted all of that data, in many cases you won't be able to get it all b/c moving it would take forever and the target machine is resource constrained. To that end, the out of the box demo code that ships with SS will need some modification.

The first point I'd make is that Yes, it is possible to sync only portions of the data. This came up recently in one of the newsgroups I frequent and it's an excellent question. Just to get a conceptual feel for this, think of the same scenario I mentioned earlier. You have a db server and a mobile salesforce (or nursing force, or delivery force, or you're a large law firm, consulting group, accounting practice...you get the idea) and you only need to sync each target machine with a subset of data. In an ideal world remote users could see everything that users at the home base could, but moving the data could take forever in many large companies. Moreover, you probably wouldn't need most of it. If you're a nurse that makes house calls, you probably wouldn't need information for people that have passed on, or that have moved or even that you're not visiting. If your device was a PDA, you need to economize on every resource possible. But even if you had a laptop or tablet you still have some resource limits. Hence, envision a case where you might just want to sync only the data related to each person's active clients (and probably augment the query's restriction with a date filter of some sort and perhaps an active account indicator) that have engaged in at least one transaction in the last year.

You could give each person some sort of UI tool which they could initiate that queries the db and writes the data to a file, which they in turn copy over to their machine.
You could do the same thing, but run it as a job so it's done automatically
You could expose the query results as a web service and let them retrieve data as they needed it
You could export the data to Excel or Access (the latter of which I've seen done more times than I care to remember)

Each of these approaches is easy enough to implement but has major suckiness associated with it. The first approach is one of the simpler ones and fairly fool-proof. Writing out the file is something you could automate via a schedule but not copying it to the device, unless of course you were positive the device would always be available when the job ran. With the web service, you're depending on internet connectivity which, even in this day where everyone has mobile broadband, there are still a lot of coverage holes. If you had any sort of substantial dataset, pulling it down over a mobile broadband connection would be a doubleplusbad. Copying it to Access or Excel would have the same issues and shortcomings that the first approach, after all it really is the same approach but simply uses a different file format.

Referring to the SyncServices_CSharp_DownloadOnly sample included in the Sync Services install, refer to the SampleServerSyncProvider method of the SampleServerSyncProvider.cs or SampleServerSyncProvider.vb file, you see the following code (the Author was kind enough to include copious comments which explain each portion - I've removed them for readability but would encourage you to refer to them if you're unfamiliar with Sync Service):

public class SampleServerSyncProvider : DbServerSyncProvider
{

     public SampleServerSyncProvider()
      {

        this.Connection = new SqlConnection(Properties.Settings.Default.ServerConnString);

string awNewAnchorVariable = "@" + SyncSession.SyncNewReceivedAnchor;
SqlCommand selectNewAnchorCommand = new SqlCommand();
selectNewAnchorCommand.CommandText = "SELECT " + awNewAnchorVariable + " = @@DBTS";
selectNewAnchorCommand.Parameters.Add(awNewAnchorVariable, SqlDbType.Timestamp);
selectNewAnchorCommand.Parameters[awNewAnchorVariable].Size = 8;
selectNewAnchorCommand.Parameters[awNewAnchorVariable].Direction = ParameterDirection.Output;
selectNewAnchorCommand.Connection = (SqlConnection)this.Connection;
this.SelectNewAnchorCommand = selectNewAnchorCommand;

SqlSyncAdapterBuilder builder = new SqlSyncAdapterBuilder((SqlConnection)this.Connection);

builder.TableName = "Sales.Customer";
builder.TombstoneTableName = builder.TableName + "_Tombstone";
builder.TombstoneFilterClause = filterCommand;

builder.DataColumns.Add("CustomerId");
builder.DataColumns.Add("CustomerName");
builder.DataColumns.Add("SalesPerson");

builder.CreationTrackingColumn = "InsertTimestamp";
builder.UpdateTrackingColumn = "UpdateTimestamp";
builder.DeletionTrackingColumn = "DeleteTimestamp";

SyncAdapter customerSyncAdapter = builder.ToSyncAdapter();
customerSyncAdapter.TableName = "Customer";
this.SyncAdapters.Add(customerSyncAdapter);
}

}

[Note: Even with the comments, some of this code may be hard to follow when you first read it. One thing I did which was very enlightening and always a useful thing to do in such situations is fire up good ole' Sql Profiler, then run the application and see exactly what happens, what objects are being used and what commands are being sent to the db].

I show some of the relevant results from the trace below (I've color coded the results to the portion of the code that which caused it to happen):

declare @p3 binary(8)
set @p3=0x0000000000000FA0
exec sp_executesql N'SELECT @sync_new_received_anchor = @@DBTS',N'@sync_new_received_anchor timestamp
output',@sync_new_received_anchor=@p3 output
select @p3

exec sp_executesql N'SELECT [CustomerId], [CustomerName], [SalesPerson] FROM Sales.Customer WHERE
(InsertTimestamp > @sync_last_received_anchor AND InsertTimestamp <=
@sync_new_received_anchor)',N'@sync_last_received_anchor binary(8000),@sync_new_received_anchor
binary(8)',@sync_last_received_anchor=0x00,@sync_new_received_anchor=0x0000000000000FA0

exec sp_executesql N'SELECT [CustomerId], [CustomerName], [SalesPerson] FROM Sales.Customer WHERE
(CustomerName=''Sharp Bikes'') AND (UpdateTimestamp > @sync_last_received_anchor AND UpdateTimestamp <=
@sync_new_received_anchor AND InsertTimestamp <= @sync_last_received_anchor)',N'@sync_last_received_anchor
timestamp,@sync_new_received_anchor
timestamp',@sync_last_received_anchor=0x0000000000000000,@sync_new_received_anchor=0x0000000000000FA0

exec sp_executesql N'SELECT [CustomerId], [CustomerName], [SalesPerson], [CustomerType], [DeleteId],
[DeleteTimestamp] FROM Sales.Customer_Tombstone WHERE (CustomerName=''Sharp Bikes'') AND (@sync_initialized = 1
AND DeleteTimestamp > @sync_last_received_anchor AND DeleteTimestamp <=
@sync_new_received_anchor)',N'@sync_initialized bit,@sync_last_received_anchor
timestamp,@sync_new_received_anchor
timestamp',@sync_initialized=0,@sync_last_received_anchor=NULL,@sync_new_received_anchor=0x0000000000000FA0

As it stands, the code above is pulling everything from the Sales.Customer table. But as I mentioned, chances are that you wouldn't want the whole resultset. Rather, you'd probably want a filtered subset. For the sake of visual simplicity, I'm going to violate one of my biggest coding Pet Peeves and concatenate a sql statement to include a parameter instead of doing it the right way, but I'll show the correct way shortly.

The SqlSyncAdapterBuilder has several properties and for filtering purposes, you can simply set the FilterClause property. Starting with the code beginning at the adapter instantiation, I modified the code to just return records that have a CustomerName value equal to the literal 'Sharp Bikes' (The relevant portions are included in Bold face):

SqlSyncAdapterBuilder builder = new SqlSyncAdapterBuilder((SqlConnection)this.Connection);

String FilterCommand = "CustomerName='Sharp Bikes'";

builder.TableName = "Sales.Customer";
builder.TombstoneTableName = builder.TableName + "_Tombstone";
builder.FilterClause = FilterCommand ;
builder.TombstoneFilterClause = FilterCommand;

builder.SyncDirection = SyncDirection.DownloadOnly;

So, it's pretty much this easy, you simply need to set the FilterClause property of the SqlSyncAdapterBuilder and absent some really compelling reason to do so, set the TombStoneFilterClause to the same value. Because you use the same statement, it's best to use a String literal so that the two FilterClause values don't get out of sync. Just as you set the FilterClause and TombstoneFilterClause properties to facilitate filtering, if you use a parameter, you need to add a SqlParameter (or SqlParameter(s)) to the FilterParameters and TombstoneFilterParameters collections. So, the below code shows the previous snippet modified to use a SqlParameter instead of concatenating the Sql text, again, the relevant portions are included in Bold face:

SqlSyncAdapterBuilder builder = new SqlSyncAdapterBuilder((SqlConnection)this.Connection);
SqlParameter CustomerNameParameter = new SqlParameter("@CustomerName", SqlDbType.NVarChar);

String FilterCommand = "CustomerName=@CustomerName";

builder.TableName = "Sales.Customer";
builder.TombstoneTableName = builder.TableName + "_Tombstone";
builder.FilterClause = FilterCommand ;
builder.TombstoneFilterClause = FilterCommand;
builder.FilterParameters.Add(CustomerNameParameter);
builder.TombstoneFilterParameters.Add(CustomerNameParameter);

Now the results from Profiler show something notably different:

exec sp_executesql N'SELECT [CustomerId], [CustomerName], [SalesPerson] FROM Sales.Customer WHERE
(CustomerName=@CustomerName) AND (InsertTimestamp > @sync_last_received_anchor AND InsertTimestamp <=
@sync_new_received_anchor)',N'@CustomerName nvarchar(11),@sync_last_received_anchor
binary(8000),@sync_new_received_anchor binary(8)',@CustomerName=N'Sharp
Bikes',@sync_last_received_anchor=0x00,@sync_new_received_anchor=0x0000000000000FA0

exec sp_executesql N'SELECT [CustomerId], [CustomerName], [SalesPerson] FROM Sales.Customer WHERE
(CustomerName=@CustomerName) AND (UpdateTimestamp > @sync_last_received_anchor AND UpdateTimestamp <=
@sync_new_received_anchor AND InsertTimestamp <= @sync_last_received_anchor)',N'@CustomerName
nvarchar(11),@sync_last_received_anchor timestamp,@sync_new_received_anchor timestamp',@CustomerName=N'Sharp
Bikes',@sync_last_received_anchor=0x0000000000000000,@sync_new_received_anchor=0x0000000000000FA0

exec sp_executesql N'SELECT [CustomerId], [CustomerName], [SalesPerson], [CustomerType], [DeleteId],
[DeleteTimestamp] FROM Sales.Customer_Tombstone WHERE (CustomerName=@CustomerName) AND (@sync_initialized = 1
AND DeleteTimestamp > @sync_last_received_anchor AND DeleteTimestamp <=
@sync_new_received_anchor)',N'@CustomerName nvarchar(11),@sync_initialized bit,@sync_last_received_anchor
timestamp,@sync_new_received_anchor timestamp',@CustomerName=N'Sharp
Bikes',@sync_initialized=0,@sync_last_received_anchor=NULL,@sync_new_received_anchor=0x0000000000000FA0

You can see here clearly that not only is the @CustomerName parameter being used, it's being set to the literal Sharp Bikes

There's one catch though when using real parameters. If you modify the code as I did above and try to run it, you'll encounter the following exception:

Microsoft.Synchronization.Data.SessionVariableException was unhandled
Message="Unable to set session parameters in DbServerSyncProvider. Cannot obtain the value for command parameter '@CustomerName'."
Source="Microsoft.Synchronization.Data.Server"
SyncSource="ServerSyncProvider"
StackTrace:
       at Microsoft.Synchronization.Data.Server.DbServerSyncProvider.SetSessionParameters(IDbCommand cmd, SyncGroupMetadata groupMetadata, SyncTableMetadata tableMetadata, SyncSession syncSession, DataColumnCollection columns, SyncStage stage)
       at Microsoft.Synchronization.Data.Server.DbServerSyncProvider.EnumerateChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession, IDbTransaction transaction, EnumerateChangeType changeType)
       at Microsoft.Synchronization.Data.Server.DbServerSyncProvider.GetChanges(SyncGroupMetadata groupMetadata, SyncSession syncSession)
       at Microsoft.Synchronization.SyncAgent.DownloadChanges(SyncGroupMetadata groupMetadata)
       at Microsoft.Synchronization.SyncAgent.Synchronize()
       at Microsoft.Samples.Synchronization.MainForm.btnSynchronize_Click(Object sender, EventArgs e) in C:\SyncServicesCode\SyncServices_CSharp_DownloadOnly\Client\Forms\MainForm.cs:...

Nothing too shocking though right, after all, although we specified a parameter be used in the CommandText property, we never set the value so it's not surprising that an exception was thrown unless the parameter had a default value, which in this case it clearly did not.

But if you change the code to explicitly set the value for the parameter, for instance like this...

SqlParameter CustomerNameParameter = new SqlParameter("@CustomerName", SqlDbType.NVarChar);
CustomerNameParameter.Value = "Sharp Bikes";

you'll still get the same exception. This really threw me for a loop b/c I used the debugger and proved to myself that the value wasn't null or left out. If you step through with the debugger, you can verify for yourself that the above code is in fact setting the value of @CustomerName = "Sharp Bikes"

One point that's extremely important... Normally, as long as you modify your CommandText to refer to the SqlParameter and add a SqlParameter object to a SqlCommand object's Parameters collection, you don't need to do anything else. But as I just babbled on about, that won't cut it here... something is still missing.

As it turns out, (and makes perfect sense once I cleared my tunnel vision), the SyncAgent (Microsoft.Synchronization.SyncAgent) class is what actually does much of the heavy lifting and just because you have a Parameter referenced in code in your SqlSyncAdapterBuilder, the SyncAgent doesn't know anything about it. Since it doesn't know anything about it, it doesn't know to pass in a value or what value to pass to it, so when it tries to finish processing the value for the parameter isn't set. It didn't matter that we set it explicitly because we set it in the wrong place.

Fortunately, it's very easy to address. The code below is the SyncAgent's code, the last line in Bold is what you need to add if you're using a parameterized filter:

public class SampleSyncAgent : Microsoft.Synchronization.SyncAgent
{

     public SampleSyncAgent()
     {

         SqlCeClientSyncProvider clientSyncProvider = new SqlCeClientSyncProvider(Properties.Settings.Default.ClientConnString, true);
         this.LocalProvider = clientSyncProvider;
              clientSyncProvider.ChangesApplied += new EventHandler<ChangesAppliedEventArgs>(clientSyncProvider_ChangesApplied);

this.RemoteProvider = new SampleServerSyncProvider();

         SyncTable customerSyncTable = new SyncTable("Customer");
         customerSyncTable.CreationOption = TableCreationOption.DropExistingOrCreateNewTable;
         customerSyncTable.SyncDirection = SyncDirection.DownloadOnly;

         this.Configuration.SyncTables.Add(customerSyncTable);
         this.Configuration.SyncParameters.Add(
           new SyncParameter("@CustomerName", "Sharp Bikes"));
     }

}

(Part of this class was left out for brevity - all that is missing is the private variables and their corresponding public properties).

The corresponding code is available Here. Please note that this code is taken from the Synchronization Services samples that are included when you install Synchronization Services. I merely modified that code to support parameterized filters. I will be adding a UI Element on the MainForm object so that you can set the value dynamically instead of hard coding it as I did. Again, although this post is a little long, we really are talking about basically adding less than 10 lines of code to add filtering. You need to set the FilterClause, the TombstoneFilterClause, FilterParameters, TombstoneFilterParameters and then add a SyncParameter to the SyncAgent. As you can infer, you if you need more expressions, you can just add them accordingly to meet whatever your requirements happen to be.

Free Silverlight Training

William — Tue, 14 Aug 2007 19:53:43 GMT

My friend Brian Madsen who owns CSharpZealot has teamed up with InnerWorkings to extend a really slick offer for Free Silverlight Training for CSharpZealot members.

In addition, Shawn Wildermuth has been way ahead of the crowd when it comes to Silverlight and has just created two more Silverlight Videos. His ADO Guy site has an entire Section dedicated to Silverlight and well, Shawn is gifted in many areas but when it comes to teaching, no one does it better.

On a similar note, my company recently sponsored an internal Silverlight contest where our different offices are competing to build the best game written in Silverlight. They put there money where their mouth is so the first place prize is pretty impressive. I've had my nose in the keyboard for the past few weeks trying to help my team win. If you're interested in learning Silverlight, one great place to get started is Here. Microsoft really did the right thing with Orcas (VS 2008) and even provides ready to run (almost anyway) VPC images.

Hopefully when I get some time I can start doing some more in depth Silverlight blogging but let me make a few recommendations.

Use the VPC images for Orcas. The reasons are the same for any other alpha or beta product you'd want to install but outside of isolation and reducing risk, the time factor is huge. Using the VPC images, you can be up and running in under 5 minutes once you have them downloaded. Benefits like this are really hard to quantify but I can tell you personally that at times, getting my environment set up without VPC images was frustrating to say the least.
Although it's often prudent to learn to code things without all the crutches that a powerful IDE provide, creating Silverlight with Intellisense and a designer is probably not a very effective way to start things. Unless you are really familiar with WPF already, the syntax takes a little getting used to and there's a lot of room to mess things up with typos.
In addition to Orcas, make sure you pull down Expression Blend and Design. Blend allows you to create Graphics with XAML. I've already had a few Paint.NET and Photoshop fanatics get all over me for plugging Blend, but I think they are off base. I'm not advocating replacing Photoshop or Paint.NET with Blend. Blend however, allows one to create images with XAML. You in turn can look at the XAML that is generated and use it to help understand and learn XAML. If you did much Office automation, you more than likely 'cheated' in the sense that you just ran a macro and saw the code that was generated and used this as a mechanism to learn VBA and get past sticking points. Blend allows you to do the same thing. Sure, hardcore 'real' developers do everything in Notepad but if you want to get up to speed, using a tool to help you draw the effects you want and then being able to disassemble the XAML that was generated will get you where you want to be a LOT faster.
Pull down each of the items in the Gallery and work through the QuickStarts. These encompass many common kick a55 effects and you can reverse engineer them to see learn how to do quite a bit.
I have some pretty strong opinions on the books out there but even if a book doesn't address Silverlight specifically (most of them however have updated versions which do include Silverlight), you can still learn quite a bit because you are ultimately going to need to really understand WPF and XAML. I really want to gather my thoughts a little better before making any more book recommendations because although all of the WPF books out there are pretty good, some are a lot more helpful than others when it comes to learning Silverlight
Read Shawn Wildermuth's Silverlight posts.

Personally, since I'm not a designer and very challenged when it comes to graphics, I had a pretty rough time at the beginning of my learning curve. Little by little though, I'm getting through it and hopefully I'll have some blogworthy material to post soon. As always, if you have any specific questions, please let me know and I'll be glad to answer what I can.

Pro WCF: Practical Microsoft SOA Implementation

William — Sun, 18 Feb 2007 23:41:00 GMT

I went on a book binge this week and have had my nose buried in WCF all week. There's a lot of really good stuff out there, but without a doubt, Pro WCF: Practical Microsoft SOA Implementation by Chris Peiris is probably my favorite.

Overall, the book is just over 400 pages but the author says quite a bit in those 400 pages. The coolest part is that they go over just about every topic that the MSDN Documentation is short on. I found that a lot of things that I stumbled my way through were covered there as well.

I can't find the link, but a while ago, KC had a post where his server program uploaded itself his web server and ran itself. His comment was something to the effect about "What did the first Blacksmith use". I was always really impressed with that program. And not just b/c of the lower cased one's coding skill. The idea itself was really cool. So when WSE 3.0 came out and MTOM was implemented, I tried to bite his style and accomplish the same thing with MTOM. It's an easy port so it didn't take much skill on my part.

Anyway, I've been trying to figure out how to port most of the WSE 3.0 code from my 70-529 book over to WCF. I've been able to do most of it, however it's been frustrating at times. I'm make a lot of typos and copy/paste errors and neither play well with .config files. After wasting about 3 hours trying to get the MTOM port to work, I read through this book and Viola'. I was kinda mad at myself for overcomplicating things that much. So I guess I really like the book in large part b/c I've had quite a few similar experiences with it.

My favorite chapters are discussed below:

Chapter 4 - It discusses installation and configuration. This is the single most frustrating area when learning WCF. Writing code instead of using .config files is lame so I try to avoid it. But getting some help in avoiding common mistakes is priceless..

Chatper 6 discusses managing WCF Services. Not a glamorous subject but being able to monitor and troubleshoot your programs is critical. Moreover, when you're first learning how to do things, it's easy to ignore performance. It's easy to overlook things that can kill performance. After reading this chapter, I am in a lot better shape to find problems

Chaper 7 discusses security. Obviously a pretty big issue when you're building services. Just for good measure there's some CardSpace stuff at the end which was a nice touch.

Chapter 9 discusses transactions. For obvious reasons, this is a subject you need to learn well and although I thought I was pretty familiar with them, I learned more than a few things from this chapter.

-------------------

All in all, this book was pretty impressive. They do mostly real world stuff and while they certainly talk theory, they stick to stuff that you'll encounter in your day to day development. You can only take so much theory and I've found that the documentation on MSDN is really heavy on theory and not enough implementation. This book will bridge that gap. Scott Klein's WCF book will help quite a bit too but won't be out for another month or two.

I also picked up John Sharp's Microsoft Windows Communication Foundation Step by Step. So far, my impressions are quite favorable although I haven't went through it in quite the detail I did with this one. I worked through each of the examples and found them pretty cool. Should have a review of it up shortly.

Is my Windows Communication Foundaton Service configured correctly?

William — Sat, 27 Jan 2007 23:55:00 GMT

One of the really sucky things about doing presentations is that you have to learn what you're talking about first. Actually, there's nothing sucky about learning things, it's just that at until you hit your learning curve, it can be frustrating. It's after that point though that things become sucky. Why? Because all too often you start going "Wow, is this cool, I wonder if I can_____________" and then you give it a try. Some stuff works on the first pass, some stuff doesn't. Then you start debugging and searching around, figure out how to make it work and you in my case, it usually takes something like the dog pooping on the floor to make me realize how long I've been zoned out on the computer.

If you're familiar with Windows Communication Foundation (WCF) then you realize that it's so configurable its almost hard to fathom (I really woulnd't be surprised if the next version negates the need for code altogether and you simply flip around config file settings to do what you want). Configuration is as cool as hard coding stuff is lame, but one problem with it is that it's fussy. If you screw something up in a XAML file (which is similar in form to config files) for instance, the compiler jumps in and lends you a hand telling you rather precisely what you did wrong. If you screw something up in a configuration file for WCF, you get the same behavior you did with .NET Remoting (for the uninitiated, that means it just sits there and laughs at you as you try to figure out which word you incorrectly spelled).

So I'm trudging through a bunch of samples I was thinking about and then realized most of what I've done entails hosting the service in a Console application. Time to take off the training wheels and host it in IIS right? I ask myself "Hell, how hard can that be?"

I created my virtual director and started copying stuff over. Carefully, I changed my configuration file settings. Just to be safe I left out all the fancy stuff I was doing with CustomBindings and just left in the simple stuff. "This should be a breeze" I'm thinking the whole time. So far so good. Normally, as I progress along each step of the way I test that part to make sure I got it right up until then, just so it's easier to isolate problems down the road should they arise. My ego got ahead of my brain and off I went.

<configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0"> <system.serviceModel> <services> <service name="MarkBrownService" behaviorConfiguration="returnFaults"> <endpoint contract="IKnightEmailHelper " binding="wsHttpBinding"/> </service> <service name="BlueCuckooService" behaviorConfiguration="returnFaults"> <endpoint contract="IPeck " binding="wsHttpBinding"/> </service> <service name="SausageDogService" behaviorConfiguration="returnFaults"> <endpoint contract="ITakeADump " binding="wsHttpBinding"/> </service> <service name="DigitalStripperService" behaviorConfiguration="returnFaults"> <endpoint contract="IStrip " binding="wsHttpBinding"/> </service>

Now, the first of these is really lame but the other three do quite a bit of stuff. I do a second glance to make sure everything looks ok and it does. I hand coded the client classes and was pretty sure they were good. So I fire everyting up and I see this:

The contract name 'IPeck ' could not be found in the list of contracts implemented by the service 'BlueCuckooService'.

The contract name 'ITakeADump ' could not be found in the list of contracts implemented by the service 'SausageDogService'.

The contract name 'IStrip ' could not be found in the list of contracts implemented by the service 'DigitalStripperService'.

Wheewwwy, I screwed up every single one of them. So I tried to eliminate them one at a time, same problem. I check the name, check the interface name. Both look good. So what have I done differently? I put the interfaces into a shared assembly, that must be it. So I removed the project reference and copied the classes back into the project. Double checked the namespaces and figured, this has to be it. But it wasn't. I went through everything I could think of and nothing. Fortunately, Nikki the sausage dog got that look in his eye that he usually does right before chewing up one of my shoes or taking a dump on the floor and sharing it with me. Upon getting up I realized I had went wayy tooo far down WindowsCommuncationFoundation express today and needed to do other things like walk the dog.

When I arrived back, I saw what the problem was by the time I got comfortably seating. A lot of times things just work like that.

So, take one last look at the problem and see if you can figure it out - it's totally glaring if you're careful. (If you've been a reader of my blog for a while, it's a well known thing that I due and have done the same thing many times before.

I tend to type fairly quickly and while I use both thumps to space with, I frequently double this the space bar. In T-SQL and C#, it seldom matters. MS Word and Excel both just fix it for me. So I don't even realize I"m doing it. But configuration files - well, I think that they were made by a bunch of German guys who though it'd be a great goof to give guys like me a hard time "So uuwwe really sink dat Lexus have betta quality control den der BMW, You fool, we'll teach you a lesson!"

So I looked around and looked around and realized I put an extra space in after an interface name. Ok, that's fixed. All is good. But each new service I added suffered from the same problem. This time I knew exactly what it was, but it was easy to mess up b/c of muscle memory in my fingers.

A quick way to know if you're service is configured correctly is as simple as one like in a browers:

http://localhost:2361/CuckooService/EvilBlueCuckooService.svc?wsdl

Substitute the name and location of your service(s) and use the good old ?wsdl method to make sure it works. If everything is in place, a browser window with a bunch of nested funky looking xml should appear that looks like your service definition. If not, well you gotta problem. So simple to use, it's worth it's price in gold.

So far, I got the images of the Cuckoo coming out of his clock, the SausageDog making "pinchy loaf loaf" all wired into to a client UI. If any of my reliable friends like KC , Brian Madsen , Sahil or Ryan wanna help me with the UI for the last one, I got the back end stuff worked out ;-)

And hopefully none of the Usual and BrainWashedGrievance Brigade
will try to pee on our parade. I have a lot of fun WCF samles which are pretty cool.

My next WCF post will be on "Doing things with Behaviors most people can only dream about..."