internal override void OnBeforeSerializeContents(WorkflowMarkupSerializationManager serializationManager, object obj)
{
base.OnBeforeSerializeContents(serializationManager, obj);
serializationManager.ExtendedPropertiesProviders.Add(this);
this.keylookupDictionary = new Hashtable();
}
protected internal override object DeserializeFromString(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");
}
// Work around For Bind based properties whose base type is an
// ICollection<string> or its derivative, special case! (A synchronization
// handle cannot begin with a * because it won't be a language independent
// identifier :) )
if (IsValidCompactAttributeFormat(value))
{
return(DeserializeFromCompactFormat(serializationManager, serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader, value));
}
else
{
return(SynchronizationHandlesTypeConverter.UnStringify(value));
}
}
protected override void OnAfterSerialize(WorkflowMarkupSerializationManager serializationManager, object obj)
{
base.OnAfterSerialize(serializationManager, obj);
serializationManager.ExtendedPropertiesProviders.Remove(this);
this.keylookupDictionary = null;
}
protected virtual InstanceDescriptor GetInstanceDescriptor(WorkflowMarkupSerializationManager serializationManager, object value)
{
MarkupExtension markupExtension = value as MarkupExtension;
if (markupExtension == null)
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(MarkupExtension).FullName), "value");
return new InstanceDescriptor(markupExtension.GetType().GetConstructor(new Type[0]), null);
}
public XmlQualifiedName GetXmlQualifiedName(WorkflowMarkupSerializationManager manager, out string prefix)
{
prefix = String.Empty;
if (OnGetXmlQualifiedName != null)
{
return(OnGetXmlQualifiedName(this, manager, out prefix));
}
else
{
return(null);
}
}
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;
// 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);
}
private static string GetAssemblyName(Type type, WorkflowMarkupSerializationManager manager)
{
//
// Handle DesignTimeType
if (type.Assembly == null)
{
return(string.Empty);
}
else
{
return(type.Assembly.FullName);
}
}
protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
{
if (serializationManager == null)
{
throw new ArgumentNullException("serializationManager");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
return(value is ICollection <String>);
}
protected internal override string SerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
{
if (serializationManager == null)
{
throw new ArgumentNullException("serializationManager");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
return(SynchronizationHandlesTypeConverter.Stringify(value as ICollection <String>));
}
protected internal override bool ShouldSerializeValue(WorkflowMarkupSerializationManager serializationManager, object value)
{
if (value == null)
{
return(false);
}
if (!(value is IDictionary))
{
throw new InvalidOperationException(SR.GetString(SR.Error_DictionarySerializerNonDictionaryObject));
}
return(((IDictionary)value).Count > 0);
}
protected internal override void AddChild(WorkflowMarkupSerializationManager serializationManager, object parentObj, object childObj)
{
if (parentObj == null)
{
throw new ArgumentNullException("parentObj");
}
if (!IsValidCollectionType(parentObj.GetType()))
{
throw new Exception(SR.GetString(SR.Error_SerializerTypeRequirement, parentObj.GetType().FullName, typeof(ICollection).FullName, typeof(ICollection <>).FullName));
}
parentObj.GetType().InvokeMember("Add", BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Instance, null, parentObj, new object[] { childObj }, CultureInfo.InvariantCulture);
}
protected internal override void ClearChildren(WorkflowMarkupSerializationManager serializationManager, object deserializedObject)
{
if (deserializedObject == null)
{
throw new ArgumentNullException("deserializedObject");
}
IDictionary dictionary = deserializedObject as IDictionary;
if (dictionary == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_DictionarySerializerNonDictionaryObject));
}
dictionary.Clear();
}
protected override InstanceDescriptor GetInstanceDescriptor(WorkflowMarkupSerializationManager serializationManager, object value)
{
TypeExtension typeExtension = value as TypeExtension;
if (typeExtension == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(TypeExtension).FullName), "value");
}
if (typeExtension.Type != null)
{
return(new InstanceDescriptor(typeof(TypeExtension).GetConstructor(new Type[] { typeof(System.Type) }),
new object[] { typeExtension.Type }));
}
return(new InstanceDescriptor(typeof(TypeExtension).GetConstructor(new Type[] { typeof(string) }),
new object[] { typeExtension.TypeName }));
}
protected internal override IList GetChildren(WorkflowMarkupSerializationManager serializationManager, object obj)
{
IDictionary dictionary = obj as IDictionary;
if (dictionary == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_DictionarySerializerNonDictionaryObject));
}
List <object> childEntries = new List <object>();
foreach (DictionaryEntry dictionaryEntry in dictionary)
{
childEntries.Add(dictionaryEntry);
}
return(childEntries);
}
protected internal override void ClearChildren(WorkflowMarkupSerializationManager serializationManager, object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (!IsValidCollectionType(obj.GetType()))
{
throw new Exception(SR.GetString(SR.Error_SerializerTypeRequirement, obj.GetType().FullName, typeof(ICollection).FullName, typeof(ICollection <>).FullName));
}
ICollection collection = obj as ICollection;
if (collection == null)
{
obj.GetType().InvokeMember("Clear", BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Instance, null, obj, new object[] { }, CultureInfo.InvariantCulture);
}
}
protected internal override bool ShouldSerializeValue(WorkflowMarkupSerializationManager serializationManager, object value)
{
if (value == null)
{
return(false);
}
if (!IsValidCollectionType(value.GetType()))
{
throw new Exception(SR.GetString(SR.Error_SerializerTypeRequirement, value.GetType().FullName, typeof(ICollection).FullName, typeof(ICollection <>).FullName));
}
IEnumerable enumerable = value as IEnumerable;
foreach (object obj in enumerable)
{
return(true);
}
return(false);
}
internal override ExtendedPropertyInfo[] GetExtendedProperties(WorkflowMarkupSerializationManager manager, object extendee)
{
List <ExtendedPropertyInfo> extendedProperties = new List <ExtendedPropertyInfo>();
DictionaryEntry? entry = null;
if (manager.WorkflowMarkupStack[typeof(DictionaryEntry)] != null)
{
entry = (DictionaryEntry)manager.WorkflowMarkupStack[typeof(DictionaryEntry)];
}
if (this.deserializingDictionary || (entry.HasValue && entry.Value.Value == extendee))
{
ExtendedPropertyInfo extendedProperty =
new ExtendedPropertyInfo(typeof(DictionaryEntry).GetProperty("Key", BindingFlags.Public | BindingFlags.Instance),
new GetValueHandler(OnGetKeyValue),
new SetValueHandler(OnSetKeyValue),
new GetQualifiedNameHandler(OnGetXmlQualifiedName), manager);
extendedProperties.Add(extendedProperty);
}
return(extendedProperties.ToArray());
}
internal static bool IsExtendedProperty(WorkflowMarkupSerializationManager manager, IList <PropertyInfo> propInfos, XmlQualifiedName xmlQualifiedName)
{
foreach (PropertyInfo propInfo in propInfos)
{
ExtendedPropertyInfo extendedProperty = propInfo as ExtendedPropertyInfo;
if (extendedProperty == null)
{
continue;
}
string prefix = String.Empty;
XmlQualifiedName qualifiedPropertyName = extendedProperty.GetXmlQualifiedName(manager, out prefix);
if (qualifiedPropertyName.Name.Equals(xmlQualifiedName.Name, StringComparison.Ordinal) &&
qualifiedPropertyName.Namespace.Equals(xmlQualifiedName.Namespace, StringComparison.Ordinal))
{
return(true);
}
}
return(false);
}
internal static bool IsExtendedProperty(WorkflowMarkupSerializationManager manager, XmlQualifiedName xmlQualifiedName)
{
bool isExtendedProperty = false;
object extendee = manager.Context.Current;
if (extendee != null)
{
foreach (ExtendedPropertyInfo extendedProperty in manager.GetExtendedProperties(extendee))
{
string prefix = String.Empty;
XmlQualifiedName qualifiedPropertyName = extendedProperty.GetXmlQualifiedName(manager, out prefix);
if (qualifiedPropertyName.Name.Equals(xmlQualifiedName.Name, StringComparison.Ordinal) &&
qualifiedPropertyName.Namespace.Equals(xmlQualifiedName.Namespace, StringComparison.Ordinal))
{
isExtendedProperty = true;
break;
}
}
}
return(isExtendedProperty);
}
protected internal override void AddChild(WorkflowMarkupSerializationManager serializationManager, object parentObj, object childObj)
{
if (parentObj == null)
{
throw new ArgumentNullException("parentObj");
}
if (childObj == null)
{
throw new ArgumentNullException("childObj");
}
IDictionary dictionary = parentObj as IDictionary;
if (dictionary == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_DictionarySerializerNonDictionaryObject));
}
object key = null;
foreach (DictionaryEntry entry in keylookupDictionary)
{
if ((!entry.Value.GetType().IsValueType&& entry.Value == childObj) ||
(entry.Value.GetType().IsValueType&& entry.Value.Equals(childObj)))
{
key = entry.Key;
break;
}
}
if (key == null)
{
throw new InvalidOperationException(SR.GetString(SR.Error_DictionarySerializerKeyNotFound, childObj.GetType().FullName));
}
dictionary.Add(key, childObj);
keylookupDictionary.Remove(key);
}
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);
}
protected internal override IList GetChildren(WorkflowMarkupSerializationManager serializationManager, object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
if (!IsValidCollectionType(obj.GetType()))
{
throw new Exception(SR.GetString(SR.Error_SerializerTypeRequirement, obj.GetType().FullName, typeof(ICollection).FullName, typeof(ICollection <>).FullName));
}
IEnumerable enumerable = obj as IEnumerable;
ArrayList arrayList = new ArrayList();
foreach (object containedObj in enumerable)
{
arrayList.Add(containedObj);
}
return(arrayList);
}
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.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);
}
internal static void GetMappingFromType(WorkflowMarkupSerializationManager manager, Type type, out WorkflowMarkupSerializerMapping matchingMapping, out IList <WorkflowMarkupSerializerMapping> collectedMappings)
{
matchingMapping = null;
collectedMappings = new List <WorkflowMarkupSerializerMapping>();
string clrNamespace = type.Namespace ?? String.Empty;
string xmlNamespace = String.Empty;
string assemblyName = String.Empty;
string prefix = String.Empty;
assemblyName = GetAssemblyName(type, manager);
if (type.Assembly.FullName.Equals(AssemblyRef.ActivitiesAssemblyRef, StringComparison.Ordinal))
{
xmlNamespace = StandardXomlKeys.WorkflowXmlNs;
prefix = StandardXomlKeys.WorkflowPrefix;
}
else if (type.Assembly.FullName.Equals(AssemblyRef.DialogAssemblyRef, StringComparison.Ordinal))
{
xmlNamespace = StandardXomlKeys.WorkflowXmlNs;
prefix = StandardXomlKeys.WorkflowPrefix;
}
else if (type.Assembly == Assembly.GetExecutingAssembly())
{
xmlNamespace = StandardXomlKeys.WorkflowXmlNs;
prefix = StandardXomlKeys.WorkflowPrefix;
}
if (xmlNamespace.Length == 0)
{
//First lookup the type's assembly for XmlNsDefinitionAttribute
object[] xmlnsDefinitions = type.Assembly.GetCustomAttributes(typeof(XmlnsDefinitionAttribute), true);
foreach (XmlnsDefinitionAttribute xmlnsDefinition in xmlnsDefinitions)
{
xmlNamespace = xmlnsDefinition.XmlNamespace;
assemblyName = xmlnsDefinition.AssemblyName;
if (type.Assembly == manager.LocalAssembly)
{
assemblyName = String.Empty;
}
else if (String.IsNullOrEmpty(assemblyName))
{
assemblyName = GetAssemblyName(type, manager);
}
if (String.IsNullOrEmpty(xmlNamespace))
{
xmlNamespace = GetFormatedXmlNamespace(clrNamespace, assemblyName);
}
prefix = GetPrefix(manager, type.Assembly, xmlNamespace);
WorkflowMarkupSerializerMapping mapping = new WorkflowMarkupSerializerMapping(prefix, xmlNamespace, clrNamespace, assemblyName, type.Assembly.FullName);
if (xmlnsDefinition.ClrNamespace.Equals(clrNamespace, StringComparison.Ordinal) && matchingMapping == null)
{
matchingMapping = mapping;
}
else
{
collectedMappings.Add(mapping);
}
}
}
if (matchingMapping == null)
{
if (type.Assembly == manager.LocalAssembly)
{
assemblyName = String.Empty;
}
else if (String.IsNullOrEmpty(assemblyName))
{
assemblyName = GetAssemblyName(type, manager);
}
xmlNamespace = GetFormatedXmlNamespace(clrNamespace, assemblyName);
if (String.IsNullOrEmpty(prefix))
{
prefix = GetPrefix(manager, type.Assembly, xmlNamespace);
}
matchingMapping = new WorkflowMarkupSerializerMapping(prefix, xmlNamespace, clrNamespace, assemblyName, type.Assembly.FullName);
}
}
internal static void GetMappingsFromXmlNamespace(WorkflowMarkupSerializationManager serializationManager, string xmlNamespace, out IList <WorkflowMarkupSerializerMapping> matchingMappings, out IList <WorkflowMarkupSerializerMapping> collectedMappings)
{
matchingMappings = new List <WorkflowMarkupSerializerMapping>();
collectedMappings = new List <WorkflowMarkupSerializerMapping>();
if (serializationManager.WorkflowMarkupStack[typeof(XmlReader)] is XmlReader reader)
{
if (xmlNamespace.StartsWith(StandardXomlKeys.CLRNamespaceQualifier, StringComparison.OrdinalIgnoreCase))
{
//Format for the xmlnamespace: clr-namespace:[Namespace][;Assembly=[AssemblyName]]
bool invalidXmlnsFormat = false;
string clrNamespace = xmlNamespace.Substring(StandardXomlKeys.CLRNamespaceQualifier.Length).Trim();
string assemblyName = String.Empty;
int index = clrNamespace.IndexOf(';');
if (index != -1)
{
assemblyName = (index + 1 < clrNamespace.Length) ? clrNamespace.Substring(index + 1).Trim() : String.Empty;
clrNamespace = clrNamespace.Substring(0, index).Trim();
if (!assemblyName.StartsWith(StandardXomlKeys.AssemblyNameQualifier, StringComparison.OrdinalIgnoreCase))
{
invalidXmlnsFormat = true;
}
assemblyName = assemblyName.Substring(StandardXomlKeys.AssemblyNameQualifier.Length);
}
if (!invalidXmlnsFormat)
{
if (clrNamespace.Equals(StandardXomlKeys.GlobalNamespace, StringComparison.OrdinalIgnoreCase))
{
clrNamespace = String.Empty;
}
matchingMappings.Add(new WorkflowMarkupSerializerMapping(reader.Prefix, xmlNamespace, clrNamespace, assemblyName));
}
}
else
{
List <Assembly> referencedAssemblies = new List <Assembly>();
if (serializationManager.LocalAssembly != null)
{
referencedAssemblies.Add(serializationManager.LocalAssembly);
}
foreach (Assembly assembly in referencedAssemblies)
{
object[] xmlnsDefinitions = assembly.GetCustomAttributes(typeof(XmlnsDefinitionAttribute), true);
if (xmlnsDefinitions != null)
{
foreach (XmlnsDefinitionAttribute xmlnsDefinition in xmlnsDefinitions)
{
string assemblyName = String.Empty;
if (serializationManager.LocalAssembly != assembly)
{
if (xmlnsDefinition.AssemblyName != null && xmlnsDefinition.AssemblyName.Trim().Length > 0)
{
assemblyName = xmlnsDefinition.AssemblyName;
}
else
{
assemblyName = assembly.FullName;
}
}
if (xmlnsDefinition.XmlNamespace.Equals(xmlNamespace, StringComparison.Ordinal))
{
matchingMappings.Add(new WorkflowMarkupSerializerMapping(reader.Prefix, xmlNamespace, xmlnsDefinition.ClrNamespace, assemblyName));
}
else
{
collectedMappings.Add(new WorkflowMarkupSerializerMapping(reader.Prefix, xmlNamespace, xmlnsDefinition.ClrNamespace, assemblyName));
}
}
}
}
}
}
}
protected internal override bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
{
return(value is CodeTypeReference);
}
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
if (manager.XmlNamespaceBasedMappings.TryGetValue(reader.LookupNamespace(prefix), out List <WorkflowMarkupSerializerMapping> 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)
{
// 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);
}
internal ExtendedPropertyInfo(PropertyInfo propertyInfo, GetValueHandler getValueHandler, SetValueHandler setValueHandler, GetQualifiedNameHandler qualifiedNameHandler, WorkflowMarkupSerializationManager manager)
: this(propertyInfo, getValueHandler, setValueHandler, qualifiedNameHandler)
{
this.manager = manager;
}
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 bool CanSerializeToString(WorkflowMarkupSerializationManager serializationManager, object value)
{
return true;
}