protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value) { CodeTypeReference reference; if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference))) { return null; } if (string.IsNullOrEmpty(value) || base.IsValidCompactAttributeFormat(value)) { return null; } try { Type type = serializationManager.GetType(value); if (type != null) { reference = new CodeTypeReference(type); reference.UserData["QualifiedName"] = type.AssemblyQualifiedName; return reference; } } catch (Exception) { } reference = new CodeTypeReference(value); reference.UserData["QualifiedName"] = value; return reference; }
protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value) { CodeTypeReference reference; if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference))) { return(null); } if (string.IsNullOrEmpty(value) || base.IsValidCompactAttributeFormat(value)) { return(null); } try { Type type = serializationManager.GetType(value); if (type != null) { reference = new CodeTypeReference(type); reference.UserData["QualifiedName"] = type.AssemblyQualifiedName; return(reference); } } catch (Exception) { } reference = new CodeTypeReference(value); reference.UserData["QualifiedName"] = value; return(reference); }
protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) { if (serializationManager == null) { throw new ArgumentNullException("serializationManager"); } if (value == null) { throw new ArgumentNullException("value"); } CodeTypeReference reference = value as CodeTypeReference; if (reference == null) { return(string.Empty); } // make the typename as best we can, and try to get the fully qualified name // if a type is used in an assembly not referenced, GetType will complain string typeName = ConvertTypeReferenceToString(reference); Type type = serializationManager.GetType(typeName); if (type == null) { // TypeProvider can't find it, see if it's a common type in mscorlib type = Type.GetType(typeName, false); if (type == null) { // still no luck finding it, so simply save the name without assembly information // this is equivalent to what happened before return(typeName); } } // // If we get a real type make sure that we get the correct fully qualified name for the target framework version string assemblyFullName = null; TypeProvider typeProvider = serializationManager.GetService(typeof(ITypeProvider)) as TypeProvider; if (typeProvider != null) { assemblyFullName = typeProvider.GetAssemblyName(type); } // // If we didn't find an assembly value it is either a local type or something is wrong // However per the general guidance on multi-targeting it is up to the caller // to make sure that writers (such as Xoml) are given types that exist in the target framework // This makes it the job of the rules designer or rules validator to not call the Xoml stack // with types that do not exist in the target framework if (string.IsNullOrEmpty(assemblyFullName)) { typeName = type.AssemblyQualifiedName; } else { typeName = string.Format(CultureInfo.InvariantCulture, "{0}, {1}", type.FullName, assemblyFullName); } return(typeName); }
internal static Type ResolveWellKnownTypes(WorkflowMarkupSerializationManager manager, string xmlns, string typeName) { Type resolvedType = null; List <WorkflowMarkupSerializerMapping> knownMappings = new List <WorkflowMarkupSerializerMapping>(); if (xmlns.Equals(StandardXomlKeys.WorkflowXmlNs, StringComparison.Ordinal)) { if (!WorkflowMarkupSerializerMapping.wellKnownTypes.TryGetValue(typeName, out resolvedType)) { if (typeName.EndsWith("Activity", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Activities); knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModel); } if (typeName.EndsWith("Designer", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Activities); knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModel); knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModelDesign); } else if (typeName.EndsWith("Theme", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModelDesign); knownMappings.Add(WorkflowMarkupSerializerMapping.Activities); } else if (typeName.StartsWith("Rule", StringComparison.OrdinalIgnoreCase) || typeName.EndsWith("Action", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Rules); } } } else if (xmlns.Equals(StandardXomlKeys.Definitions_XmlNs, StringComparison.Ordinal)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Serialization); } if (resolvedType == null) { foreach (WorkflowMarkupSerializerMapping mapping in knownMappings) { string fullyQualifiedTypeName = mapping.ClrNamespace + "." + typeName + ", " + mapping.AssemblyName; resolvedType = manager.GetType(fullyQualifiedTypeName); if (resolvedType != null) { break; } } } return(resolvedType); }
protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) { if (serializationManager == null) throw new ArgumentNullException("serializationManager"); if (value == null) throw new ArgumentNullException("value"); CodeTypeReference reference = value as CodeTypeReference; if (reference == null) return string.Empty; // make the typename as best we can, and try to get the fully qualified name // if a type is used in an assembly not referenced, GetType will complain string typeName = ConvertTypeReferenceToString(reference); Type type = serializationManager.GetType(typeName); if (type == null) { // TypeProvider can't find it, see if it's a common type in mscorlib type = Type.GetType(typeName, false); if (type == null) { // still no luck finding it, so simply save the name without assembly information // this is equivalent to what happened before return typeName; } } // // If we get a real type make sure that we get the correct fully qualified name for the target framework version string assemblyFullName = null; TypeProvider typeProvider = serializationManager.GetService(typeof(ITypeProvider)) as TypeProvider; if (typeProvider != null) { assemblyFullName = typeProvider.GetAssemblyName(type); } // // If we didn't find an assembly value it is either a local type or something is wrong // However per the general guidance on multi-targeting it is up to the caller // to make sure that writers (such as Xoml) are given types that exist in the target framework // This makes it the job of the rules designer or rules validator to not call the Xoml stack // with types that do not exist in the target framework if (string.IsNullOrEmpty(assemblyFullName)) { typeName = type.AssemblyQualifiedName; } else { typeName = string.Format(CultureInfo.InvariantCulture, "{0}, {1}", type.FullName, assemblyFullName); } return typeName; }
internal static Type ResolveWellKnownTypes(WorkflowMarkupSerializationManager manager, string xmlns, string typeName) { Type type = null; List <WorkflowMarkupSerializerMapping> list = new List <WorkflowMarkupSerializerMapping>(); if (xmlns.Equals("http://schemas.microsoft.com/winfx/2006/xaml/workflow", StringComparison.Ordinal)) { if (!wellKnownTypes.TryGetValue(typeName, out type)) { if (typeName.EndsWith("Activity", StringComparison.OrdinalIgnoreCase)) { list.Add(Activities); list.Add(ComponentModel); } if (typeName.EndsWith("Designer", StringComparison.OrdinalIgnoreCase)) { list.Add(Activities); list.Add(ComponentModel); list.Add(ComponentModelDesign); } else if (typeName.EndsWith("Theme", StringComparison.OrdinalIgnoreCase)) { list.Add(ComponentModelDesign); list.Add(Activities); } else if (typeName.StartsWith("Rule", StringComparison.OrdinalIgnoreCase) || typeName.EndsWith("Action", StringComparison.OrdinalIgnoreCase)) { list.Add(Rules); } } } else if (xmlns.Equals("http://schemas.microsoft.com/winfx/2006/xaml", StringComparison.Ordinal)) { list.Add(Serialization); } if (type == null) { foreach (WorkflowMarkupSerializerMapping mapping in list) { string str = mapping.ClrNamespace + "." + typeName + ", " + mapping.AssemblyName; type = manager.GetType(str); if (type != null) { return(type); } } } return(type); }
protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) { if (serializationManager == null) { throw new ArgumentNullException("serializationManager"); } if (value == null) { throw new ArgumentNullException("value"); } CodeTypeReference reference = value as CodeTypeReference; if (reference == null) { return(string.Empty); } string typeName = ConvertTypeReferenceToString(reference); Type type = serializationManager.GetType(typeName); if (type == null) { type = Type.GetType(typeName, false); if (type == null) { return(typeName); } } string assemblyName = null; TypeProvider service = serializationManager.GetService(typeof(ITypeProvider)) as TypeProvider; if (service != null) { assemblyName = service.GetAssemblyName(type); } if (string.IsNullOrEmpty(assemblyName)) { return(type.AssemblyQualifiedName); } return(string.Format(CultureInfo.InvariantCulture, "{0}, {1}", new object[] { type.FullName, assemblyName })); }
protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value) { if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference))) { return(null); } // if the string is empty or markup extension, // then the object is null if (string.IsNullOrEmpty(value) || IsValidCompactAttributeFormat(value)) { return(null); } // value is the fully qualified name of the type // however, it may refer to non-existant assemblies, so we may get an error CodeTypeReference result; try { Type type = serializationManager.GetType(value); if (type != null) { result = new CodeTypeReference(type); result.UserData[QualifiedName] = type.AssemblyQualifiedName; return(result); } } catch (Exception) { // something went wrong getting the type, so simply pass in the string and // let CodeTypeReference figure it out. Note that CodeTypeReference has a method // RipOffAssemblyInformationFromTypeName, so assembly names are ignored. } result = new CodeTypeReference(value); result.UserData[QualifiedName] = value; return(result); }
private DependencyProperty ResolveDependencyProperty(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, object attachedObj, string fullPropertyName) { Type ownerType = null; string propertyName = String.Empty; int separatorIndex = fullPropertyName.IndexOf("."); if (separatorIndex != -1) { string ownerTypeName = fullPropertyName.Substring(0, separatorIndex); propertyName = fullPropertyName.Substring(separatorIndex + 1); if (!String.IsNullOrEmpty(ownerTypeName) && !String.IsNullOrEmpty(propertyName)) ownerType = serializationManager.GetType(new XmlQualifiedName(ownerTypeName, reader.LookupNamespace(reader.Prefix))); } else { ownerType = attachedObj.GetType(); propertyName = fullPropertyName; } if (ownerType == null) return null; //We need to make sure that the register method is always called for the dynamic property before we try to resolve it //In cases of attached properties if this statement is not there then the dynamic property wont be found as it is //not registered till the first access of the static field DependencyProperty dependencyProperty = null; FieldInfo fieldInfo = ownerType.GetField(propertyName + "Property", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy); if (fieldInfo == null) fieldInfo = ownerType.GetField(propertyName + "Event", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy); if (fieldInfo != null) { dependencyProperty = fieldInfo.GetValue(attachedObj) as DependencyProperty; if (dependencyProperty != null) { object[] attributes = dependencyProperty.DefaultMetadata.GetAttributes(typeof(DesignerSerializationVisibilityAttribute)); if (attributes.Length > 0) { DesignerSerializationVisibilityAttribute serializationVisibilityAttribute = attributes[0] as DesignerSerializationVisibilityAttribute; if (serializationVisibilityAttribute.Visibility == DesignerSerializationVisibility.Hidden) dependencyProperty = null; } } } return dependencyProperty; }
protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value) { if (serializationManager == null) { throw new ArgumentNullException("serializationManager"); } if (value == null) { throw new ArgumentNullException("value"); } CodeTypeReference reference = value as CodeTypeReference; if (reference == null) { return string.Empty; } string typeName = ConvertTypeReferenceToString(reference); Type type = serializationManager.GetType(typeName); if (type == null) { type = Type.GetType(typeName, false); if (type == null) { return typeName; } } string assemblyName = null; TypeProvider service = serializationManager.GetService(typeof(ITypeProvider)) as TypeProvider; if (service != null) { assemblyName = service.GetAssemblyName(type); } if (string.IsNullOrEmpty(assemblyName)) { return type.AssemblyQualifiedName; } return string.Format(CultureInfo.InvariantCulture, "{0}, {1}", new object[] { type.FullName, assemblyName }); }
internal static Type ResolveWellKnownTypes(WorkflowMarkupSerializationManager manager, string xmlns, string typeName) { Type type = null; List<WorkflowMarkupSerializerMapping> list = new List<WorkflowMarkupSerializerMapping>(); if (xmlns.Equals("http://schemas.microsoft.com/winfx/2006/xaml/workflow", StringComparison.Ordinal)) { if (!wellKnownTypes.TryGetValue(typeName, out type)) { if (typeName.EndsWith("Activity", StringComparison.OrdinalIgnoreCase)) { list.Add(Activities); list.Add(ComponentModel); } if (typeName.EndsWith("Designer", StringComparison.OrdinalIgnoreCase)) { list.Add(Activities); list.Add(ComponentModel); list.Add(ComponentModelDesign); } else if (typeName.EndsWith("Theme", StringComparison.OrdinalIgnoreCase)) { list.Add(ComponentModelDesign); list.Add(Activities); } else if (typeName.StartsWith("Rule", StringComparison.OrdinalIgnoreCase) || typeName.EndsWith("Action", StringComparison.OrdinalIgnoreCase)) { list.Add(Rules); } } } else if (xmlns.Equals("http://schemas.microsoft.com/winfx/2006/xaml", StringComparison.Ordinal)) { list.Add(Serialization); } if (type == null) { foreach (WorkflowMarkupSerializerMapping mapping in list) { string str = mapping.ClrNamespace + "." + typeName + ", " + mapping.AssemblyName; type = manager.GetType(str); if (type != null) { return type; } } } return type; }
internal static Type ResolveWellKnownTypes(WorkflowMarkupSerializationManager manager, string xmlns, string typeName) { Type resolvedType = null; List<WorkflowMarkupSerializerMapping> knownMappings = new List<WorkflowMarkupSerializerMapping>(); if (xmlns.Equals(StandardXomlKeys.WorkflowXmlNs, StringComparison.Ordinal)) { if (!WorkflowMarkupSerializerMapping.wellKnownTypes.TryGetValue(typeName, out resolvedType)) { if (typeName.EndsWith("Activity", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Activities); knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModel); } if (typeName.EndsWith("Designer", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Activities); knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModel); knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModelDesign); } else if (typeName.EndsWith("Theme", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.ComponentModelDesign); knownMappings.Add(WorkflowMarkupSerializerMapping.Activities); } else if (typeName.StartsWith("Rule", StringComparison.OrdinalIgnoreCase) || typeName.EndsWith("Action", StringComparison.OrdinalIgnoreCase)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Rules); } } } else if (xmlns.Equals(StandardXomlKeys.Definitions_XmlNs, StringComparison.Ordinal)) { knownMappings.Add(WorkflowMarkupSerializerMapping.Serialization); } if (resolvedType == null) { foreach (WorkflowMarkupSerializerMapping mapping in knownMappings) { string fullyQualifiedTypeName = mapping.ClrNamespace + "." + typeName + ", " + mapping.AssemblyName; resolvedType = manager.GetType(fullyQualifiedTypeName); if (resolvedType != null) break; } } return resolvedType; }
public override object ProvideValue(IServiceProvider provider) { if (this.type != null) { return(this.type); } if (provider == null) { throw new ArgumentNullException("provider"); } if (this.typeName == null) { throw new InvalidOperationException("typename"); } WorkflowMarkupSerializationManager manager = provider as WorkflowMarkupSerializationManager; if (manager == null) { throw new ArgumentNullException("provider"); } XmlReader reader = manager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader; if (reader != null) { string name = this.typeName.Trim(); string prefix = string.Empty; int index = name.IndexOf(':'); if (index >= 0) { prefix = name.Substring(0, index); name = name.Substring(index + 1); this.type = manager.GetType(new XmlQualifiedName(name, reader.LookupNamespace(prefix))); if (this.type != null) { return(this.type); } List <WorkflowMarkupSerializerMapping> list = null; if ((manager.XmlNamespaceBasedMappings.TryGetValue(reader.LookupNamespace(prefix), out list) && (list != null)) && (list.Count > 0)) { return(list[0].ClrNamespace + "." + name); } return(name); } this.type = manager.GetType(new XmlQualifiedName(name, reader.LookupNamespace(string.Empty))); if (this.type == null) { ITypeProvider service = provider.GetService(typeof(ITypeProvider)) as ITypeProvider; if (service != null) { this.type = service.GetType(name); } if ((this.type == null) && (manager.GetService(typeof(ITypeResolutionService)) == null)) { this.type = manager.SerializationManager.GetType(name); } } if (this.type != null) { return(this.type); } } return(this.typeName); }
public override object ProvideValue(IServiceProvider provider) { if (this.type != null) { return(this.type); } if (provider == null) { throw new ArgumentNullException("provider"); } if (this.typeName == null) { throw new InvalidOperationException("typename"); } WorkflowMarkupSerializationManager manager = provider as WorkflowMarkupSerializationManager; if (manager == null) { throw new ArgumentNullException("provider"); } XmlReader reader = manager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader; if (reader == null) { Debug.Assert(false); return(this.typeName); } string typename = this.typeName.Trim(); string prefix = String.Empty; int typeIndex = typename.IndexOf(':'); if (typeIndex >= 0) { prefix = typename.Substring(0, typeIndex); typename = typename.Substring(typeIndex + 1); type = manager.GetType(new XmlQualifiedName(typename, reader.LookupNamespace(prefix))); if (type != null) { return(type); } // To Support types whose assembly is not available, we need to still resolve the clr namespace List <WorkflowMarkupSerializerMapping> xmlnsMappings = null; if (manager.XmlNamespaceBasedMappings.TryGetValue(reader.LookupNamespace(prefix), out xmlnsMappings) && xmlnsMappings != null && xmlnsMappings.Count > 0) { return(xmlnsMappings[0].ClrNamespace + "." + typename); } else { return(typename); } } type = manager.GetType(new XmlQualifiedName(typename, reader.LookupNamespace(string.Empty))); // To Support Beta2 format if (type == null) { ITypeProvider typeProvider = provider.GetService(typeof(ITypeProvider)) as ITypeProvider; if (typeProvider != null) { type = typeProvider.GetType(typename); } // If not design mode, get the value from serialization manager // At design time, we need to get the type from ITypeProvider else // we need to store the string in the hashtable we maintain internally if (type == null && manager.GetService(typeof(ITypeResolutionService)) == null) { type = manager.SerializationManager.GetType(typename); } } if (type != null) { return(type); } return(this.typeName); }
// 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 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; }
private object InternalDeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value) { if (serializationManager == null) throw new ArgumentNullException("serializationManager"); if (propertyType == null) throw new ArgumentNullException("propertyType"); if (value == null) throw new ArgumentNullException("value"); object propVal = null; XmlReader reader = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader; if (reader == null) { Debug.Assert(false, "XmlReader not available."); return null; } if (IsValidCompactAttributeFormat(value)) { propVal = DeserializeFromCompactFormat(serializationManager, reader, value); } else { if (value.StartsWith("{}", StringComparison.Ordinal)) value = value.Substring(2); // Check for Nullable types if (propertyType.IsGenericType && propertyType.GetGenericTypeDefinition() == typeof(Nullable<>)) { Type genericType = (Type)propertyType.GetGenericArguments()[0]; Debug.Assert(genericType != null); propertyType = genericType; } if (propertyType.IsPrimitive || propertyType == typeof(System.String)) { propVal = Convert.ChangeType(value, propertyType, CultureInfo.InvariantCulture); } else if (propertyType.IsEnum) { propVal = Enum.Parse(propertyType, value, true); } else if (typeof(Delegate).IsAssignableFrom(propertyType)) { // Just return the method name. This must happen after Bind syntax has been checked. propVal = value; } else if (typeof(TimeSpan) == propertyType) { propVal = TimeSpan.Parse(value, CultureInfo.InvariantCulture); } else if (typeof(DateTime) == propertyType) { propVal = DateTime.Parse(value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind); } else if (typeof(Guid) == propertyType) { propVal = Utility.CreateGuid(value); } else if (typeof(Type).IsAssignableFrom(propertyType)) { propVal = serializationManager.GetType(value); if (propVal != null) { Type type = propVal as Type; if (type.IsPrimitive || type.IsEnum || type == typeof(System.String)) return type; } ITypeProvider typeProvider = serializationManager.GetService(typeof(ITypeProvider)) as ITypeProvider; if (typeProvider != null) { Type type = typeProvider.GetType(value); if (type != null) return type; } return value; } else if (typeof(IConvertible).IsAssignableFrom(propertyType)) { propVal = Convert.ChangeType(value, propertyType, CultureInfo.InvariantCulture); } else if (propertyType.IsAssignableFrom(value.GetType())) { propVal = value; } else { throw CreateSerializationError(SR.GetString(SR.Error_SerializerPrimitivePropertyNoLogic, new object[] { "", value.Trim(), "" }), reader); } } return propVal; }
protected internal override object DeserializeFromString(WorkflowMarkupSerializationManager serializationManager, Type propertyType, string value) { if (!propertyType.IsAssignableFrom(typeof(CodeTypeReference))) return null; // if the string is empty or markup extension, // then the object is null if (string.IsNullOrEmpty(value) || IsValidCompactAttributeFormat(value)) return null; // value is the fully qualified name of the type // however, it may refer to non-existant assemblies, so we may get an error CodeTypeReference result; try { Type type = serializationManager.GetType(value); if (type != null) { result = new CodeTypeReference(type); result.UserData[QualifiedName] = type.AssemblyQualifiedName; return result; } } catch (Exception) { // something went wrong getting the type, so simply pass in the string and // let CodeTypeReference figure it out. Note that CodeTypeReference has a method // RipOffAssemblyInformationFromTypeName, so assembly names are ignored. } result = new CodeTypeReference(value); result.UserData[QualifiedName] = value; return result; }