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;
}
}
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;
}
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
{
ResourceManager manager = new ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(ActivityBind).Assembly);
if (reader.NodeType == XmlNodeType.Attribute)
{
string str;
if (((str = reader.LocalName) != null) && (str == "Class"))
{
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
}
else
{
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
}
}
else
{
bool flag = false;
bool isEmptyElement = reader.IsEmptyElement;
int depth = reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
string localName = reader.LocalName;
if (localName != null)
{
if (localName == "Code")
{
if (isEmptyElement)
{
flag = true;
}
break;
}
bool flag1 = localName == "Constructor";
}
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
return;
}
case XmlNodeType.Text:
case XmlNodeType.CDATA:
{
int num2 = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1;
int num3 = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1;
CodeSnippetTypeMember member = new CodeSnippetTypeMember(reader.Value)
{
LinePragma = new CodeLinePragma(fileName, Math.Max(num2 - 1, 1))
};
member.UserData[UserDataKeys.CodeSegment_New] = newSegment;
member.UserData[UserDataKeys.CodeSegment_ColumnNumber] = (num3 + reader.Name.Length) - 1;
CodeTypeMemberCollection members = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (members == null)
{
members = new CodeTypeMemberCollection();
activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, members);
}
members.Add(member);
break;
}
case XmlNodeType.EndElement:
if (reader.Depth == depth)
{
flag = true;
}
break;
}
}while (!flag && reader.Read());
}
}
internal object DeserializeObject(WorkflowMarkupSerializationManager serializationManager, XmlReader reader)
{
if (serializationManager == null)
throw new ArgumentNullException("serializationManager");
if (reader == null)
throw new ArgumentNullException("reader");
object obj = null;
try
{
serializationManager.WorkflowMarkupStack.Push(reader);
AdvanceReader(reader);
if (reader.NodeType != XmlNodeType.Element)
{
serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidDataFound), reader));
}
else
{
// Lets ignore the Definition tags if nobody is interested
//
string decodedName = XmlConvert.DecodeName(reader.LocalName);
XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(decodedName, reader.LookupNamespace(reader.Prefix));
if (xmlQualifiedName.Namespace.Equals(StandardXomlKeys.Definitions_XmlNs, StringComparison.Ordinal) &&
!IsMarkupExtension(xmlQualifiedName) &&
!ExtendedPropertyInfo.IsExtendedProperty(serializationManager, xmlQualifiedName))
{
int initialDepth = reader.Depth;
serializationManager.FireFoundDefTag(new WorkflowMarkupElementEventArgs(reader));
if ((initialDepth + 1) < reader.Depth)
{
while (reader.Read() && (initialDepth + 1) < reader.Depth);
}
}
else
{
obj = CreateInstance(serializationManager, xmlQualifiedName, reader);
reader.MoveToElement();
if (obj != null)
{
serializationManager.Context.Push(obj);
try
{
DeserializeContents(serializationManager, obj, reader);
}
finally
{
Debug.Assert(serializationManager.Context.Current == obj, "Serializer did not remove an object it pushed into stack.");
serializationManager.Context.Pop();
}
}
}
}
}
finally
{
serializationManager.WorkflowMarkupStack.Pop();
}
return obj;
}
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 IDictionary<DependencyProperty, object> GetDependencyProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
{
if (serializationManager == null)
throw new ArgumentNullException("serializationManager");
if (obj == null)
throw new ArgumentNullException("obj");
List<PropertyInfo> pis = new List<PropertyInfo>();
pis.AddRange(GetProperties(serializationManager, obj));
List<EventInfo> eis = new List<EventInfo>();
eis.AddRange(GetEvents(serializationManager, obj));
Dictionary<DependencyProperty, object> dependencyProperties = new Dictionary<DependencyProperty, object>();
DependencyObject dependencyObject = obj as DependencyObject;
if (dependencyObject != null)
{
foreach (DependencyProperty dependencyProperty in dependencyObject.MetaDependencyProperties)
{
Attribute[] visibilityAttrs = dependencyProperty.DefaultMetadata.GetAttributes(typeof(DesignerSerializationVisibilityAttribute));
if (visibilityAttrs.Length > 0 && ((DesignerSerializationVisibilityAttribute)visibilityAttrs[0]).Visibility == DesignerSerializationVisibility.Hidden)
continue;
//If the dependency property is readonly and we have not marked it with DesignerSerializationVisibility.Content attribute the we should not
//serialize it
if ((dependencyProperty.DefaultMetadata.Options & DependencyPropertyOptions.ReadOnly) == DependencyPropertyOptions.ReadOnly)
{
object[] serializationVisibilityAttribute = dependencyProperty.DefaultMetadata.GetAttributes(typeof(DesignerSerializationVisibilityAttribute));
if (serializationVisibilityAttribute == null ||
serializationVisibilityAttribute.Length == 0 ||
((DesignerSerializationVisibilityAttribute)serializationVisibilityAttribute[0]).Visibility != DesignerSerializationVisibility.Content)
{
continue;
}
}
object obj1 = null;
if (!dependencyProperty.IsAttached && !dependencyProperty.DefaultMetadata.IsMetaProperty)
{
if (dependencyProperty.IsEvent)
obj1 = LookupEvent(eis, dependencyProperty.Name);
else
obj1 = LookupProperty(pis, dependencyProperty.Name);
if (obj1 == null)
{
serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_MissingCLRProperty, dependencyProperty.Name, obj.GetType().FullName)));
continue;
}
}
if (dependencyObject.IsBindingSet(dependencyProperty))
{
dependencyProperties.Add(dependencyProperty, dependencyObject.GetBinding(dependencyProperty));
}
else if (!dependencyProperty.IsEvent)
{
object propValue = null;
propValue = dependencyObject.GetValue(dependencyProperty);
if (!dependencyProperty.IsAttached && !dependencyProperty.DefaultMetadata.IsMetaProperty)
{
PropertyInfo propertyInfo = obj1 as PropertyInfo;
// if the propertyValue is assignable to the type in of the .net property then call the .net property's getter also
// else add the keep the value that we got
if (propValue != null && propertyInfo.PropertyType.IsAssignableFrom(propValue.GetType()))
propValue = (obj1 as PropertyInfo).GetValue(dependencyObject, null);
}
dependencyProperties.Add(dependencyProperty, propValue);
}
else
{
dependencyProperties.Add(dependencyProperty, dependencyObject.GetHandler(dependencyProperty));
}
}
foreach (DependencyProperty dependencyProperty in dependencyObject.DependencyPropertyValues.Keys)
{
Attribute[] visibilityAttrs = dependencyProperty.DefaultMetadata.GetAttributes(typeof(DesignerSerializationVisibilityAttribute));
if (visibilityAttrs.Length > 0 && ((DesignerSerializationVisibilityAttribute)visibilityAttrs[0]).Visibility == DesignerSerializationVisibility.Hidden)
continue;
if (!dependencyProperty.DefaultMetadata.IsMetaProperty && dependencyProperty.IsAttached && VerifyAttachedPropertyConditions(dependencyProperty))
dependencyProperties.Add(dependencyProperty, dependencyObject.GetValue(dependencyProperty));
}
}
return dependencyProperties;
}
private void SetDependencyPropertyValue(WorkflowMarkupSerializationManager serializationManager, object obj, DependencyProperty dependencyProperty, object value)
{
if (dependencyProperty == null)
throw new ArgumentNullException("dependencyProperty");
if (obj == null)
throw new ArgumentNullException("obj");
DependencyObject dependencyObject = obj as DependencyObject;
if (dependencyObject == null)
throw new ArgumentException(SR.GetString(SR.Error_InvalidArgumentValue), "obj");
if (dependencyProperty.IsEvent)
{
if (value is ActivityBind)
dependencyObject.SetBinding(dependencyProperty, value as ActivityBind);
else if (dependencyProperty.IsAttached)
{
MethodInfo methodInfo = dependencyProperty.OwnerType.GetMethod("Add" + dependencyProperty.Name + "Handler", BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
if (methodInfo != null)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters == null || parameters.Length != 2 || parameters[0].ParameterType != typeof(object) || parameters[1].ParameterType != typeof(object))
methodInfo = null;
}
if (methodInfo != null)
WorkflowMarkupSerializationHelpers.SetEventHandlerName(dependencyObject, dependencyProperty.Name, value as string);
else
serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_MissingAddHandler, dependencyProperty.Name, dependencyProperty.OwnerType.FullName)));
}
else
WorkflowMarkupSerializationHelpers.SetEventHandlerName(dependencyObject, dependencyProperty.Name, value as string);
}
else
{
if (value is ActivityBind)
dependencyObject.SetBinding(dependencyProperty, value as ActivityBind);
else if (value is string && TypeProvider.IsAssignable(typeof(Type), dependencyProperty.PropertyType))
Helpers.SetDesignTimeTypeName(obj, dependencyProperty, value as string);
else if (dependencyProperty.IsAttached)
{
MethodInfo methodInfo = dependencyProperty.OwnerType.GetMethod("Set" + dependencyProperty.Name, BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
if (methodInfo != null)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters == null || parameters.Length != 2 || parameters[0].ParameterType != typeof(object) || parameters[1].ParameterType != typeof(object))
methodInfo = null;
}
if (methodInfo != null)
methodInfo.Invoke(null, new object[] { dependencyObject, value });
else
serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_MissingSetAccessor, dependencyProperty.Name, dependencyProperty.OwnerType.FullName)));
}
else
{
List<PropertyInfo> pis = new List<PropertyInfo>();
pis.AddRange(GetProperties(serializationManager, obj));
//The following condition is workaround for the partner team as they depend on the dependencyObject.SetValue being called
//for non assignable property values
PropertyInfo pi = LookupProperty(pis, dependencyProperty.Name);
if (pi != null &&
(value == null || pi.PropertyType.IsAssignableFrom(value.GetType())))
{
if (pi.CanWrite)
{
pi.SetValue(obj, value, null);
}
else if (typeof(ICollection<string>).IsAssignableFrom(value.GetType()))
{
ICollection<string> propVal = pi.GetValue(obj, null) as ICollection<string>;
ICollection<string> deserializedValue = value as ICollection<string>;
if (propVal != null && deserializedValue != null)
{
foreach (string content in deserializedValue)
propVal.Add(content);
}
}
}
else
{
dependencyObject.SetValue(dependencyProperty, value);
}
}
}
}
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
{
if (serializationManager == null)
throw new ArgumentNullException("serializationManager");
if (type == null)
throw new ArgumentNullException("type");
object designer = null;
IDesignerHost host = serializationManager.GetService(typeof(IDesignerHost)) as IDesignerHost;
XmlReader reader = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader;
if (host != null && reader != null)
{
//Find the associated activity
string associatedActivityName = String.Empty;
while (reader.MoveToNextAttribute() && !reader.LocalName.Equals("Name", StringComparison.Ordinal));
if (reader.LocalName.Equals("Name", StringComparison.Ordinal) && reader.ReadAttributeValue())
associatedActivityName = reader.Value;
reader.MoveToElement();
if (!String.IsNullOrEmpty(associatedActivityName))
{
CompositeActivityDesigner parentDesigner = serializationManager.Context[typeof(CompositeActivityDesigner)] as CompositeActivityDesigner;
if (parentDesigner == null)
{
Activity activity = host.RootComponent as Activity;
if (activity != null && !associatedActivityName.Equals(activity.Name, StringComparison.Ordinal))
{
foreach (IComponent component in host.Container.Components)
{
activity = component as Activity;
if (activity != null && associatedActivityName.Equals(activity.Name, StringComparison.Ordinal))
break;
}
}
if (activity != null)
designer = host.GetDesigner(activity);
}
else
{
CompositeActivity compositeActivity = parentDesigner.Activity as CompositeActivity;
if (compositeActivity != null)
{
Activity matchingActivity = null;
foreach (Activity activity in compositeActivity.Activities)
{
if (associatedActivityName.Equals(activity.Name, StringComparison.Ordinal))
{
matchingActivity = activity;
break;
}
}
if (matchingActivity != null)
designer = host.GetDesigner(matchingActivity);
}
}
if (designer == null)
serializationManager.ReportError(SR.GetString(SR.Error_LayoutSerializationActivityNotFound, reader.LocalName, associatedActivityName, "Name"));
}
else
{
serializationManager.ReportError(SR.GetString(SR.Error_LayoutSerializationAssociatedActivityNotFound, reader.LocalName, "Name"));
}
}
return designer;
}
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;
}
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
{
System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(System.Workflow.ComponentModel.ActivityBind).Assembly);
if (reader.NodeType == XmlNodeType.Attribute)
{
switch (reader.LocalName)
{
case StandardXomlKeys.Definitions_Class_LocalName:
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
break;
default:
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, resourceManager.GetString("UnknownDefinitionTag"), new object[] { StandardXomlKeys.Definitions_XmlNs_Prefix, reader.LocalName, StandardXomlKeys.Definitions_XmlNs }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
break;
}
return;
}
bool exitLoop = false;
bool isEmptyElement = reader.IsEmptyElement;
int initialDepth = reader.Depth;
do
{
XmlNodeType currNodeType = reader.NodeType;
switch (currNodeType)
{
case XmlNodeType.Element:
{
/*
if (!reader.LocalName.Equals(localName))
{
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(resourceManager.GetString("DefnTagsCannotBeNested"), "def", localName, reader.LocalName), reader.LineNumber, reader.LinePosition));
return;
}
*/
switch (reader.LocalName)
{
case StandardXomlKeys.Definitions_Code_LocalName:
break;
case "Constructor":
default:
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, resourceManager.GetString("UnknownDefinitionTag"), StandardXomlKeys.Definitions_XmlNs_Prefix, reader.LocalName, StandardXomlKeys.Definitions_XmlNs), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
return;
}
// if an empty element do a Reader then exit
if (isEmptyElement)
exitLoop = true;
break;
}
case XmlNodeType.EndElement:
{
//reader.Read();
if (reader.Depth == initialDepth)
exitLoop = true;
break;
}
case XmlNodeType.CDATA:
case XmlNodeType.Text:
{
//
int lineNumber = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1;
int linePosition = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1;
CodeSnippetTypeMember codeSegment = new CodeSnippetTypeMember(reader.Value);
codeSegment.LinePragma = new CodeLinePragma(fileName, Math.Max(lineNumber - 1, 1));
codeSegment.UserData[UserDataKeys.CodeSegment_New] = newSegment;
codeSegment.UserData[UserDataKeys.CodeSegment_ColumnNumber] = linePosition + reader.Name.Length - 1;
CodeTypeMemberCollection codeSegments = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (codeSegments == null)
{
codeSegments = new CodeTypeMemberCollection();
activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, codeSegments);
}
codeSegments.Add(codeSegment);
//}
/*else
{
serializationManager.ReportError( new WorkflowMarkupSerializationException(
string.Format(resourceManager.GetString("IllegalCDataTextScoping"),
"def",
reader.LocalName,
(currNodeType == XmlNodeType.CDATA ? resourceManager.GetString("CDATASection") : resourceManager.GetString("TextSection"))),
reader.LineNumber,
reader.LinePosition)
);
}
*/
break;
}
}
}
while (!exitLoop && reader.Read());
}
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
{
ResourceManager manager = new ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(ActivityBind).Assembly);
if (reader.NodeType == XmlNodeType.Attribute)
{
string str;
if (((str = reader.LocalName) != null) && (str == "Class"))
{
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
}
else
{
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1));
}
}
else
{
bool flag = false;
bool isEmptyElement = reader.IsEmptyElement;
int depth = reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
{
string localName = reader.LocalName;
if (localName != null)
{
if (localName == "Code")
{
if (isEmptyElement)
{
flag = true;
}
break;
}
bool flag1 = localName == "Constructor";
}
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, manager.GetString("UnknownDefinitionTag"), new object[] { "x", reader.LocalName, "http://schemas.microsoft.com/winfx/2006/xaml" }), (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1));
return;
}
case XmlNodeType.Text:
case XmlNodeType.CDATA:
{
int num2 = (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LineNumber : 1;
int num3 = (reader is IXmlLineInfo) ? ((IXmlLineInfo) reader).LinePosition : 1;
CodeSnippetTypeMember member = new CodeSnippetTypeMember(reader.Value) {
LinePragma = new CodeLinePragma(fileName, Math.Max(num2 - 1, 1))
};
member.UserData[UserDataKeys.CodeSegment_New] = newSegment;
member.UserData[UserDataKeys.CodeSegment_ColumnNumber] = (num3 + reader.Name.Length) - 1;
CodeTypeMemberCollection members = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (members == null)
{
members = new CodeTypeMemberCollection();
activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, members);
}
members.Add(member);
break;
}
case XmlNodeType.EndElement:
if (reader.Depth == depth)
{
flag = true;
}
break;
}
}
while (!flag && reader.Read());
}
}
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);
}
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 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 PropertyInfo GetContentProperty(WorkflowMarkupSerializationManager serializationManager, object parentObject)
{
PropertyInfo contentProperty = null;
string contentPropertyName = String.Empty;
object[] contentPropertyAttributes = parentObject.GetType().GetCustomAttributes(typeof(ContentPropertyAttribute), true);
if (contentPropertyAttributes != null && contentPropertyAttributes.Length > 0)
contentPropertyName = ((ContentPropertyAttribute)contentPropertyAttributes[0]).Name;
if (!String.IsNullOrEmpty(contentPropertyName))
{
contentProperty = parentObject.GetType().GetProperty(contentPropertyName, BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.Public);
if (contentProperty == null)
serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_ContentPropertyCouldNotBeFound, contentPropertyName, parentObject.GetType().FullName)));
}
return contentProperty;
}
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 })));
}
}
}
}
}
}
}
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
{
Activity activity3;
if (serializationManager == null)
{
throw new ArgumentNullException("serializationManager");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
object obj2 = null;
IDesignerHost service = serializationManager.GetService(typeof(IDesignerHost)) as IDesignerHost;
XmlReader reader = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader;
if ((service == null) || (reader == null))
{
return obj2;
}
string str = string.Empty;
while (reader.MoveToNextAttribute() && !reader.LocalName.Equals("Name", StringComparison.Ordinal))
{
}
if (reader.LocalName.Equals("Name", StringComparison.Ordinal) && reader.ReadAttributeValue())
{
str = reader.Value;
}
reader.MoveToElement();
if (string.IsNullOrEmpty(str))
{
serializationManager.ReportError(SR.GetString("Error_LayoutSerializationAssociatedActivityNotFound", new object[] { reader.LocalName, "Name" }));
return obj2;
}
CompositeActivityDesigner designer = serializationManager.Context[typeof(CompositeActivityDesigner)] as CompositeActivityDesigner;
if (designer != null)
{
CompositeActivity activity2 = designer.Activity as CompositeActivity;
if (activity2 == null)
{
goto Label_01D0;
}
activity3 = null;
foreach (Activity activity4 in activity2.Activities)
{
if (str.Equals(activity4.Name, StringComparison.Ordinal))
{
activity3 = activity4;
break;
}
}
}
else
{
Activity rootComponent = service.RootComponent as Activity;
if ((rootComponent != null) && !str.Equals(rootComponent.Name, StringComparison.Ordinal))
{
foreach (IComponent component in service.Container.Components)
{
rootComponent = component as Activity;
if ((rootComponent != null) && str.Equals(rootComponent.Name, StringComparison.Ordinal))
{
break;
}
}
}
if (rootComponent != null)
{
obj2 = service.GetDesigner(rootComponent);
}
goto Label_01D0;
}
if (activity3 != null)
{
obj2 = service.GetDesigner(activity3);
}
Label_01D0:
if (obj2 == null)
{
serializationManager.ReportError(SR.GetString("Error_LayoutSerializationActivityNotFound", new object[] { reader.LocalName, str, "Name" }));
}
return obj2;
}
private void DeserializeSimpleProperty(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, object obj, string value)
{
Type propertyType = null;
bool isReadOnly = false;
DependencyProperty dependencyProperty = serializationManager.Context.Current as DependencyProperty;
PropertyInfo property = serializationManager.Context.Current as PropertyInfo;
if (dependencyProperty != null)
{
propertyType = dependencyProperty.PropertyType;
isReadOnly = ((dependencyProperty.DefaultMetadata.Options & DependencyPropertyOptions.ReadOnly) == DependencyPropertyOptions.ReadOnly);
}
else if (property != null)
{
propertyType = property.PropertyType;
isReadOnly = !property.CanWrite;
}
else
{
Debug.Assert(false);
return;
}
if (isReadOnly && !typeof(ICollection<string>).IsAssignableFrom(propertyType))
{
serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerPrimitivePropertyReadOnly, new object[] { property.Name, property.Name, obj.GetType().FullName }), reader));
return;
}
DeserializeSimpleMember(serializationManager, propertyType, reader, obj, value);
}
internal static void ProcessDefTag(WorkflowMarkupSerializationManager serializationManager, XmlReader reader, Activity activity, bool newSegment, string fileName)
{
System.Resources.ResourceManager resourceManager = new System.Resources.ResourceManager("System.Workflow.ComponentModel.StringResources", typeof(System.Workflow.ComponentModel.ActivityBind).Assembly);
if (reader.NodeType == XmlNodeType.Attribute)
{
switch (reader.LocalName)
{
case StandardXomlKeys.Definitions_Class_LocalName:
activity.SetValue(WorkflowMarkupSerializer.XClassProperty, reader.Value);
break;
default:
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, resourceManager.GetString("UnknownDefinitionTag"), new object[] { StandardXomlKeys.Definitions_XmlNs_Prefix, reader.LocalName, StandardXomlKeys.Definitions_XmlNs }), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
break;
}
return;
}
bool exitLoop = false;
bool isEmptyElement = reader.IsEmptyElement;
int initialDepth = reader.Depth;
do
{
XmlNodeType currNodeType = reader.NodeType;
switch (currNodeType)
{
case XmlNodeType.Element:
{
/*
* if (!reader.LocalName.Equals(localName))
* {
* serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(resourceManager.GetString("DefnTagsCannotBeNested"), "def", localName, reader.LocalName), reader.LineNumber, reader.LinePosition));
* return;
* }
*/
switch (reader.LocalName)
{
case StandardXomlKeys.Definitions_Code_LocalName:
break;
case "Constructor":
default:
serializationManager.ReportError(new WorkflowMarkupSerializationException(string.Format(CultureInfo.CurrentCulture, resourceManager.GetString("UnknownDefinitionTag"), StandardXomlKeys.Definitions_XmlNs_Prefix, reader.LocalName, StandardXomlKeys.Definitions_XmlNs), (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1, (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1));
return;
}
// if an empty element do a Reader then exit
if (isEmptyElement)
{
exitLoop = true;
}
break;
}
case XmlNodeType.EndElement:
{
//reader.Read();
if (reader.Depth == initialDepth)
{
exitLoop = true;
}
break;
}
case XmlNodeType.CDATA:
case XmlNodeType.Text:
{
//
int lineNumber = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1;
int linePosition = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1;
CodeSnippetTypeMember codeSegment = new CodeSnippetTypeMember(reader.Value);
codeSegment.LinePragma = new CodeLinePragma(fileName, Math.Max(lineNumber - 1, 1));
codeSegment.UserData[UserDataKeys.CodeSegment_New] = newSegment;
codeSegment.UserData[UserDataKeys.CodeSegment_ColumnNumber] = linePosition + reader.Name.Length - 1;
CodeTypeMemberCollection codeSegments = activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (codeSegments == null)
{
codeSegments = new CodeTypeMemberCollection();
activity.SetValue(WorkflowMarkupSerializer.XCodeProperty, codeSegments);
}
codeSegments.Add(codeSegment);
//}
/*else
* {
* serializationManager.ReportError( new WorkflowMarkupSerializationException(
* string.Format(resourceManager.GetString("IllegalCDataTextScoping"),
* "def",
* reader.LocalName,
* (currNodeType == XmlNodeType.CDATA ? resourceManager.GetString("CDATASection") : resourceManager.GetString("TextSection"))),
* reader.LineNumber,
* reader.LinePosition)
* );
* }
*/
break;
}
}
}while (!exitLoop && reader.Read());
}
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);
}