internal void DeserializeTo(IServiceProvider serviceProvider, IContainer container)
        {
            DesignerSerializationManager serializationManager = new LocalDesignerSerializationManager(this, serviceProvider);

            using (serializationManager.CreateSession())
            {
                WorkflowMarkupSerializationManager   xomlSerializationManager             = new WorkflowMarkupSerializationManager(serializationManager);
                PropertySegmentSerializationProvider propertySegmentSerializationProvider = new PropertySegmentSerializationProvider();
                xomlSerializationManager.AddSerializationProvider(propertySegmentSerializationProvider);

                StringReader stringReader = new StringReader(this.serializedXmlString);
                using (XmlTextReader reader = new XmlTextReader(stringReader)
                {
                    DtdProcessing = DtdProcessing.Prohibit
                })
                {
                    while (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.ProcessingInstruction && reader.Read())
                    {
                        ;
                    }

                    IReferenceService       referenceService       = this.serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
                    IComponentChangeService componentChangeService = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
                    for (int loop = 0; loop < this.memberList.Count; loop++)
                    {
                        object obj = referenceService.GetReference(this.parentObjectNameList[loop]);
                        if (obj != null)
                        {
                            bool needChangeEvent = (componentChangeService != null) && (!(obj is IComponent) || (((IComponent)obj).Site == null));

                            PropertyDescriptor member = this.memberList[loop] as PropertyDescriptor;
                            if (needChangeEvent)
                            {
                                componentChangeService.OnComponentChanging(obj, member);
                            }

                            xomlSerializationManager.Context.Push(obj);
                            PropertySegmentSerializer serializer      = new PropertySegmentSerializer(null);
                            PropertySegment           propertySegment = serializer.DeserializeObject(xomlSerializationManager, reader) as PropertySegment;
                            System.Diagnostics.Debug.Assert(obj == xomlSerializationManager.Context.Current, "Serialization Store did not remove object which it pushed onto the stack.");
                            xomlSerializationManager.Context.Pop();

                            if (needChangeEvent)
                            {
                                componentChangeService.OnComponentChanged(obj, member, null, null);
                            }
                        }
                    }
                }

                xomlSerializationManager.RemoveSerializationProvider(propertySegmentSerializationProvider);
            }
        }
        internal void DeserializeTo(IServiceProvider serviceProvider, IContainer container)
        {
            DesignerSerializationManager manager = new LocalDesignerSerializationManager(this, serviceProvider);

            using (manager.CreateSession())
            {
                WorkflowMarkupSerializationManager   serializationManager = new WorkflowMarkupSerializationManager(manager);
                PropertySegmentSerializationProvider provider             = new PropertySegmentSerializationProvider();
                serializationManager.AddSerializationProvider(provider);
                StringReader input = new StringReader(this.serializedXmlString);
                using (XmlTextReader reader2 = new XmlTextReader(input))
                {
                    while (((reader2.NodeType != XmlNodeType.Element) && (reader2.NodeType != XmlNodeType.ProcessingInstruction)) && reader2.Read())
                    {
                    }
                    IReferenceService       service  = this.serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
                    IComponentChangeService service2 = this.serviceProvider.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
                    for (int i = 0; i < this.memberList.Count; i++)
                    {
                        object reference = service.GetReference(this.parentObjectNameList[i]);
                        if (reference != null)
                        {
                            bool flag = (service2 != null) && (!(reference is IComponent) || (((IComponent)reference).Site == null));
                            PropertyDescriptor member = this.memberList[i] as PropertyDescriptor;
                            if (flag)
                            {
                                service2.OnComponentChanging(reference, member);
                            }
                            serializationManager.Context.Push(reference);
                            new PropertySegmentSerializer(null).DeserializeObject(serializationManager, reader2);
                            serializationManager.Context.Pop();
                            if (flag)
                            {
                                service2.OnComponentChanged(reference, member, null, null);
                            }
                        }
                    }
                }
                serializationManager.RemoveSerializationProvider(provider);
            }
        }
