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 //first and elements later // Dependency events are treated as the same as dependency properties. try { if (obj is DependencyObject && ((DependencyObject)obj).UserData.Contains(UserDataKeys.DesignTimeTypeNames)) designTimeTypeNames = ((DependencyObject)obj).UserData[UserDataKeys.DesignTimeTypeNames] as Hashtable; dependencyProperties = serializer.GetDependencyProperties(serializationManager, obj); properties.AddRange(serializer.GetProperties(serializationManager, obj)); // For Key properties, we don;t want to get the extended properties if (!dictionaryKey) properties.AddRange(serializationManager.GetExtendedProperties(obj)); events.AddRange(serializer.GetEvents(serializationManager, obj)); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } } if (dependencyProperties != null) { // For attached properties that does not have a corresponding real property on the object, if the value is a design time // type, it may not be set through dependency property SetValue, therefore will not be present in the dependencyProperties // collection, we'll have to get the dependency property object ourselves. if (designTimeTypeNames != null) { foreach (object key in designTimeTypeNames.Keys) { DependencyProperty dependencyProperty = key as DependencyProperty; if (dependencyProperty != null && !dependencyProperties.ContainsKey(dependencyProperty)) dependencyProperties.Add(dependencyProperty, designTimeTypeNames[dependencyProperty]); } } // Add all dependency properties to the master collection. foreach (DependencyProperty dependencyProperty in dependencyProperties.Keys) { string propertyName = String.Empty; if (dependencyProperty.IsAttached) { string prefix = String.Empty; XmlQualifiedName qualifiedName = serializationManager.GetXmlQualifiedName(dependencyProperty.OwnerType, out prefix); propertyName = qualifiedName.Name + "." + dependencyProperty.Name; } else { propertyName = dependencyProperty.Name; } if (dependencyProperty.IsAttached || !dependencyProperty.DefaultMetadata.IsMetaProperty) allProperties.Add(propertyName, dependencyProperty); } } if (properties != null) { foreach (PropertyInfo propInfo in properties) { // Do not serialize properties that have corresponding dynamic properties. if (propInfo != null && !allProperties.ContainsKey(propInfo.Name)) allProperties.Add(propInfo.Name, propInfo); } } if (events != null) { foreach (EventInfo eventInfo in events) { // Do not serialize events that have corresponding dynamic properties. if (eventInfo != null && !allProperties.ContainsKey(eventInfo.Name)) allProperties.Add(eventInfo.Name, eventInfo); } } using (ContentProperty contentProperty = new ContentProperty(serializationManager, serializer, obj)) { foreach (object propertyObj in allProperties.Values) { string propertyName = String.Empty; object propertyValue = null; Type propertyInfoType = null; try { if (propertyObj is PropertyInfo) { PropertyInfo property = propertyObj as PropertyInfo; // If the property has parameters we can not serialize it , we just move on. ParameterInfo[] indexParameters = property.GetIndexParameters(); if (indexParameters != null && indexParameters.Length > 0) continue; propertyName = property.Name; propertyValue = null; if (property.CanRead) { propertyValue = property.GetValue(obj, null); if (propertyValue == null && TypeProvider.IsAssignable(typeof(Type), property.PropertyType)) { // See if we have a design time value for the property DependencyProperty dependencyProperty = DependencyProperty.FromName(property.Name, property.ReflectedType); if (dependencyProperty != null) propertyValue = Helpers.GetDesignTimeTypeName(obj, dependencyProperty); if (propertyValue == null) { string key = property.ReflectedType.FullName + "." + property.Name; propertyValue = Helpers.GetDesignTimeTypeName(obj, key); } if (propertyValue != null) propertyValue = new TypeExtension((string)propertyValue); } } propertyInfoType = property.PropertyType; } else if (propertyObj is EventInfo) { EventInfo evt = propertyObj as EventInfo; propertyName = evt.Name; propertyValue = WorkflowMarkupSerializationHelpers.GetEventHandlerName(obj, evt.Name); if ((propertyValue == null || (propertyValue is string && string.IsNullOrEmpty((string)propertyValue))) && obj is DependencyObject) { // The object is not created through deserialization, we should check to see if the delegate is // created and added to list. We can only serialize the handler if its target type is the same // as the activity type that's be designed. DependencyProperty dependencyProperty = DependencyProperty.FromName(propertyName, obj.GetType()); if (dependencyProperty != null) { Activity activity = serializationManager.Context[typeof(Activity)] as Activity; Delegate handler = ((DependencyObject)obj).GetHandler(dependencyProperty) as Delegate; if (handler != null && activity != null && TypeProvider.Equals(handler.Target.GetType(), Helpers.GetRootActivity(activity).GetType())) propertyValue = handler; } } propertyInfoType = evt.EventHandlerType; } else if (propertyObj is DependencyProperty) { DependencyProperty dependencyProperty = propertyObj as DependencyProperty; propertyName = dependencyProperty.Name; propertyValue = dependencyProperties[dependencyProperty]; propertyInfoType = dependencyProperty.PropertyType; } } catch (Exception e) { while (e is TargetInvocationException && e.InnerException != null) e = e.InnerException; serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerPropertyGetFailed, new object[] { propertyName, obj.GetType().FullName, e.Message }))); continue; } if (propertyObj is PropertyInfo && contentProperty.Property == (PropertyInfo)propertyObj) continue; Type propertyValueType = null; if (propertyValue != null) { propertyValue = GetMarkupExtensionFromValue(propertyValue); propertyValueType = propertyValue.GetType(); } else if (propertyObj is PropertyInfo) { propertyValue = new NullExtension(); propertyValueType = propertyValue.GetType(); Attribute[] attributes = Attribute.GetCustomAttributes(propertyObj as PropertyInfo, typeof(DefaultValueAttribute), true); if (attributes.Length > 0) { DefaultValueAttribute defaultValueAttr = attributes[0] as DefaultValueAttribute; if (defaultValueAttr.Value == null) propertyValue = null; } } if (propertyValue != null) propertyValueType = propertyValue.GetType(); //Now get the serializer to persist the properties, if the serializer is not found then we dont serialize the properties serializationManager.Context.Push(propertyObj); WorkflowMarkupSerializer propValueSerializer = null; try { propValueSerializer = serializationManager.GetSerializer(propertyValueType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); serializationManager.Context.Pop(); continue; } if (propValueSerializer == null) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, propertyValueType.FullName))); serializationManager.Context.Pop(); continue; } // ask serializer if we can serialize try { if (propValueSerializer.ShouldSerializeValue(serializationManager, propertyValue)) { //NOTE: THE FOLLOWING CONDITION ABOUT propertyInfoType != typeof(object) is VALID AS WE SHOULD NOT SERIALIZE A PROPERTY OF TYPE OBJECT TO STRING //IF WE DO THAT THEN WE DO NOT KNOWN WHAT WAS THE TYPE OF ORIGINAL OBJECT AND SERIALIZER WONT BE ABLE TO GET THE STRING BACK INTO THE CORRECT TYPE, //AS THE TYPE INFORMATION IS LOST if (propValueSerializer.CanSerializeToString(serializationManager, propertyValue) && propertyInfoType != typeof(object)) { using (new SafeXmlNodeWriter(serializationManager, obj, propertyObj, XmlNodeType.Attribute)) { //This is a work around to special case the markup extension serializer as it writes to the stream using writer if (propValueSerializer is MarkupExtensionSerializer) { propValueSerializer.SerializeToString(serializationManager, propertyValue); } else { string stringValue = propValueSerializer.SerializeToString(serializationManager, propertyValue); if (!string.IsNullOrEmpty(stringValue)) { stringValue = stringValue.Replace('\0', ' '); if (propertyValue is MarkupExtension || !(stringValue.StartsWith("{", StringComparison.Ordinal) && stringValue.EndsWith("}", StringComparison.Ordinal))) writer.WriteString(stringValue); else writer.WriteString("{}" + stringValue); } } } } else { complexProperties.Add(propertyObj); } } } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNoSerializeLogic, new object[] { propertyName, obj.GetType().FullName }), e)); } finally { Debug.Assert(serializationManager.Context.Current == propertyObj, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } try { serializer.OnBeforeSerializeContents(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } // serialize compound properties as child elements of the current node. foreach (object propertyObj in complexProperties) { // get value and check for null string propertyName = String.Empty; object propertyValue = null; Type ownerType = null; bool isReadOnly = false; try { if (propertyObj is PropertyInfo) { PropertyInfo property = propertyObj as PropertyInfo; propertyName = property.Name; propertyValue = property.CanRead ? property.GetValue(obj, null) : null; ownerType = obj.GetType(); isReadOnly = (!property.CanWrite); } else if (propertyObj is DependencyProperty) { DependencyProperty dependencyProperty = propertyObj as DependencyProperty; propertyName = dependencyProperty.Name; propertyValue = dependencyProperties[dependencyProperty]; ownerType = dependencyProperty.OwnerType; isReadOnly = ((dependencyProperty.DefaultMetadata.Options & DependencyPropertyOptions.ReadOnly) == DependencyPropertyOptions.ReadOnly); } } catch (Exception e) { while (e is TargetInvocationException && e.InnerException != null) e = e.InnerException; serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerPropertyGetFailed, propertyName, ownerType.FullName, e.Message))); continue; } if (propertyObj is PropertyInfo && (PropertyInfo)propertyObj == contentProperty.Property) continue; if (propertyValue != null) { propertyValue = GetMarkupExtensionFromValue(propertyValue); WorkflowMarkupSerializer propValueSerializer = serializationManager.GetSerializer(propertyValue.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (propValueSerializer != null) { using (new SafeXmlNodeWriter(serializationManager, obj, propertyObj, XmlNodeType.Element)) { if (isReadOnly) propValueSerializer.SerializeContents(serializationManager, propertyValue, writer, false); else propValueSerializer.SerializeObject(serializationManager, propertyValue, writer); } } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, propertyValue.GetType().FullName))); } } } // serialize the contents try { object contents = contentProperty.GetContents(); if (contents != null) { contents = GetMarkupExtensionFromValue(contents); WorkflowMarkupSerializer propValueSerializer = serializationManager.GetSerializer(contents.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (propValueSerializer == null) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, contents.GetType()))); } else { // //NOTE: THE FOLLOWING CONDITION ABOUT contentProperty.Property.PropertyType != typeof(object) is VALID AS WE SHOULD NOT SERIALIZE A PROPERTY OF TYPE OBJECT TO STRING //IF WE DO THAT THEN WE DO NOT KNOWN WHAT WAS THE TYPE OF ORIGINAL OBJECT AND SERIALIZER WONT BE ABLE TO GET THE STRING BACK INTO THE CORRECT TYPE, //AS THE TYPE INFORMATION IS LOST if (propValueSerializer.CanSerializeToString(serializationManager, contents) && (contentProperty.Property == null || contentProperty.Property.PropertyType != typeof(object))) { string stringValue = propValueSerializer.SerializeToString(serializationManager, contents); if (!string.IsNullOrEmpty(stringValue)) { stringValue = stringValue.Replace('\0', ' '); if (contents is MarkupExtension || !(stringValue.StartsWith("{", StringComparison.Ordinal) && stringValue.EndsWith("}", StringComparison.Ordinal))) writer.WriteString(stringValue); else writer.WriteString("{}" + stringValue); } } else if (CollectionMarkupSerializer.IsValidCollectionType(contents.GetType())) { if (contentProperty.Property == null) { IEnumerable enumerableContents = contents as IEnumerable; foreach (object childObj in enumerableContents) { if (childObj == null) { SerializeObject(serializationManager, new NullExtension(), writer); } else { object childObj2 = childObj; bool dictionaryEntry = (childObj2 is DictionaryEntry); try { if (dictionaryEntry) { serializationManager.WorkflowMarkupStack.Push(childObj); childObj2 = ((DictionaryEntry)childObj2).Value; } childObj2 = GetMarkupExtensionFromValue(childObj2); WorkflowMarkupSerializer childObjectSerializer = serializationManager.GetSerializer(childObj2.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (childObjectSerializer != null) childObjectSerializer.SerializeObject(serializationManager, childObj2, writer); else serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, childObj2.GetType()))); } finally { if (dictionaryEntry) serializationManager.WorkflowMarkupStack.Pop(); } } } } else { propValueSerializer.SerializeContents(serializationManager, contents, writer, false); } } else { propValueSerializer.SerializeObject(serializationManager, contents, writer); } } } } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } } try { serializer.OnAfterSerialize(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } }
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; } } serializationManager.Context.Push(info2); try { object obj3 = info2.GetValue(value, null); if (serializer.ShouldSerializeValue(serializationManager, obj3)) { if (serializer.CanSerializeToString(serializationManager, obj3)) { if (num++ > 0) { writer.WriteString(","); } else { writer.WriteString(" "); } writer.WriteString(info2.Name); writer.WriteString("="); if (obj3.GetType() == typeof(string)) { writer.WriteString(this.CreateEscapedValue(obj3 as string)); } else { string str4 = serializer.SerializeToString(serializationManager, obj3); if (str4 != null) { writer.WriteString(str4); } } } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString("Error_SerializerNoSerializeLogic", new object[] { info2.Name, value.GetType().FullName }))); } } } catch { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString("Error_SerializerNoSerializeLogic", new object[] { info2.Name, value.GetType().FullName }))); } finally { serializationManager.Context.Pop(); } } } } writer.WriteString("}"); return string.Empty; }
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) { serializationManager.Context.Push(property); try { DeserializeSimpleProperty(serializationManager, reader, obj, propVal); } finally { Debug.Assert((PropertyInfo)serializationManager.Context.Current == property, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else { EventInfo evt = WorkflowMarkupSerializer.LookupEvent(events, propName); if (events != null && evt != null) { serializationManager.Context.Push(evt); try { DeserializeEvent(serializationManager, reader, obj, propVal); } finally { Debug.Assert((EventInfo)serializationManager.Context.Current == evt, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNoMemberFound, new object[] { propName, obj.GetType().FullName }), reader)); } } } } try { serializer.OnBeforeDeserializeContents(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } //Now deserialize compound properties try { serializer.ClearChildren(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerThrewException, obj.GetType(), e.Message), e, reader)); return; } using (ContentProperty contentProperty = new ContentProperty(serializationManager, serializer, obj)) { List<ContentInfo> contents = new List<ContentInfo>(); if (!isEmptyElement) { reader.MoveToElement(); int initialDepth = reader.Depth; XmlQualifiedName extendedPropertyQualifiedName = new XmlQualifiedName(reader.LocalName, reader.LookupNamespace(reader.Prefix)); do { // Extended property should be deserialized, this is required for primitive types which have extended property as children // We should not ignore if (extendedPropertyQualifiedName != null && !ExtendedPropertyInfo.IsExtendedProperty(serializationManager, extendedPropertyQualifiedName)) { extendedPropertyQualifiedName = null; continue; } // this will make it to skip all the nodes if ((initialDepth + 1) < reader.Depth) { bool unnecessaryXmlFound = false; while (reader.Read() && ((initialDepth + 1) < reader.Depth)) { // Ignore comments and whitespaces if (reader.NodeType != XmlNodeType.Comment && reader.NodeType != XmlNodeType.Whitespace && !unnecessaryXmlFound) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidDataFoundForType, obj.GetType().FullName), reader)); unnecessaryXmlFound = true; } } } //Push all the PIs into stack so that they are available for type resolution AdvanceReader(reader); if (reader.NodeType == XmlNodeType.Element) { //We should only support A.B syntax for compound properties, all others are treated as content XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(reader.LocalName, reader.LookupNamespace(reader.Prefix)); int index = reader.LocalName.IndexOf('.'); if (index > 0 || ExtendedPropertyInfo.IsExtendedProperty(serializationManager, xmlQualifiedName)) { string propertyName = reader.LocalName.Substring(reader.LocalName.IndexOf('.') + 1); PropertyInfo property = WorkflowMarkupSerializer.LookupProperty(props, propertyName); DependencyProperty dependencyProperty = ResolveDependencyProperty(serializationManager, reader, obj, reader.LocalName); if (dependencyProperty == null && property == null) serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidElementFoundForType, reader.LocalName, obj.GetType().FullName), reader)); else if (dependencyProperty != null) { PropertyInfo prop = WorkflowMarkupSerializer.LookupProperty(props, dependencyProperty.Name); //Deserialize the dynamic property serializationManager.Context.Push(dependencyProperty); try { DeserializeCompoundProperty(serializationManager, reader, obj); } finally { Debug.Assert(serializationManager.Context.Current == dependencyProperty, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else if (property != null) { //Deserialize the compound property serializationManager.Context.Push(property); try { DeserializeCompoundProperty(serializationManager, reader, obj); } finally { Debug.Assert((PropertyInfo)serializationManager.Context.Current == property, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } } else { //Deserialize the children int lineNumber = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1; int linePosition = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1; object obj2 = DeserializeObject(serializationManager, reader); if (obj2 != null) { obj2 = GetValueFromMarkupExtension(serializationManager, obj2); if (obj2 != null && obj2.GetType() == typeof(string) && ((string)obj2).StartsWith("{}", StringComparison.Ordinal)) obj2 = ((string)obj2).Substring(2); contents.Add(new ContentInfo(obj2, lineNumber, linePosition)); } } } else if (reader.NodeType == XmlNodeType.Text && contentProperty.Property != null) { //If we read the string then we should not advance the reader further instead break int lineNumber = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1; int linePosition = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1; contents.Add(new ContentInfo(reader.ReadString(), lineNumber, linePosition)); if (initialDepth >= reader.Depth) break; } else { if (reader.NodeType == XmlNodeType.Entity || reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA) serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidDataFound, reader.Value.Trim(), obj.GetType().FullName), reader)); } } while (reader.Read() && initialDepth < reader.Depth); } //Make sure that we set contents contentProperty.SetContents(contents); } try { serializer.OnAfterDeserialize(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } }
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))); } } }
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)); } }
// This function parses the data bind syntax (markup extension in xaml terms). The syntax is: // {ObjectTypeName arg1, arg2, name3=arg3, name4=arg4, ...} // For example, an ActivityBind would have the syntax as the following: // {wcm:ActivityBind ID=Workflow1, Path=error1} // We also support positional arguments, so the above expression is equivalent to // {wcm:ActivityBind Workflow1, Path=error1} or {wcm:ActivityBind Workflow1, error1} // Notice that the object must have the appropriate constructor to support positional arugments. // There should be no constructors that takes the same number of arugments, regardless of their types. internal object DeserializeFromCompactFormat(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, string attrValue) { if (attrValue.Length == 0 || !attrValue.StartsWith("{", StringComparison.Ordinal) || !attrValue.EndsWith("}", StringComparison.Ordinal)) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.IncorrectSyntax, attrValue), reader)); return null; } // check for correct format: typename name=value name=value int argIndex = attrValue.IndexOf(" ", StringComparison.Ordinal); if (argIndex == -1) argIndex = attrValue.IndexOf("}", StringComparison.Ordinal); string typename = attrValue.Substring(1, argIndex - 1).Trim(); string arguments = attrValue.Substring(argIndex + 1, attrValue.Length - (argIndex + 1)); // lookup the type of the target string prefix = String.Empty; int typeIndex = typename.IndexOf(":", StringComparison.Ordinal); if (typeIndex >= 0) { prefix = typename.Substring(0, typeIndex); typename = typename.Substring(typeIndex + 1); } Type type = serializationManager.GetType(new XmlQualifiedName(typename, reader.LookupNamespace(prefix))); if (type == null && !typename.EndsWith("Extension", StringComparison.Ordinal)) { typename = typename + "Extension"; type = serializationManager.GetType(new XmlQualifiedName(typename, reader.LookupNamespace(prefix))); } if (type == null) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_MarkupSerializerTypeNotResolved, typename), reader)); return null; } // Break apart the argument string. object obj = null; Dictionary<string, object> namedArgs = new Dictionary<string, object>(); ArrayList argTokens = null; try { argTokens = TokenizeAttributes(serializationManager, arguments, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1); } catch (Exception error) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_MarkupExtensionDeserializeFailed, attrValue, error.Message), reader)); return null; } if (argTokens != null) { // Process the positional arugments and find the correct constructor to call. ArrayList positionalArgs = new ArrayList(); bool firstEqual = true; for (int i = 0; i < argTokens.Count; i++) { char token = (argTokens[i] is char) ? (char)argTokens[i] : '\0'; if (token == '=') { if (positionalArgs.Count > 0 && firstEqual) positionalArgs.RemoveAt(positionalArgs.Count - 1); firstEqual = false; namedArgs.Add(argTokens[i - 1] as string, argTokens[i + 1] as string); i++; } 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 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 { property.SetValue(obj, propValue, null); } catch { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerComplexPropertySetFailed, new object[] { propertyName, propertyName, obj.GetType().Name }))); } } } } } } }
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 if (propSerializer.CanSerializeToString(serializationManager, propValue)) { if (index++ > 0) writer.WriteString(MarkupExtensionSerializer.CompactFormatPropertySeperator); else writer.WriteString(MarkupExtensionSerializer.CompactFormatTypeSeperator); writer.WriteString(serializableProperty.Name); writer.WriteString(MarkupExtensionSerializer.CompactFormatNameValueSeperator); if (propValue.GetType() == typeof(string)) { writer.WriteString(CreateEscapedValue(propValue as string)); } else { string stringValue = propSerializer.SerializeToString(serializationManager, propValue); if (stringValue != null) writer.WriteString(stringValue); } } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNoSerializeLogic, new object[] { serializableProperty.Name, value.GetType().FullName }))); } } } catch { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNoSerializeLogic, new object[] { serializableProperty.Name, value.GetType().FullName }))); continue; } finally { Debug.Assert((PropertyInfo)serializationManager.Context.Current == serializableProperty, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } } writer.WriteString(MarkupExtensionSerializer.CompactFormatEnd); return string.Empty; }
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) { if (instanceDescriptor.MemberInfo is ConstructorInfo ctorInfo) { 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 if (propSerializer.CanSerializeToString(serializationManager, propValue)) { if (index++ > 0) { writer.WriteString(MarkupExtensionSerializer.CompactFormatPropertySeperator); } else { writer.WriteString(MarkupExtensionSerializer.CompactFormatTypeSeperator); } writer.WriteString(serializableProperty.Name); writer.WriteString(MarkupExtensionSerializer.CompactFormatNameValueSeperator); if (propValue.GetType() == typeof(string)) { writer.WriteString(CreateEscapedValue(propValue as string)); } else { string stringValue = propSerializer.SerializeToString(serializationManager, propValue); if (stringValue != null) { writer.WriteString(stringValue); } } } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNoSerializeLogic, new object[] { serializableProperty.Name, value.GetType().FullName }))); } } } catch { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNoSerializeLogic, new object[] { serializableProperty.Name, value.GetType().FullName }))); continue; } finally { Debug.Assert((PropertyInfo)serializationManager.Context.Current == serializableProperty, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } } writer.WriteString(MarkupExtensionSerializer.CompactFormatEnd); return(string.Empty); }
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; } } serializationManager.Context.Push(info2); try { object obj3 = info2.GetValue(value, null); if (serializer.ShouldSerializeValue(serializationManager, obj3)) { if (serializer.CanSerializeToString(serializationManager, obj3)) { if (num++ > 0) { writer.WriteString(","); } else { writer.WriteString(" "); } writer.WriteString(info2.Name); writer.WriteString("="); if (obj3.GetType() == typeof(string)) { writer.WriteString(this.CreateEscapedValue(obj3 as string)); } else { string str4 = serializer.SerializeToString(serializationManager, obj3); if (str4 != null) { writer.WriteString(str4); } } } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString("Error_SerializerNoSerializeLogic", new object[] { info2.Name, value.GetType().FullName }))); } } } catch { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString("Error_SerializerNoSerializeLogic", new object[] { info2.Name, value.GetType().FullName }))); } finally { serializationManager.Context.Pop(); } } } } writer.WriteString("}"); return(string.Empty); }