WorkflowPersistenceService.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 / WF / RunTime / Hosting / WorkflowPersistenceService.cs / 1305376 / WorkflowPersistenceService.cs
                        

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

using System; 
using System.IO; 
using System.IO.Compression;
using System.Workflow.Runtime; 
using System.Workflow.ComponentModel;
using System.Diagnostics;

namespace System.Workflow.Runtime.Hosting 
{
 	///  Service for saving engine state.  
    public abstract class WorkflowPersistenceService : WorkflowRuntimeService 
    {
        ///  Saves the state of a workflow instance.  
        ///  The workflow instance state to save 
        internal protected abstract void SaveWorkflowInstanceState(Activity rootActivity, bool unlock);

        ///  
        /// 
		internal protected abstract void UnlockWorkflowInstanceState(Activity rootActivity); 
 
        ///  Loads the state of a workflow instance. 
        ///  The unique ID of the instance to load  
        ///  The workflow instance state
        internal protected abstract Activity LoadWorkflowInstanceState(Guid instanceId);

        ///  Saves the state of a completed scope.  
        ///  The completed scope to save 
        internal protected abstract void SaveCompletedContextActivity(Activity activity); 
 
        ///  Loads the state of a completed scope 
        ///  The unique identifier of the completed scope  
        ///  The completed scope or null 
        internal protected abstract Activity LoadCompletedContextActivity(Guid scopeId, Activity outerActivity);

        ///  
        /// 
        /// The value of the "UnloadOnIdle" flag 
        internal protected abstract bool UnloadOnIdle(Activity activity); 

        static protected byte[] GetDefaultSerializedForm(Activity activity) 
        {
            DateTime startTime = DateTime.Now;
            Byte[] result;
 
            Debug.Assert(activity != null, "Null activity");
            using (MemoryStream stream = new MemoryStream(10240)) 
            { 
                stream.Position = 0;
                activity.Save(stream); 
                using (MemoryStream compressedStream = new MemoryStream((int)stream.Length))
                {
                    using (GZipStream gzs = new GZipStream(compressedStream, CompressionMode.Compress, true))
                    { 
                        gzs.Write(stream.GetBuffer(), 0, (int)stream.Length);
                    } 
 
                    ActivityExecutionContextInfo executionContextInfo = (ActivityExecutionContextInfo)activity.GetValue(Activity.ActivityExecutionContextInfoProperty);
                    TimeSpan timeElapsed = DateTime.Now - startTime; 
                    WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0,
                        "Serialized a {0} with id {1} to length {2}. Took {3}.",
                        executionContextInfo, executionContextInfo.ContextGuid, compressedStream.Length, timeElapsed);
 
                    result = compressedStream.GetBuffer();
                    Array.Resize(ref result, Convert.ToInt32(compressedStream.Length)); 
                } 
            }
            return result; 
        }

        static protected Activity RestoreFromDefaultSerializedForm(Byte[] activityBytes, Activity outerActivity)
        { 
            DateTime startTime = DateTime.Now;
            Activity state; 
 
            MemoryStream stream = new MemoryStream(activityBytes);
            stream.Position = 0; 

            using (GZipStream gzs = new GZipStream(stream, CompressionMode.Decompress, true))
            {
                state = Activity.Load(gzs, outerActivity); 
            }
            Debug.Assert(state != null, "invalid state recovered"); 
            TimeSpan timeElapsed = DateTime.Now - startTime; 
            WorkflowTrace.Host.TraceEvent(TraceEventType.Information, 0,
                "Deserialized a {0} to length {1}. Took {2}.", 
                state, stream.Length, timeElapsed);

            return state;
        } 
        static protected internal bool GetIsBlocked(Activity rootActivity)
        { 
            return (bool)rootActivity.GetValue(WorkflowExecutor.IsBlockedProperty); 
        }
        static protected internal string GetSuspendOrTerminateInfo(Activity rootActivity) 
        {
            return (string)rootActivity.GetValue(WorkflowExecutor.SuspendOrTerminateInfoProperty);
        }
        static protected internal WorkflowStatus GetWorkflowStatus(Activity rootActivity) 
        {
            return (WorkflowStatus)rootActivity.GetValue(WorkflowExecutor.WorkflowStatusProperty); 
        } 
    }
} 

// 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