LoadWorkflowAsyncResult.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.Activities.DurableInstancing / System / Activities / DurableInstancing / LoadWorkflowAsyncResult.cs / 1305376 / LoadWorkflowAsyncResult.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

namespace System.Activities.DurableInstancing 
{
    using System.Collections.Generic; 
    using System.Data; 
    using System.Data.SqlClient;
    using System.Globalization; 
    using System.Linq;
    using System.Runtime.DurableInstancing;
    using System.Transactions;
    using System.Xml.Linq; 

    class LoadWorkflowAsyncResult : SqlWorkflowInstanceStoreAsyncResult 
    { 
        static readonly string commandText = string.Format(CultureInfo.InvariantCulture, "{0}.[LoadInstance]", SqlWorkflowInstanceStoreConstants.DefaultSchema);
        Dictionary> associatedInstanceKeys; 
        Dictionary> completedInstanceKeys;

        Dictionary instanceData;
        Dictionary instanceMetadata; 
        IObjectSerializer objectSerializer;
 
        public LoadWorkflowAsyncResult 
            (
            InstancePersistenceContext context, 
            InstancePersistenceCommand command,
            SqlWorkflowInstanceStore store,
            SqlWorkflowInstanceStoreLock storeLock,
            Transaction currentTransaction, 
            TimeSpan timeout,
            AsyncCallback callback, 
            object state 
            ) :
            base(context, command, store, storeLock, currentTransaction, timeout, callback, state) 
        {
            this.associatedInstanceKeys = new Dictionary>();
            this.completedInstanceKeys = new Dictionary>();
            this.objectSerializer = ObjectSerializerFactory.GetDefaultObjectSerializer(); 
        }
 
        protected void GenerateLoadSqlCommand 
            (
            SqlCommand command, 
            LoadType loadType,
            Guid keyToLoadBy,
            Guid instanceId,
            List keysToAssociate 
            )
        { 
            long surrogateLockOwnerId = base.StoreLock.SurrogateLockOwnerId; 
            byte[] concatenatedKeyProperties = null;
            bool singleKeyToAssociate = (keysToAssociate != null && keysToAssociate.Count == 1); 

            if (keysToAssociate != null)
            {
                concatenatedKeyProperties = SerializationUtilities.CreateKeyBinaryBlob(keysToAssociate); 
            }
 
            double operationTimeout = this.TimeoutHelper.RemainingTime().TotalMilliseconds; 

            SqlParameterCollection parameters = command.Parameters; 
            parameters.Add(new SqlParameter { ParameterName = "@surrogateLockOwnerId", SqlDbType = SqlDbType.BigInt, Value = surrogateLockOwnerId });
            parameters.Add(new SqlParameter { ParameterName = "@operationType", SqlDbType = SqlDbType.TinyInt, Value = loadType });
            parameters.Add(new SqlParameter { ParameterName = "@keyToLoadBy", SqlDbType = SqlDbType.UniqueIdentifier, Value = keyToLoadBy });
            parameters.Add(new SqlParameter { ParameterName = "@instanceId", SqlDbType = SqlDbType.UniqueIdentifier, Value = instanceId }); 
            parameters.Add(new SqlParameter { ParameterName = "@handleInstanceVersion", SqlDbType = SqlDbType.BigInt, Value = base.InstancePersistenceContext.InstanceVersion });
            parameters.Add(new SqlParameter { ParameterName = "@handleIsBoundToLock", SqlDbType = SqlDbType.Bit, Value = base.InstancePersistenceContext.InstanceView.IsBoundToLock }); 
            parameters.Add(new SqlParameter { ParameterName = "@keysToAssociate", SqlDbType = SqlDbType.Xml, Value = singleKeyToAssociate ? DBNull.Value : SerializationUtilities.CreateCorrelationKeyXmlBlob(keysToAssociate) }); 
            parameters.Add(new SqlParameter { ParameterName = "@encodingOption", SqlDbType = SqlDbType.TinyInt, Value = base.Store.InstanceEncodingOption });
            parameters.Add(new SqlParameter { ParameterName = "@concatenatedKeyProperties", SqlDbType = SqlDbType.VarBinary, Value = (object) concatenatedKeyProperties ?? DBNull.Value }); 
            parameters.Add(new SqlParameter { ParameterName = "@operationTimeout", SqlDbType = SqlDbType.Int, Value = (operationTimeout < Int32.MaxValue) ? Convert.ToInt32(operationTimeout) : Int32.MaxValue });
            parameters.Add(new SqlParameter { ParameterName = "@singleKeyId", SqlDbType = SqlDbType.UniqueIdentifier, Value = singleKeyToAssociate ? keysToAssociate[0].KeyId : (object) DBNull.Value });
        }
 
