C# WorkflowMarkupSerializationManager.GetSerializer方法代码示例

        internal void SerializeContents(WorkflowMarkupSerializationManager serializationManager, object obj, XmlWriter writer, bool dictionaryKey)
        {
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager");
            if (obj == null)
                throw new ArgumentNullException("obj");
            if (writer == null)
                throw new ArgumentNullException("writer");

            WorkflowMarkupSerializer serializer = null;
            try
            {
                //Now get the serializer to persist the properties, if the serializer is not found then we dont serialize the properties
                serializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;

            }
            catch (Exception e)
            {
                serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e));
                return;

            }

            if (serializer == null)
            {
                serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, obj.GetType().FullName)));
                return;
            }

            try
            {
                serializer.OnBeforeSerialize(serializationManager, obj);
            }
            catch (Exception e)
            {
                serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e));
                return;
            }

            Hashtable allProperties = new Hashtable();
            ArrayList complexProperties = new ArrayList();

            IDictionary<DependencyProperty, object> dependencyProperties = null;
            List<PropertyInfo> properties = new List<PropertyInfo>();
            List<EventInfo> events = new List<EventInfo>();
            Hashtable designTimeTypeNames = null;

            // Serialize the extended properties for primitive types also
            if (obj.GetType().IsPrimitive || obj.GetType() == typeof(string) || obj.GetType() == typeof(decimal) ||
                obj.GetType() == typeof(DateTime) || obj.GetType() == typeof(TimeSpan) || obj.GetType().IsEnum ||
                obj.GetType() == typeof(Guid))
            {
                if (obj.GetType() == typeof(char) || obj.GetType() == typeof(byte) ||
                    obj.GetType() == typeof(System.Int16) || obj.GetType() == typeof(decimal) ||
                    obj.GetType() == typeof(DateTime) || obj.GetType() == typeof(TimeSpan) ||
                    obj.GetType().IsEnum || obj.GetType() == typeof(Guid))
                {
                    //These non CLS-compliant are not supported in the XmlWriter 
                    if ((obj.GetType() != typeof(char)) || (char)obj != '\0')
                    {
                        //These non CLS-compliant are not supported in the XmlReader 
                        string stringValue = String.Empty;
                        if (obj.GetType() == typeof(DateTime))
                        {
                            stringValue = ((DateTime)obj).ToString("o", CultureInfo.InvariantCulture);
                        }
                        else
                        {
                            TypeConverter typeConverter = TypeDescriptor.GetConverter(obj.GetType());
                            if (typeConverter != null && typeConverter.CanConvertTo(typeof(string)))
                                stringValue = typeConverter.ConvertTo(null, CultureInfo.InvariantCulture, obj, typeof(string)) as string;
                            else
                                stringValue = Convert.ToString(obj, CultureInfo.InvariantCulture);
                        }

                        writer.WriteValue(stringValue);
                    }
                }
                else if (obj.GetType() == typeof(string))
                {
                    string attribValue = obj as string;
                    attribValue = attribValue.Replace('\0', ' ');
                    if (!(attribValue.StartsWith("{", StringComparison.Ordinal) && attribValue.EndsWith("}", StringComparison.Ordinal)))
                        writer.WriteValue(attribValue);
                    else
                        writer.WriteValue("{}" + attribValue);
                }
                else
                {
                    writer.WriteValue(obj);
                }
                // For Key properties, we don;t want to get the extended properties
                if (!dictionaryKey)
                    properties.AddRange(serializationManager.GetExtendedProperties(obj));
            }
            else
            {
                // Serialize properties
                //We first get all the properties, once we have them all, we start distinguishing between
                //simple and complex properties, the reason for that is XmlWriter needs to write attributes
//.........这里部分代码省略.........

 protected internal sealed override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
 {
     if (serializationManager == null)
     {
         throw new ArgumentNullException("serializationManager");
     }
     XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     if (value == null)
     {
         throw new ArgumentNullException("value");
     }
     writer.WriteString("{");
     string prefix = string.Empty;
     XmlQualifiedName xmlQualifiedName = serializationManager.GetXmlQualifiedName(value.GetType(), out prefix);
     writer.WriteQualifiedName(xmlQualifiedName.Name, xmlQualifiedName.Namespace);
     int num = 0;
     Dictionary<string, string> dictionary = null;
     InstanceDescriptor instanceDescriptor = this.GetInstanceDescriptor(serializationManager, value);
     if (instanceDescriptor != null)
     {
         ConstructorInfo memberInfo = instanceDescriptor.MemberInfo as ConstructorInfo;
         if (memberInfo != null)
         {
             ParameterInfo[] parameters = memberInfo.GetParameters();
             if ((parameters != null) && (parameters.Length == instanceDescriptor.Arguments.Count))
             {
                 int index = 0;
                 foreach (object obj2 in instanceDescriptor.Arguments)
                 {
                     if (dictionary == null)
                     {
                         dictionary = new Dictionary<string, string>();
                     }
                     if (obj2 != null)
                     {
                         dictionary.Add(parameters[index].Name, parameters[index++].Name);
                         if (num++ > 0)
                         {
                             writer.WriteString(",");
                         }
                         else
                         {
                             writer.WriteString(" ");
                         }
                         if (obj2.GetType() == typeof(string))
                         {
                             writer.WriteString(this.CreateEscapedValue(obj2 as string));
                         }
                         else if (obj2 is Type)
                         {
                             Type type = obj2 as Type;
                             if (type.Assembly != null)
                             {
                                 string str2 = string.Empty;
                                 XmlQualifiedName name2 = serializationManager.GetXmlQualifiedName(type, out str2);
                                 writer.WriteQualifiedName(XmlConvert.EncodeName(name2.Name), name2.Namespace);
                             }
                             else
                             {
                                 writer.WriteString(type.FullName);
                             }
                         }
                         else
                         {
                             string text = base.SerializeToString(serializationManager, obj2);
                             if (text != null)
                             {
                                 writer.WriteString(text);
                             }
                         }
                     }
                 }
             }
         }
     }
     List<PropertyInfo> list = new List<PropertyInfo>();
     list.AddRange(this.GetProperties(serializationManager, value));
     list.AddRange(serializationManager.GetExtendedProperties(value));
     foreach (PropertyInfo info2 in list)
     {
         if (((Helpers.GetSerializationVisibility(info2) != DesignerSerializationVisibility.Hidden) && info2.CanRead) && (info2.GetValue(value, null) != null))
         {
             WorkflowMarkupSerializer serializer = serializationManager.GetSerializer(info2.PropertyType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
             if (serializer == null)
             {
                 serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString("Error_SerializerNotAvailable", new object[] { info2.PropertyType.FullName })));
             }
             else
             {
                 if (dictionary != null)
                 {
                     object[] customAttributes = info2.GetCustomAttributes(typeof(ConstructorArgumentAttribute), false);
                     if ((customAttributes.Length > 0) && dictionary.ContainsKey((customAttributes[0] as ConstructorArgumentAttribute).ArgumentName))
                     {
                         continue;
                     }
//.........这里部分代码省略.........

        private void DeserializeContents(WorkflowMarkupSerializationManager serializationManager, object obj, XmlReader reader)
        {
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager");
            if (obj == null)
                throw new ArgumentNullException("obj");
            if (reader == null)
                throw new ArgumentNullException("reader");

            if (reader.NodeType != XmlNodeType.Element)
                return;

            // get the serializer
            WorkflowMarkupSerializer serializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
            if (serializer == null)
            {
                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, obj.GetType().FullName), reader));
                return;
            }

            try
            {
                serializer.OnBeforeDeserialize(serializationManager, obj);
            }
            catch (Exception e)
            {
                serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e));
                return;
            }

            bool isEmptyElement = reader.IsEmptyElement;
            string elementNamespace = reader.NamespaceURI;

            List<PropertyInfo> props = new List<PropertyInfo>();
            List<EventInfo> events = new List<EventInfo>();
            // Add the extended properties for primitive types
            if (obj.GetType().IsPrimitive || obj.GetType() == typeof(string) || obj.GetType() == typeof(decimal) ||
                obj.GetType().IsEnum || obj.GetType() == typeof(DateTime) || obj.GetType() == typeof(TimeSpan) ||
                obj.GetType() == typeof(Guid))
            {
                props.AddRange(serializationManager.GetExtendedProperties(obj));
            }
            else
            {
                try
                {
                    props.AddRange(serializer.GetProperties(serializationManager, obj));
                    props.AddRange(serializationManager.GetExtendedProperties(obj));
                    events.AddRange(serializer.GetEvents(serializationManager, obj));
                }
                catch (Exception e)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerThrewException, obj.GetType(), e.Message), e, reader));
                    return;
                }
            }
            //First we try to deserialize simple properties
            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    // 
                    if (reader.LocalName.Equals("xmlns", StringComparison.Ordinal) || reader.Prefix.Equals("xmlns", StringComparison.Ordinal))
                        continue;

                    //
                    XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(reader.LocalName, reader.LookupNamespace(reader.Prefix));
                    if (xmlQualifiedName.Namespace.Equals(StandardXomlKeys.Definitions_XmlNs, StringComparison.Ordinal) &&
                        !IsMarkupExtension(xmlQualifiedName) &&
                        !ExtendedPropertyInfo.IsExtendedProperty(serializationManager, props, xmlQualifiedName) &&
                        !ExtendedPropertyInfo.IsExtendedProperty(serializationManager, xmlQualifiedName))
                    {
                        serializationManager.FireFoundDefTag(new WorkflowMarkupElementEventArgs(reader));
                        continue;
                    }

                    //For simple properties we assume that if . indicates
                    string propName = XmlConvert.DecodeName(reader.LocalName);
                    string propVal = reader.Value;
                    DependencyProperty dependencyProperty = ResolveDependencyProperty(serializationManager, reader, obj, propName);
                    if (dependencyProperty != null)
                    {
                        serializationManager.Context.Push(dependencyProperty);
                        try
                        {
                            if (dependencyProperty.IsEvent)
                                DeserializeEvent(serializationManager, reader, obj, propVal);
                            else
                                DeserializeSimpleProperty(serializationManager, reader, obj, propVal);
                        }
                        finally
                        {
                            Debug.Assert(serializationManager.Context.Current == dependencyProperty, "Serializer did not remove an object it pushed into stack.");
                            serializationManager.Context.Pop();
                        }
                    }
                    else
                    {
                        PropertyInfo property = WorkflowMarkupSerializer.LookupProperty(props, propName);
                        if (property != null)
//.........这里部分代码省略.........

            public ContentProperty(WorkflowMarkupSerializationManager serializationManager, WorkflowMarkupSerializer parentObjectSerializer, object parentObject)
            {
                this.serializationManager = serializationManager;
                this.parentObjectSerializer = parentObjectSerializer;
                this.parentObject = parentObject;

                this.contentProperty = GetContentProperty(this.serializationManager, this.parentObject);
                if (this.contentProperty != null)
                {
                    this.contentPropertySerializer = this.serializationManager.GetSerializer(this.contentProperty.PropertyType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                    if (this.contentPropertySerializer != null)
                    {
                        try
                        {
                            XmlReader reader = this.serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader;
                            object contentPropertyValue = null;
                            if (reader == null)
                            {
                                contentPropertyValue = this.contentProperty.GetValue(this.parentObject, null);
                            }
                            else if (!this.contentProperty.PropertyType.IsValueType &&
                                    !this.contentProperty.PropertyType.IsPrimitive &&
                                    this.contentProperty.PropertyType != typeof(string) &&
                                    !IsMarkupExtension(this.contentProperty.PropertyType) &&
                                    this.contentProperty.CanWrite)
                            {
                                WorkflowMarkupSerializer serializer = serializationManager.GetSerializer(this.contentProperty.PropertyType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                                if (serializer == null)
                                {
                                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, this.contentProperty.PropertyType.FullName), reader));
                                    return;
                                }
                                try
                                {
                                    contentPropertyValue = serializer.CreateInstance(serializationManager, this.contentProperty.PropertyType);
                                }
                                catch (Exception e)
                                {
                                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerCreateInstanceFailed, this.contentProperty.PropertyType.FullName, e.Message), reader));
                                    return;
                                }
                                this.contentProperty.SetValue(this.parentObject, contentPropertyValue, null);
                            }

                            if (contentPropertyValue != null)
                            {
                                if (reader != null)
                                {
                                    this.contentPropertySerializer.OnBeforeDeserialize(this.serializationManager, contentPropertyValue);
                                    this.contentPropertySerializer.OnBeforeDeserializeContents(this.serializationManager, contentPropertyValue);
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            this.serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, this.parentObject.GetType(), e.Message), e));
                        }
                    }
                    else
                    {
                        this.serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, this.contentProperty.PropertyType.FullName)));
                    }
                }
            }

