Disconnected LINQ to SQL Tips Part 1

Intro!
In my research on LINQ to SQL and trying to work around the limititation of no "out of the box" disconnected (n-tier) mode, I've come accross a lot of things that others may find useful.

I was somewhat disappointed in this drawback as LINQ to SQL - seeing that it was only intended to be used in "connected" scenario. I saw it as a challenge to figure out ways in which a "disconnected" scenario could be done.

Hence, here I am a first time virgin blogger - who felt compelled to reduce the sweat and tears of others while dealing with this double edged sword.

I'll be blogging how "Disconnected LINQ" can be achieved in a later post, but first up here's some tips for some of you out there that might be struggling with "Disconnected LINQ".

The 'How to do Disconnected' Rules
First up, here are the rules for allowing disconnected LINQ to SQL. To successfully disconnect a LINQ to SQL entity from a Data Context and allow it to re-connect to a different Data Context, you must do the following:

1. Enable Concurrency Tracking
You can enable concurrency tracking by adding a timestamp (rowversion) field to your database and include this in your LINQ to SQL model.

Alternatively, if you don't care for concurrency tracking you can set all columns so that the Update Check is set to false.

2. Disable Deffered Loading, Load Everything or Serialize the objects
Disabling Lazy loading is fairly straight forward, it just a simple matter of setting the DeferredLoadingEnabled = False like so:

using (EntitiesDataContext db = new EntitiesDataContext())

{

    db.DeferredLoadingEnabled = false;

    var customers = from c in db.Customers

                    where c.CustomerId == CustomerId

                    select c;

}

This tells link not to query that database when a link association (another object or collection) is referenced, instead it will simply return a null.

Alternatively, you can also load all related objects so there is nothing to lazy load. This can be done by using the datacontext load options object like so:

using (EntitiesDataContext db = new EntitiesDataContext())

{

    DataLoadOptions lo = new DataLoadOptions();

    lo.LoadWith<Customer>(c => c.Dependants);

    db.LoadOptions = lo;

    var customers = from c in db.Customers

                    where c.CustomerId == CustomerId

                    select c;

}

Basically, this is telling the data context that whenever it loads a Customer, it should also load the Dependants for that customer. If all the related objects or collections are covered in this way, LINQ to SQL won't even consider deferred loading because it believes it has all the possible connected objects.

As for serialization, this automatically disables deferred loading as above ... and how to serialize is covered next....

Serializing and copying the objects
Linq to SQL entities cannot be serialized using standard serialization techniques, this means you can't just pop it in the view state or ASP.NET state server without running into some trouble.

In order to serialize an LINQ to SQL object graph (a root object and it's child entities) you'll need to use the WCF data contract serializer instead.

But wait! Even before you do that, you'll need to set your Data Contexts serialization mode to "Unidirectional" (which is available in the model properties). This means that only references in the object graph from parent to child will be serialized and therefore therefore child to parent references will be ignored. This is good because it means that circular references won't cause problems. The standard serializer can't be used for exactly this reason, because it would end up with failing because it would try to serialize circular references.

Here's a couple of functions which can be used to serialize/deserialize a LINQ to SQL object graph and also a handy copy function which will make a completely seperate copy of an object graph.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.Serialization;

using System.Text;

using System.IO;

using System.Xml;

namespace SampleFramework

{

    public static class LINQHelper

    {       

        /// <summary>

        /// Makes a copy of an existing LINQ to SQL entity and it's children.

        /// </summary>

        /// <typeparam name="T"></typeparam>

        /// <param name="entitySource">The LINQ to SQL entity to copy</param>

        /// <returns></returns>

        public static T CopyEntityDeep<T>(T entitySource)

        {

            if (entitySource == null)

                return default(T);

            return (T)DeserializeEntity(SerializeEntity(entitySource), entitySource.GetType());

        }

        /// <summary>

        /// Makes a copy of a list of existing LINQ to SQL entities and their children.

        /// </summary>

        /// <typeparam name="T"></typeparam>

        /// <param name="source">The LIST of SQL entities to copy

        /// </param>

        /// <returns></returns>

        public static List<T> CopyEntityListDeep<T>(List<T> entitySourceList)

        {

            List<T> result = new List<T>();

            if (entitySourceList == null)

                return null;

            foreach (T entitySource in entitySourceList)

            {

                T entityTarget = CopyEntityDeep(entitySource);

                result.Add(entityTarget);

            }

            return result;

        }

        public static string SerializeEntity<T>(T entitySource)

        {

            DataContractSerializer dcs = new DataContractSerializer(entitySource.GetType());

            if (entitySource == null)

                return null;

            StringBuilder sb = new StringBuilder();

            XmlWriter xmlw = XmlWriter.Create(sb);

            dcs.WriteObject(xmlw, entitySource);

            xmlw.Close();

            return sb.ToString();

        }

        public static object DeserializeEntity(string entitySource, Type entityType)

        {

            object entityTarget;

            if (entityType == null)

                return null;

            DataContractSerializer dcs = new DataContractSerializer(entityType);

            StringReader sr = new StringReader(entitySource);

            XmlTextReader xmltr = new XmlTextReader(sr);

            entityTarget = (object)dcs.ReadObject(xmltr);

            xmltr.Close();

            return entityTarget;

        }

    }

}

Wrapping up
Next post, I hope to move further into the disconnected model that I've come up with that uses some of the above techniques to track changes.

Cheers

Matt.