        protected override void GenerateSqlCommand(SqlCommand command)
        { 
            LoadWorkflowCommand loadWorkflowCommand = base.InstancePersistenceCommand as LoadWorkflowCommand; 
            LoadType loadType = loadWorkflowCommand.AcceptUninitializedInstance ? LoadType.LoadOrCreateByInstance : LoadType.LoadByInstance;
            Guid instanceId = base.InstancePersistenceContext.InstanceView.InstanceId; 

            GenerateLoadSqlCommand(command, loadType, Guid.Empty, instanceId, null);
        }
 
        protected override string GetSqlCommandText()
        { 
            return LoadWorkflowAsyncResult.commandText; 
        }
 
        protected override CommandType GetSqlCommandType()
        {
            return CommandType.StoredProcedure;
        } 

        protected override Exception ProcessSqlResult(SqlDataReader reader) 
        { 
            Exception exception = StoreUtilities.GetNextResultSet(base.InstancePersistenceCommand.Name, reader);
 
            if (exception == null)
            {
                Guid instanceId = reader.GetGuid(1);
                long surrogateInstanceId = reader.GetInt64(2); 
                byte[] primitiveProperties = reader.IsDBNull(3) ? null : (byte[])(reader.GetValue(3));
                byte[] complexProperties = reader.IsDBNull(4) ? null : (byte[])(reader.GetValue(4)); 
                byte[] metadataProperties = reader.IsDBNull(5) ? null : (byte[])(reader.GetValue(5)); 
                InstanceEncodingOption dataEncodingOption = (InstanceEncodingOption)(reader.GetByte(6));
                InstanceEncodingOption metadataEncodingOption = (InstanceEncodingOption)(reader.GetByte(7)); 
                long version = reader.GetInt64(8);
                bool isInitialized = reader.GetBoolean(9);
                bool createdInstance = reader.GetBoolean(10);
 
                LoadWorkflowCommand loadWorkflowCommand = base.InstancePersistenceCommand as LoadWorkflowCommand;
                LoadWorkflowByInstanceKeyCommand loadByKeycommand = base.InstancePersistenceCommand as LoadWorkflowByInstanceKeyCommand; 
 
                if (!base.InstancePersistenceContext.InstanceView.IsBoundToInstance)
                { 
                    base.InstancePersistenceContext.BindInstance(instanceId);
                }
                if (!base.InstancePersistenceContext.InstanceView.IsBoundToInstanceOwner)
                { 
                    base.InstancePersistenceContext.BindInstanceOwner(base.StoreLock.LockOwnerId, base.StoreLock.LockOwnerId);
                } 
                if (!base.InstancePersistenceContext.InstanceView.IsBoundToLock) 
                {
                    InstanceLockTracking instanceLockTracking = (InstanceLockTracking)(base.InstancePersistenceContext.UserContext); 
                    instanceLockTracking.TrackStoreLock(instanceId, version, this.DependentTransaction);
                    base.InstancePersistenceContext.BindAcquiredLock(version);
                }
 
                this.instanceData = SerializationUtilities.DeserializePropertyBag(primitiveProperties, complexProperties, dataEncodingOption);
                this.instanceMetadata = SerializationUtilities.DeserializeMetadataPropertyBag(metadataProperties, metadataEncodingOption); 
 
                if (!createdInstance)
                { 
                    ReadInstanceMetadataChanges(reader, this.instanceMetadata);
                    ReadKeyData(reader, this.associatedInstanceKeys, this.completedInstanceKeys);
                }
                else if (loadByKeycommand != null) 
                {
                    foreach (KeyValuePair> keyEntry in loadByKeycommand.InstanceKeysToAssociate) 
                    { 
                        this.associatedInstanceKeys.Add(keyEntry.Key, keyEntry.Value);
                    } 

                    if (!this.associatedInstanceKeys.ContainsKey(loadByKeycommand.LookupInstanceKey))
                    {
                        base.InstancePersistenceContext.AssociatedInstanceKey(loadByKeycommand.LookupInstanceKey); 
                        this.associatedInstanceKeys.Add(loadByKeycommand.LookupInstanceKey, new Dictionary());
                    } 
                } 

                if (loadByKeycommand != null) 
                {
                    foreach (KeyValuePair> keyEntry in loadByKeycommand.InstanceKeysToAssociate)
                    {
                        base.InstancePersistenceContext.AssociatedInstanceKey(keyEntry.Key); 

                        if (keyEntry.Value != null) 
                        { 
                            foreach (KeyValuePair property in keyEntry.Value)
                            { 
                                base.InstancePersistenceContext.WroteInstanceKeyMetadataValue(keyEntry.Key, property.Key, property.Value);
                            }
                        }
                    } 
                }
 
                base.InstancePersistenceContext.LoadedInstance 
                    (
                    isInitialized ? InstanceState.Initialized : InstanceState.Uninitialized, 
                    this.instanceData,
                    this.instanceMetadata,
                    this.associatedInstanceKeys,
                    this.completedInstanceKeys 
                    );
            } 
            else if (exception is InstanceLockLostException) 
            {
                base.InstancePersistenceContext.InstanceHandle.Free(); 
            }

            return exception;
        } 