//.........这里部分代码省略.........
                    }
                    if (token == ',')
                        continue;

                    if (namedArgs.Count == 0)
                        positionalArgs.Add(argTokens[i] as string);
                }

                if (positionalArgs.Count > 0)
                {
                    ConstructorInfo matchConstructor = null;
                    ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
                    ParameterInfo[] matchParameters = null;
                    foreach (ConstructorInfo ctor in constructors)
                    {
                        ParameterInfo[] parameters = ctor.GetParameters();
                        if (parameters.Length == positionalArgs.Count)
                        {
                            matchConstructor = ctor;
                            matchParameters = parameters;
                            break;
                        }
                    }

                    if (matchConstructor != null)
                    {
                        for (int i = 0; i < positionalArgs.Count; i++)
                        {
                            positionalArgs[i] = XmlConvert.DecodeName((string)positionalArgs[i]);
                            string argVal = (string)positionalArgs[i];
                            RemoveEscapes(ref argVal);
                            positionalArgs[i] = InternalDeserializeFromString(serializationManager, matchParameters[i].ParameterType, argVal);
                            positionalArgs[i] = GetValueFromMarkupExtension(serializationManager, positionalArgs[i]);
                        }

                        obj = Activator.CreateInstance(type, positionalArgs.ToArray());
                    }
                }
                else
                    obj = Activator.CreateInstance(type);
            }
            else
                obj = Activator.CreateInstance(type);

            if (obj == null)
            {
                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_CantCreateInstanceOfBaseType, type.FullName), reader));
                return null;
            }

            if (namedArgs.Count > 0)
            {
                WorkflowMarkupSerializer serializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                if (serializer == null)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, obj.GetType().FullName), reader));
                    return obj;
                }
                List<PropertyInfo> properties = new List<PropertyInfo>();
                try
                {
                    properties.AddRange(serializer.GetProperties(serializationManager, obj));
                    properties.AddRange(serializationManager.GetExtendedProperties(obj));
                }
                catch (Exception e)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e, reader));
                    return obj;
                }

                foreach (string key in namedArgs.Keys)
                {
                    string argName = key;
                    string argVal = namedArgs[key] as string;
                    RemoveEscapes(ref argName);
                    RemoveEscapes(ref argVal);

                    PropertyInfo property = WorkflowMarkupSerializer.LookupProperty(properties, argName);
                    if (property != null)
                    {
                        serializationManager.Context.Push(property);
                        try
                        {
                            DeserializeSimpleProperty(serializationManager, reader, obj, argVal);
                        }
                        finally
                        {
                            Debug.Assert((PropertyInfo)serializationManager.Context.Current == property, "Serializer did not remove an object it pushed into stack.");
                            serializationManager.Context.Pop();
                        }
                    }
                    else
                    {
                        serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerPrimitivePropertyNoLogic, new object[] { argName, argName, obj.GetType().FullName }), reader));
                    }
                }
            }

            return obj;
        }

        private void DeserializeSimpleMember(WorkflowMarkupSerializationManager serializationManager, Type memberType, XmlReader reader, object obj, string value)
        {
            //Get the serializer for the member type
            WorkflowMarkupSerializer memberSerializer = serializationManager.GetSerializer(memberType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
            if (memberSerializer == null)
            {
                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, memberType.FullName), reader));
                return;
            }

            //Try to deserialize
            object memberValue = null;
            try
            {
                memberValue = memberSerializer.DeserializeFromString(serializationManager, memberType, value);
                memberValue = GetValueFromMarkupExtension(serializationManager, memberValue);

                DependencyProperty dependencyProperty = serializationManager.Context.Current as DependencyProperty;
                if (dependencyProperty != null)
                {
                    //Get the serializer for the property type
                    WorkflowMarkupSerializer objSerializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                    if (objSerializer == null)
                    {
                        serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, obj.GetType().FullName), reader));
                        return;
                    }

                    objSerializer.SetDependencyPropertyValue(serializationManager, obj, dependencyProperty, memberValue);
                }
                else
                {
                    EventInfo evt = serializationManager.Context.Current as EventInfo;
                    if (evt != null)
                    {
                        try
                        {
                            WorkflowMarkupSerializationHelpers.SetEventHandlerName(obj, evt.Name, memberValue as string);
                        }
                        catch (Exception e)
                        {
                            while (e is TargetInvocationException && e.InnerException != null)
                                e = e.InnerException;
                            serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerMemberSetFailed, new object[] { reader.LocalName, reader.Value, reader.LocalName, obj.GetType().FullName, e.Message }), e, reader));
                        }
                    }
                    else
                    {
                        PropertyInfo property = serializationManager.Context.Current as PropertyInfo;
                        if (property != null)
                        {
                            try
                            {
                                if (memberValue is string && TypeProvider.IsAssignable(typeof(Type), property.PropertyType))
                                {
                                    string key = property.ReflectedType.FullName + "." + property.Name;
                                    Helpers.SetDesignTimeTypeName(obj, key, memberValue as string);
                                }
                                else if (property.CanWrite)
                                {
                                    property.SetValue(obj, memberValue, null);
                                }
                                else if (typeof(ICollection<string>).IsAssignableFrom(memberValue.GetType()))
                                {
                                    ICollection<string> propVal = property.GetValue(obj, null) as ICollection<string>;
                                    ICollection<string> deserializedValue = memberValue as ICollection<string>;
                                    if (propVal != null && deserializedValue != null)
                                    {
                                        foreach (string content in deserializedValue)
                                            propVal.Add(content);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                while (e is TargetInvocationException && e.InnerException != null)
                                    e = e.InnerException;
                                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerMemberSetFailed, new object[] { reader.LocalName, reader.Value, reader.LocalName, obj.GetType().FullName, e.Message }), e, reader));
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                while (e is TargetInvocationException && e.InnerException != null)
                    e = e.InnerException;
                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerMemberSetFailed, new object[] { reader.LocalName, reader.Value, reader.LocalName, obj.GetType().FullName, e.Message }), e, reader));
            }
        }

        private void DeserializeCompoundProperty(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, object obj)
        {
            string propertyName = reader.LocalName;
            bool isReadOnly = false;

            DependencyProperty dependencyProperty = serializationManager.Context.Current as DependencyProperty;
            PropertyInfo property = serializationManager.Context.Current as PropertyInfo;
            if (dependencyProperty != null)
                isReadOnly = ((dependencyProperty.DefaultMetadata.Options & DependencyPropertyOptions.ReadOnly) == DependencyPropertyOptions.ReadOnly);
            else if (property != null)
                isReadOnly = !property.CanWrite;
            else
            {
                Debug.Assert(false);
                return;
            }

            //Deserialize compound properties
            if (isReadOnly)
            {
                object propValue = null;
                if (dependencyProperty != null && obj is DependencyObject)
                {
                    if (((DependencyObject)obj).IsBindingSet(dependencyProperty))
                        propValue = ((DependencyObject)obj).GetBinding(dependencyProperty);
                    else if (!dependencyProperty.IsEvent)
                        propValue = ((DependencyObject)obj).GetValue(dependencyProperty);
                    else
                        propValue = ((DependencyObject)obj).GetHandler(dependencyProperty);
                }
                else if (property != null)
                    propValue = property.CanRead ? property.GetValue(obj, null) : null;

                if (propValue != null)
                    DeserializeContents(serializationManager, propValue, reader);
                else
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerReadOnlyPropertyAndValueIsNull, propertyName, obj.GetType().FullName), reader));
            }
            else if (!reader.IsEmptyElement)
            {
                //
                if (reader.HasAttributes)
                {
                    //We allow xmlns on the complex property nodes
                    while (reader.MoveToNextAttribute())
                    {
                        // 
                        if (string.Equals(reader.LocalName, "xmlns", StringComparison.Ordinal) || string.Equals(reader.Prefix, "xmlns", StringComparison.Ordinal))
                            continue;
                        else
                            serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerAttributesFoundInComplexProperty, propertyName, obj.GetType().FullName), reader));
                    }
                }

                do
                {
                    if (!reader.Read())
                        return;
                } while (reader.NodeType != XmlNodeType.Text && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.ProcessingInstruction && reader.NodeType != XmlNodeType.EndElement);

                if (reader.NodeType == XmlNodeType.Text)
                {
                    this.DeserializeSimpleProperty(serializationManager, reader, obj, reader.Value);
                }
                else
                {
                    AdvanceReader(reader);
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        object propValue = DeserializeObject(serializationManager, reader);
                        if (propValue != null)
                        {
                            propValue = GetValueFromMarkupExtension(serializationManager, propValue);

                            if (propValue != null && propValue.GetType() == typeof(string) && ((string)propValue).StartsWith("{}", StringComparison.Ordinal))
                                propValue = ((string)propValue).Substring(2);

                            if (dependencyProperty != null)
                            {
                                //Get the serializer for the property type
                                WorkflowMarkupSerializer objSerializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                                if (objSerializer == null)
                                {
                                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, obj.GetType().FullName), reader));
                                    return;
                                }

                                try
                                {
                                    objSerializer.SetDependencyPropertyValue(serializationManager, obj, dependencyProperty, propValue);
                                }
                                catch (Exception e)
                                {
                                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e, reader));
                                    return;
                                }
                            }
                            else if (property != null)
                            {
                                try
//.........这里部分代码省略.........

        private object CreateInstance(WorkflowMarkupSerializationManager serializationManager, XmlQualifiedName xmlQualifiedName, XmlReader reader)
        {
            object obj = null;
            // resolve the type
            Type type = null;
            try
            {
                type = serializationManager.GetType(xmlQualifiedName);
            }
            catch (Exception e)
            {
                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerTypeNotResolvedWithInnerError, new object[] { GetClrFullName(serializationManager, xmlQualifiedName), e.Message }), e, reader));
                return null;
            }
            if (type == null && !xmlQualifiedName.Name.EndsWith("Extension", StringComparison.Ordinal))
            {
                string typename = xmlQualifiedName.Name + "Extension";
                try
                {
                    type = serializationManager.GetType(new XmlQualifiedName(typename, xmlQualifiedName.Namespace));
                }
                catch (Exception e)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerTypeNotResolvedWithInnerError, new object[] { GetClrFullName(serializationManager, xmlQualifiedName), e.Message }), e, reader));
                    return null;
                }
            }

            if (type == null)
            {
                serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerTypeNotResolved, new object[] { GetClrFullName(serializationManager, xmlQualifiedName) }), reader));
                return null;
            }

            if (type.IsPrimitive || type == typeof(string) || type == typeof(decimal) || type == typeof(DateTime) ||
                type == typeof(TimeSpan) || type.IsEnum || type == typeof(Guid))
            {
                try
                {
                    string stringValue = reader.ReadString();
                    if (type == typeof(DateTime))
                    {
                        obj = DateTime.Parse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
                    }
                    else if (type.IsPrimitive || type == typeof(decimal) || type == typeof(TimeSpan) || type.IsEnum || type == typeof(Guid))
                    {
                        //These non CLS-compliant are not supported in the XmlReader 
                        TypeConverter typeConverter = TypeDescriptor.GetConverter(type);
                        if (typeConverter != null && typeConverter.CanConvertFrom(typeof(string)))
                            obj = typeConverter.ConvertFrom(null, CultureInfo.InvariantCulture, stringValue);
                        else if (typeof(IConvertible).IsAssignableFrom(type))
                            obj = Convert.ChangeType(stringValue, type, CultureInfo.InvariantCulture);
                    }
                    else
                    {
                        obj = stringValue;
                    }
                }
                catch (Exception e)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerCreateInstanceFailed, e.Message), reader));
                    return null;
                }
            }
            else
            {
                // get the serializer
                WorkflowMarkupSerializer serializer = serializationManager.GetSerializer(type, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                if (serializer == null)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, type.FullName), reader));
                    return null;
                }

                // create an instance
                try
                {
                    obj = serializer.CreateInstance(serializationManager, type);
                }
                catch (Exception e)
                {
                    serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerCreateInstanceFailed, type.FullName, e.Message), reader));
                    return null;
                }
            }
            return obj;
        }

        protected internal sealed override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
        {
            if (serializationManager == null)
                throw new ArgumentNullException("serializationManager");
            XmlWriter writer = serializationManager.WorkflowMarkupStack[typeof(XmlWriter)] as XmlWriter;
            if (writer == null)
                throw new ArgumentNullException("writer");
            if (value == null)
                throw new ArgumentNullException("value");

            writer.WriteString(MarkupExtensionSerializer.CompactFormatStart);

            string prefix = String.Empty;
            XmlQualifiedName qualifiedName = serializationManager.GetXmlQualifiedName(value.GetType(), out prefix);
            writer.WriteQualifiedName(qualifiedName.Name, qualifiedName.Namespace);

            int index = 0;

            Dictionary<string, string> constructorArguments = null;
            InstanceDescriptor instanceDescriptor = this.GetInstanceDescriptor(serializationManager, value);
            if (instanceDescriptor != null)
            {
                ConstructorInfo ctorInfo = instanceDescriptor.MemberInfo as ConstructorInfo;
                if (ctorInfo != null)
                {
                    ParameterInfo[] parameters = ctorInfo.GetParameters();
                    if (parameters != null && parameters.Length == instanceDescriptor.Arguments.Count)
                    {
                        int i = 0;
                        foreach (object argValue in instanceDescriptor.Arguments)
                        {
                            if (constructorArguments == null)
                                constructorArguments = new Dictionary<string, string>();
                            // 
                            if (argValue == null)
                                continue;
                            constructorArguments.Add(parameters[i].Name, parameters[i++].Name);
                            if (index++ > 0)
                                writer.WriteString(MarkupExtensionSerializer.CompactFormatPropertySeperator);
                            else
                                writer.WriteString(MarkupExtensionSerializer.CompactFormatTypeSeperator);
                            if (argValue.GetType() == typeof(string))
                            {
                                writer.WriteString(CreateEscapedValue(argValue as string));
                            }
                            else if (argValue is System.Type)
                            {
                                Type argType = argValue as Type;
                                if (argType.Assembly != null)
                                {
                                    string typePrefix = String.Empty;
                                    XmlQualifiedName typeQualifiedName = serializationManager.GetXmlQualifiedName(argType, out typePrefix);
                                    writer.WriteQualifiedName(XmlConvert.EncodeName(typeQualifiedName.Name), typeQualifiedName.Namespace);
                                }
                                else
                                {
                                    writer.WriteString(argType.FullName);
                                }
                            }
                            else
                            {
                                string stringValue = base.SerializeToString(serializationManager, argValue);
                                if (stringValue != null)
                                    writer.WriteString(stringValue);
                            }
                        }
                    }
                }
            }

            List<PropertyInfo> properties = new List<PropertyInfo>();
            properties.AddRange(GetProperties(serializationManager, value));
            properties.AddRange(serializationManager.GetExtendedProperties(value));
            foreach (PropertyInfo serializableProperty in properties)
            {
                if (Helpers.GetSerializationVisibility(serializableProperty) != DesignerSerializationVisibility.Hidden && serializableProperty.CanRead && serializableProperty.GetValue(value, null) != null)
                {
                    WorkflowMarkupSerializer propSerializer = serializationManager.GetSerializer(serializableProperty.PropertyType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer;
                    if (propSerializer == null)
                    {
                        serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailable, serializableProperty.PropertyType.FullName)));
                        continue;
                    }

                    if (constructorArguments != null)
                    {
                        object[] attributes = serializableProperty.GetCustomAttributes(typeof(ConstructorArgumentAttribute), false);
                        if (attributes.Length > 0 && constructorArguments.ContainsKey((attributes[0] as ConstructorArgumentAttribute).ArgumentName))
                            // Skip this property, it has already been represented by a constructor parameter
                            continue;
                    }

                    //Get the property serializer so that we can convert the bind object to string
                    serializationManager.Context.Push(serializableProperty);
                    try
                    {
                        object propValue = serializableProperty.GetValue(value, null);
                        if (propSerializer.ShouldSerializeValue(serializationManager, propValue))
                        {
                            //We do not allow nested bind syntax
//.........这里部分代码省略.........