Ejemplo n.º 3
0
        public override void Close()
        {
            if (this.serializedXmlString != null)
            {
                return;
            }

            DesignerSerializationManager serializationManager = new LocalDesignerSerializationManager(this, serviceProvider);

            using (serializationManager.CreateSession())
            {
                // serialize all objects
                WorkflowMarkupSerializationManager xomlSerializationManager = new WorkflowMarkupSerializationManager(serializationManager);
                StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
                using (XmlTextWriter writer = new XmlTextWriter(stringWriter))
                {
                    if (this.memberList.Count == 0)
                    {
                        WorkflowMarkupSerializer xomlSerializer = new WorkflowMarkupSerializer();
                        foreach (Activity activity in this.activities)
                        {
                            xomlSerializer.SerializeObject(xomlSerializationManager, activity, writer);
                        }
                    }
                    else
                    {
                        PropertySegmentSerializationProvider propertySegmentSerializationProvider = new PropertySegmentSerializationProvider();
                        xomlSerializationManager.AddSerializationProvider(propertySegmentSerializationProvider);

                        xomlSerializationManager.Context.Push(new StringWriter(CultureInfo.InvariantCulture));

                        IReferenceService referenceService = this.serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
                        if (referenceService != null)
                        {
                            for (int loop = 0; loop < this.memberList.Count; loop++)
                            {
                                object obj = referenceService.GetReference(this.parentObjectNameList[loop]);
                                PropertySegmentSerializer serializer = new PropertySegmentSerializer(null);
                                if (this.memberList[loop] is PropertyDescriptor)
                                {
                                    PropertyInfo propertyInfo = XomlComponentSerializationService.GetProperty(obj.GetType(), (this.memberList[loop] as PropertyDescriptor).Name, BindingFlags.Public | BindingFlags.Instance);
                                    if (propertyInfo != null)
                                    {
                                        serializer.SerializeObject(xomlSerializationManager, new PropertySegment(this.serviceProvider, obj, propertyInfo), writer);
                                    }
                                    else
                                    {
                                        serializer.SerializeObject(xomlSerializationManager, new PropertySegment(this.serviceProvider, obj, this.memberList[loop] as PropertyDescriptor), writer);
                                    }
                                }
                                else if (this.memberList[loop] is EventDescriptor)
                                {
                                    // Events.
                                    IEventBindingService eventBindingService = this.serviceProvider.GetService(typeof(IEventBindingService)) as IEventBindingService;
                                    if (eventBindingService != null)
                                    {
                                        PropertySegment propertySegment = new PropertySegment(serviceProvider, obj, eventBindingService.GetEventProperty(this.memberList[loop] as EventDescriptor));
                                        serializer.SerializeObject(xomlSerializationManager, propertySegment, writer);
                                    }
                                }
                            }
                        }

                        xomlSerializationManager.Context.Pop();
                        xomlSerializationManager.RemoveSerializationProvider(propertySegmentSerializationProvider);
                    }
                }
                this.serializedXmlString = stringWriter.ToString();

                // store all the assembly names
                List <AssemblyName> assemblyList = new List <AssemblyName>();
                foreach (Activity activity in this.activities)
                {
                    Assembly a = activity.GetType().Assembly;
                    assemblyList.Add(a.GetName(true));
                }
                this.assemblies = assemblyList.ToArray();
                this.activities.Clear();
                this.activities = null;
            }
        }
 public override void Close()
 {
     if (this.serializedXmlString == null)
     {
         DesignerSerializationManager manager = new LocalDesignerSerializationManager(this, this.serviceProvider);
         using (manager.CreateSession())
         {
             WorkflowMarkupSerializationManager serializationManager = new WorkflowMarkupSerializationManager(manager);
             StringWriter w = new StringWriter(CultureInfo.InvariantCulture);
             using (XmlTextWriter writer2 = new XmlTextWriter(w))
             {
                 if (this.memberList.Count == 0)
                 {
                     WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
                     foreach (Activity activity in this.activities)
                     {
                         serializer.SerializeObject(serializationManager, activity, writer2);
                     }
                 }
                 else
                 {
                     PropertySegmentSerializationProvider provider = new PropertySegmentSerializationProvider();
                     serializationManager.AddSerializationProvider(provider);
                     serializationManager.Context.Push(new StringWriter(CultureInfo.InvariantCulture));
                     IReferenceService service = this.serviceProvider.GetService(typeof(IReferenceService)) as IReferenceService;
                     if (service != null)
                     {
                         for (int i = 0; i < this.memberList.Count; i++)
                         {
                             object reference = service.GetReference(this.parentObjectNameList[i]);
                             PropertySegmentSerializer serializer2 = new PropertySegmentSerializer(null);
                             if (this.memberList[i] is PropertyDescriptor)
                             {
                                 PropertyInfo property = XomlComponentSerializationService.GetProperty(reference.GetType(), (this.memberList[i] as PropertyDescriptor).Name, BindingFlags.Public | BindingFlags.Instance);
                                 if (property != null)
                                 {
                                     serializer2.SerializeObject(serializationManager, new PropertySegment(this.serviceProvider, reference, property), writer2);
                                 }
                                 else
                                 {
                                     serializer2.SerializeObject(serializationManager, new PropertySegment(this.serviceProvider, reference, this.memberList[i] as PropertyDescriptor), writer2);
                                 }
                             }
                             else if (this.memberList[i] is EventDescriptor)
                             {
                                 IEventBindingService service2 = this.serviceProvider.GetService(typeof(IEventBindingService)) as IEventBindingService;
                                 if (service2 != null)
                                 {
                                     PropertySegment segment = new PropertySegment(this.serviceProvider, reference, service2.GetEventProperty(this.memberList[i] as EventDescriptor));
                                     serializer2.SerializeObject(serializationManager, segment, writer2);
                                 }
                             }
                         }
                     }
                     serializationManager.Context.Pop();
                     serializationManager.RemoveSerializationProvider(provider);
                 }
             }
             this.serializedXmlString = w.ToString();
             List <AssemblyName> list = new List <AssemblyName>();
             foreach (Activity activity2 in this.activities)
             {
                 Assembly assembly = activity2.GetType().Assembly;
                 list.Add(assembly.GetName(true));
             }
             this.assemblies = list.ToArray();
             this.activities.Clear();
             this.activities = null;
         }
     }
 }