        void ReadInstanceMetadataChanges(SqlDataReader reader, Dictionary instanceMetadata) 
        { 
            Exception exception = StoreUtilities.GetNextResultSet(base.InstancePersistenceCommand.Name, reader);
 
            if (exception == null)
            {
                if (reader.IsDBNull(1))
                { 
                    return;
                } 
            } 

            do 
            {
                InstanceEncodingOption encodingOption = (InstanceEncodingOption) reader.GetByte(1);
                byte[] serializedMetadataChanges = (byte[]) reader.GetValue(2);
 
                Dictionary metadataChangeSet = SerializationUtilities.DeserializeMetadataPropertyBag(serializedMetadataChanges, encodingOption);
 
                foreach (KeyValuePair metadataChange in metadataChangeSet) 
                {
                    XName xname = metadataChange.Key; 
                    InstanceValue propertyValue = metadataChange.Value;

                    if (propertyValue.Value is DeletedMetadataValue)
                    { 
                        instanceMetadata.Remove(xname);
                    } 
                    else 
                    {
                        instanceMetadata[xname] = propertyValue; 
                    }
                }
            }
            while (reader.Read()); 
        }
 
        void ReadKeyData(SqlDataReader reader, Dictionary> associatedInstanceKeys, 
            Dictionary> completedInstanceKeys)
        { 
            Exception exception = StoreUtilities.GetNextResultSet(base.InstancePersistenceCommand.Name, reader);

            if (exception == null)
            { 
                if (reader.IsDBNull(1))
                { 
                    return; 
                }
 
                do
                {
                    Guid key = reader.GetGuid(1);
                    bool isAssociated = reader.GetBoolean(2); 
                    InstanceEncodingOption encodingOption = (InstanceEncodingOption) reader.GetByte(3);
                    Dictionary> destination = isAssociated ? associatedInstanceKeys : completedInstanceKeys; 
 
                    if (!reader.IsDBNull(4))
                    { 
                        destination[key] = SerializationUtilities.DeserializeKeyMetadata((byte[]) reader.GetValue(4), encodingOption);
                    }
                    else
                    { 
                        destination[key] = new Dictionary();
                    } 
 
                }
                while (reader.Read()); 
            }
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK