public static void Ctor_Visibility(DesignerSerializationVisibility visibility, bool expectedIsDefaultAttribute)
{
var attribute = new DesignerSerializationVisibilityAttribute(visibility);
Assert.Equal(visibility, attribute.Visibility);
Assert.Equal(expectedIsDefaultAttribute, attribute.IsDefaultAttribute());
}
CanSerializeProperty(
MemberInfo memberInfo,
SerializersCacheManager serializersCacheManager,
out DesignerSerializationVisibility visibility,
out Type serializerTypeForProperty,
out TypeConverter typeConverterForProperty,
out DefaultValueAttribute defaultValueAttr,
out DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
)
{
bool canSerializeProperty = false;
// The conditions that we care about in those properties are as follows
// 1. Properties that are decorated with the DesignerSerializationVisibility
// and that are not hidden
//
visibility = DesignerSerializationVisibility.Visible;
serializerTypeForProperty = null;
typeConverterForProperty = null;
defaultValueAttr = null;
designerSerializationFlagsAttr = null;
Attribute[] attributes = Attribute.GetCustomAttributes(memberInfo);
for (int numberOfAttributes = 0;
numberOfAttributes < attributes.Length;
numberOfAttributes++)
{
//
// Based on the attribute type, different properties could be set
//
Attribute attribute = attributes[numberOfAttributes];
if (attribute is DesignerSerializationVisibilityAttribute)
{
visibility = ((DesignerSerializationVisibilityAttribute)attribute).Visibility;
}
else if (attribute is DefaultValueAttribute)
{
defaultValueAttr = (DefaultValueAttribute)attribute;
}
else if (attribute is DesignerSerializationOptionsAttribute)
{
designerSerializationFlagsAttr = (DesignerSerializationOptionsAttribute)attribute;
}
}
if (visibility != DesignerSerializationVisibility.Hidden)
{
canSerializeProperty = true;
}
return(canSerializeProperty);
}
// Summary:
// Initializes a new instance of the System.ComponentModel.DesignerSerializationVisibilityAttribute
// class using the specified System.ComponentModel.DesignerSerializationVisibility
// value.
//
// Parameters:
// visibility:
// One of the System.ComponentModel.DesignerSerializationVisibility values.
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility visibility)
{
// Summary:
// Gets a value indicating the basic serialization mode a serializer should
// use when determining whether and how to persist the value of a property.
//
// Returns:
// One of the System.ComponentModel.DesignerSerializationVisibility values.
// The default is System.ComponentModel.DesignerSerializationVisibility.Visible.
return(default(DesignerSerializationVisibilityAttribute));
}
internal MemberReflector(XamlType type, XamlValueConverter <System.ComponentModel.TypeConverter> typeConverter)
{
this.Type = type;
this._typeConverter.Value = typeConverter;
this._designerSerializationVisibility = DesignerSerializationVisibility.Visible;
this._memberBits = -65440;
this._deferringLoader.Value = null;
this._getter.Value = null;
this._setter.Value = null;
this._valueSerializer.Value = null;
}
internal MemberReflector(XamlType type, XamlValueConverter<System.ComponentModel.TypeConverter> typeConverter)
{
this.Type = type;
this._typeConverter.Value = typeConverter;
this._designerSerializationVisibility = DesignerSerializationVisibility.Visible;
this._memberBits = -65440;
this._deferringLoader.Value = null;
this._getter.Value = null;
this._setter.Value = null;
this._valueSerializer.Value = null;
}
// Summary:
// Initializes a new instance of the System.ComponentModel.DesignerSerializationVisibilityAttribute
// class using the specified System.ComponentModel.DesignerSerializationVisibility
// value.
//
// Parameters:
// visibility:
// One of the System.ComponentModel.DesignerSerializationVisibility values.
public DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility visibility) {
// Summary:
// Gets a value indicating the basic serialization mode a serializer should
// use when determining whether and how to persist the value of a property.
//
// Returns:
// One of the System.ComponentModel.DesignerSerializationVisibility values.
// The default is System.ComponentModel.DesignerSerializationVisibility.Visible.
return default(DesignerSerializationVisibilityAttribute);
}
///<summary>Ctor used by directives</summary>
internal MemberReflector(XamlType type, XamlValueConverter <TypeConverter> typeConverter)
{
Type = type;
_typeConverter.Value = typeConverter;
_designerSerializationVisibility = DesignerSerializationVisibility.Visible;
_memberBits = (int)BoolMemberBits.Directive | (int)BoolMemberBits.AllValid;
// Explicitly set all the nullable references so that IsSet is true
_deferringLoader.Value = null;
_getter.Value = null;
_setter.Value = null;
_valueSerializer.Value = null;
}
private static DesignerSerializationVisibility GetSerializationVisibility(PropertyInfo prop)
{
if ((prop.DeclaringType == typeof(CompositeActivity)) && string.Equals(prop.Name, "Activities", StringComparison.Ordinal))
{
return(DesignerSerializationVisibility.Hidden);
}
DesignerSerializationVisibility visible = DesignerSerializationVisibility.Visible;
DesignerSerializationVisibilityAttribute[] customAttributes = (DesignerSerializationVisibilityAttribute[])prop.GetCustomAttributes(typeof(DesignerSerializationVisibilityAttribute), true);
if (customAttributes.Length > 0)
{
visible = customAttributes[0].Visibility;
}
return(visible);
}
protected internal override PropertyInfo[] GetProperties(WorkflowMarkupSerializationManager serializationManager, object obj)
{
List <PropertyInfo> properties = new List <PropertyInfo>(base.GetProperties(serializationManager, obj));
//Collect the internal properties, we do this so that activity change action apis don't need to expose unnecessary setters
foreach (PropertyInfo property in obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy))
{
DesignerSerializationVisibility visibility = Helpers.GetSerializationVisibility(property);
if (visibility != DesignerSerializationVisibility.Hidden && property.GetSetMethod() == null && property.GetSetMethod(true) != null)
{
properties.Add(property);
}
}
return(properties.ToArray());
}
private static DesignerSerializationVisibility GetSerializationVisibility(PropertyInfo prop)
{
// work around!!! for Activities collection
if (prop.DeclaringType == typeof(CompositeActivity) && string.Equals(prop.Name, "Activities", StringComparison.Ordinal))
{
return(DesignerSerializationVisibility.Hidden);
}
DesignerSerializationVisibility visibility = DesignerSerializationVisibility.Visible;
DesignerSerializationVisibilityAttribute[] visibilityAttrs = (DesignerSerializationVisibilityAttribute[])prop.GetCustomAttributes(typeof(DesignerSerializationVisibilityAttribute), true);
if (visibilityAttrs.Length > 0)
{
visibility = visibilityAttrs[0].Visibility;
}
return(visibility);
}
internal static DesignerSerializationVisibility GetSerializationVisibility(MemberInfo memberInfo)
{
if (memberInfo == null)
{
throw new ArgumentNullException("memberInfo");
}
DesignerSerializationVisibility visible = DesignerSerializationVisibility.Visible;
object[] customAttributes = memberInfo.GetCustomAttributes(typeof(DesignerSerializationVisibilityAttribute), true);
if (customAttributes.Length > 0)
{
return((customAttributes[0] as DesignerSerializationVisibilityAttribute).Visibility);
}
if (Attribute.IsDefined(memberInfo, typeof(DesignerSerializationVisibilityAttribute)))
{
visible = (Attribute.GetCustomAttribute(memberInfo, typeof(DesignerSerializationVisibilityAttribute)) as DesignerSerializationVisibilityAttribute).Visibility;
}
return(visible);
}
TypePropertyCache(
PropertyInfo propertyInfo,
DesignerSerializationVisibility visibility,
Type serializerTypeForProperty,
TypeConverter typeConverterForProperty,
DefaultValueAttribute defaultValueAttr,
DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
)
{
if (propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
this.propertyInfo = propertyInfo;
this.visibility = visibility;
this.serializerTypeForProperty = serializerTypeForProperty;
this.typeConverterForProperty = typeConverterForProperty;
this.defaultValueAttr = defaultValueAttr;
this.designerSerializationFlagsAttr = designerSerializationFlagsAttr;
this.propertyValue = null;
}
TypeDependencyPropertyCache(
MemberInfo memberInfo,
Object dependencyProperty,
DesignerSerializationVisibility visibility,
Type serializerTypeForProperty,
TypeConverter typeConverterForProperty,
DefaultValueAttribute defaultValueAttr,
DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
) :
base()
{
this.MemberInfo = memberInfo;
this.DependencyProperty = dependencyProperty;
this.PropertyInfo = memberInfo as PropertyInfo;
this.Visibility = visibility;
this.SerializerTypeForProperty = serializerTypeForProperty;
this.TypeConverterForProperty = typeConverterForProperty;
this.DefaultValueAttr = defaultValueAttr;
this.DesignerSerializationOptionsAttr = designerSerializationFlagsAttr;
this.PropertyValue = null;
}
internal static DesignerSerializationVisibility GetSerializationVisibility(MemberInfo memberInfo)
{
if (memberInfo == null)
{
throw new ArgumentNullException("memberInfo");
}
DesignerSerializationVisibility designerSerializationVisibility = DesignerSerializationVisibility.Visible;
// Calling GetCustomAttributes on PropertyInfo or EventInfo when the inherit parameter of GetCustomAttributes
// is true does not walk the type hierarchy. But System.Attribute.GetCustomAttributes causes perf issues.
object[] attributes = memberInfo.GetCustomAttributes(typeof(DesignerSerializationVisibilityAttribute), true);
if (attributes.Length > 0)
{
designerSerializationVisibility = (attributes[0] as DesignerSerializationVisibilityAttribute).Visibility;
}
else if (Attribute.IsDefined(memberInfo, typeof(DesignerSerializationVisibilityAttribute)))
{
designerSerializationVisibility = (Attribute.GetCustomAttribute(memberInfo, typeof(DesignerSerializationVisibilityAttribute)) as DesignerSerializationVisibilityAttribute).Visibility;
}
return(designerSerializationVisibility);
}
public T?GetAttributeValue <T>(Type attributeType) where T : struct
{
if (CustomAttributeProvider != null)
{
object[] attributes = CustomAttributeProvider.GetCustomAttributes(attributeType, false);
if (attributes.Length == 0)
{
return(null);
}
if (attributeType == typeof(DesignerSerializationVisibilityAttribute))
{
DesignerSerializationVisibility result = ((DesignerSerializationVisibilityAttribute)attributes[0]).Visibility;
return((T)(object)result);
}
if (attributeType == typeof(UsableDuringInitializationAttribute))
{
bool result = ((UsableDuringInitializationAttribute)attributes[0]).Usable;
return((T)(object)result);
}
Debug.Fail("Unexpected attribute type requested: " + attributeType.Name);
return(null);
}
try
{
CustomAttributeData cad = GetAttribute(attributeType);
if (cad == null)
{
return(null);
}
return(Extract <T>(cad));
}
catch (CustomAttributeFormatException)
{
CustomAttributeProvider = Member;
return(GetAttributeValue <T>(attributeType));
}
}
public bool WalkProperties(Activity activity, object obj)
{
Activity currentActivity = obj as Activity;
PropertyInfo[] props = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo prop in props)
{
// !!Work around: no indexer property walking
if (prop.GetIndexParameters() != null && prop.GetIndexParameters().Length > 0)
{
continue;
}
DesignerSerializationVisibility visibility = GetSerializationVisibility(prop);
if (visibility == DesignerSerializationVisibility.Hidden)
{
continue;
}
//Try to see if we have dynamic property associated with the object on the same object
//if so then we should compare if the dynamic property values match with the property type
//if not we bail out
object propValue = null;
DependencyProperty dependencyProperty = DependencyProperty.FromName(prop.Name, obj.GetType());
if (dependencyProperty != null && currentActivity != null)
{
if (currentActivity.IsBindingSet(dependencyProperty))
{
propValue = currentActivity.GetBinding(dependencyProperty);
}
else
{
propValue = currentActivity.GetValue(dependencyProperty);
}
}
else
{
try
{
propValue = prop.CanRead ? prop.GetValue(obj, null) : null;
}
catch
{
// Eat exceptions that occur while invoking the getter.
}
}
if (FoundProperty != null)
{
WalkerEventArgs args = new WalkerEventArgs(activity, propValue, prop, obj);
FoundProperty(this, args);
if (args.Action == WalkerAction.Skip)
{
continue;
}
else if (args.Action == WalkerAction.Abort)
{
return(false);
}
}
if (propValue is IList)
{
//We do not need to reflect on the properties of the list
foreach (object childObj in (IList)propValue)
{
if (FoundProperty != null)
{
WalkerEventArgs args = new WalkerEventArgs(activity, childObj, null, propValue);
FoundProperty(this, args);
if (args.Action == WalkerAction.Skip)
{
continue;
}
else if (args.Action == WalkerAction.Abort)
{
return(false);
}
}
if (childObj != null && IsBrowsableType(childObj.GetType()))
{
if (!WalkProperties(activity, childObj))
{
return(false);
}
}
}
}
else if (propValue != null && IsBrowsableType(propValue.GetType()))
{
if (!WalkProperties(activity, propValue))
{
return(false);
}
}
}
return(true);
}
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility visiblity)
{
this.m_visibility = visiblity;
}
/// <summary>Initializes a new instance of the <see cref="T:System.ComponentModel.DesignerSerializationVisibilityAttribute" /> class using the specified <see cref="T:System.ComponentModel.DesignerSerializationVisibility" /> value.</summary>
/// <param name="visibility">One of the <see cref="T:System.ComponentModel.DesignerSerializationVisibility" /> values. </param>
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility vis)
{
this.visibility = vis;
}
internal override IEnumerable <MarkupProperty> GetProperties(bool mapToConstructorArgs)
{
ValueSerializer valueSerializer = ValueSerializer.GetSerializerFor(ObjectType, Context);
if (valueSerializer != null && valueSerializer.CanConvertToString(_instance, Context))
{
yield return(new ElementStringValueProperty(this));
if (_key != null)
{
yield return(_key);
}
}
else
{
Dictionary <string, string> constructorArguments = null;
// if this markup item is the value of property in attribute form and the instance
// it represents is a MarkupExtension, then we return any properties that are
// constructor arguments as ElementConstructorArgument markup properties
if (mapToConstructorArgs && _instance is MarkupExtension)
{
ParameterInfo[] parameters;
ICollection arguments;
if (TryGetConstructorInfoArguments(_instance, out parameters, out arguments))
{
int i = 0;
foreach (object value in arguments)
{
if (constructorArguments == null)
{
constructorArguments = new Dictionary <string, string>();
}
// store a list of the parameters that are constructor arguments
// so that we don't return those properties again
constructorArguments.Add(parameters[i].Name, parameters[i].Name);
yield return(new ElementConstructorArgument(value, parameters[i++].ParameterType, this));
}
}
}
foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(_instance))
{
DesignerSerializationVisibility visibility = descriptor.SerializationVisibility;
if (visibility != DesignerSerializationVisibility.Hidden &&
(!descriptor.IsReadOnly || visibility == DesignerSerializationVisibility.Content) &&
ShouldSerialize(descriptor, _instance, _manager))
{
if (visibility == DesignerSerializationVisibility.Content)
{
// Ensure the collection has content
object value = descriptor.GetValue(_instance);
if (value == null)
{
continue;
}
else
{
ICollection collection = value as ICollection;
if (collection != null && collection.Count < 1)
{
continue;
}
IEnumerable enumerable = value as IEnumerable;
if (enumerable != null && !enumerable.GetEnumerator().MoveNext())
{
continue;
}
}
}
if (constructorArguments != null)
{
ConstructorArgumentAttribute constructorArgumentAttribute = descriptor.Attributes[typeof(ConstructorArgumentAttribute)] as ConstructorArgumentAttribute;
if (constructorArgumentAttribute != null && constructorArguments.ContainsKey(constructorArgumentAttribute.ArgumentName))
{
// Skip this property, it has already been represented by a constructor parameter
continue;
}
}
yield return(new ElementProperty(this, descriptor));
}
}
IDictionary dictionary = _instance as IDictionary;
if (dictionary != null)
{
yield return(new ElementDictionaryItemsPseudoProperty(dictionary, typeof(IDictionary), this));
}
else
{
IEnumerable enumerable = _instance as IEnumerable;
if (enumerable != null && enumerable.GetEnumerator().MoveNext())
{
yield return(new ElementItemsPseudoProperty(enumerable, typeof(IEnumerable), this));
}
}
if (_key != null)
{
yield return(_key);
}
}
}
// Token: 0x0600240C RID: 9228 RVA: 0x000AFC1A File Offset: 0x000ADE1A
internal override IEnumerable <MarkupProperty> GetProperties(bool mapToConstructorArgs)
{
ValueSerializer serializerFor = ValueSerializer.GetSerializerFor(this.ObjectType, this.Context);
if (serializerFor != null && serializerFor.CanConvertToString(this._instance, this.Context))
{
yield return(new ElementStringValueProperty(this));
if (this._key != null)
{
yield return(this._key);
}
}
else
{
Dictionary <string, string> constructorArguments = null;
IEnumerator enumerator;
if (mapToConstructorArgs && this._instance is MarkupExtension)
{
ParameterInfo[] parameters;
ICollection collection;
if (this.TryGetConstructorInfoArguments(this._instance, out parameters, out collection))
{
int i = 0;
foreach (object obj in collection)
{
if (constructorArguments == null)
{
constructorArguments = new Dictionary <string, string>();
}
constructorArguments.Add(parameters[i].Name, parameters[i].Name);
object value = obj;
ParameterInfo[] array = parameters;
int num = i;
i = num + 1;
yield return(new ElementConstructorArgument(value, array[num].ParameterType, this));
}
enumerator = null;
}
parameters = null;
}
foreach (object obj2 in TypeDescriptor.GetProperties(this._instance))
{
PropertyDescriptor propertyDescriptor = (PropertyDescriptor)obj2;
DesignerSerializationVisibility serializationVisibility = propertyDescriptor.SerializationVisibility;
if (serializationVisibility != DesignerSerializationVisibility.Hidden && (!propertyDescriptor.IsReadOnly || serializationVisibility == DesignerSerializationVisibility.Content) && ElementMarkupObject.ShouldSerialize(propertyDescriptor, this._instance, this._manager))
{
if (serializationVisibility == DesignerSerializationVisibility.Content)
{
object value2 = propertyDescriptor.GetValue(this._instance);
if (value2 == null)
{
continue;
}
ICollection collection2 = value2 as ICollection;
if (collection2 != null && collection2.Count < 1)
{
continue;
}
IEnumerable enumerable = value2 as IEnumerable;
if (enumerable != null && !enumerable.GetEnumerator().MoveNext())
{
continue;
}
}
if (constructorArguments != null)
{
ConstructorArgumentAttribute constructorArgumentAttribute = propertyDescriptor.Attributes[typeof(ConstructorArgumentAttribute)] as ConstructorArgumentAttribute;
if (constructorArgumentAttribute != null && constructorArguments.ContainsKey(constructorArgumentAttribute.ArgumentName))
{
continue;
}
}
yield return(new ElementProperty(this, propertyDescriptor));
}
}
enumerator = null;
IDictionary dictionary = this._instance as IDictionary;
if (dictionary != null)
{
yield return(new ElementDictionaryItemsPseudoProperty(dictionary, typeof(IDictionary), this));
}
else
{
IEnumerable enumerable2 = this._instance as IEnumerable;
if (enumerable2 != null && enumerable2.GetEnumerator().MoveNext())
{
yield return(new ElementItemsPseudoProperty(enumerable2, typeof(IEnumerable), this));
}
}
if (this._key != null)
{
yield return(this._key);
}
constructorArguments = null;
}
yield break;
yield break;
}
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility visibility)
{
this.visibility = visibility;
}
public static void Visibility(DesignerSerializationVisibility visibility)
{
var attribute = new DesignerSerializationVisibilityAttribute(visibility);
Assert.Equal(visibility, attribute.Visibility);
}
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility visibility)
{
throw new NotImplementedException();
}
public void DefaultProperties_GetVisibility_ReturnsExpected(DesignerSerializationVisibilityAttribute attribute, DesignerSerializationVisibility expectedVisibility, bool expectedIsDefaultAttribute)
{
Assert.Equal(expectedVisibility, attribute.Visibility);
Assert.Equal(expectedIsDefaultAttribute, attribute.IsDefaultAttribute());
}
internal MemberReflector()
{
_designerSerializationVisibility = VisibilityInvalid;
}
private protected bool SkipMember(object obj, MemberInfo member, out object value, ref DesignerSerializationVisibility visibility)
{
value = null;
// skipping non-serializable members
// Skip 1.) hidden by DesignerSerializationVisibility
Attribute[] attrs = Attribute.GetCustomAttributes(member, typeof(DesignerSerializationVisibilityAttribute), true);
visibility = attrs.Length > 0 ? ((DesignerSerializationVisibilityAttribute)attrs[0]).Visibility : visibility;
if (visibility == DesignerSerializationVisibility.Hidden)
{
return(true);
}
// Skip 2.) ShouldSerialize<MemberName> method returns false
if ((Options & XmlSerializationOptions.IgnoreShouldSerialize) == XmlSerializationOptions.None)
{
MethodInfo shouldSerializeMethod = member.DeclaringType?.GetMethod(XmlSerializer.MethodShouldSerialize + member.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
if (shouldSerializeMethod != null && shouldSerializeMethod.ReturnType == Reflector.BoolType && !(bool)Reflector.InvokeMethod(obj, shouldSerializeMethod))
{
return(true);
}
}
// Skip 3.) DefaultValue equals to property value
bool hasDefaultValue = false;
object defaultValue = null;
if ((Options & XmlSerializationOptions.IgnoreDefaultValueAttribute) == XmlSerializationOptions.None)
{
attrs = Attribute.GetCustomAttributes(member, typeof(DefaultValueAttribute), true);
hasDefaultValue = attrs.Length > 0;
if (hasDefaultValue)
{
defaultValue = ((DefaultValueAttribute)attrs[0]).Value;
}
}
PropertyInfo property = member as PropertyInfo;
FieldInfo field = property == null ? (FieldInfo)member : null;
Type memberType = property != null ? property.PropertyType : field.FieldType;
if (!hasDefaultValue && (Options & XmlSerializationOptions.AutoGenerateDefaultValuesAsFallback) != XmlSerializationOptions.None)
{
hasDefaultValue = true;
defaultValue = memberType.IsValueType ? Activator.CreateInstance(memberType) : null;
}
value = property != null
? property.Get(obj)
: field.Get(obj);
return(hasDefaultValue && Equals(value, defaultValue));
}
DesignerSerializationVisibility(DesignerSerializationVisibility.Content)> _
private void SerializeObject(object obj, bool typeNeeded, XmlWriter writer, DesignerSerializationVisibility visibility)
{
#region Local Methods to reduce complexity
bool TrySerializeKeyValue(ref SerializeObjectContext ctx)
{
// 1.) KeyValue 1: DictionaryEntry: can be serialized recursively. Just handling to avoid binary serialization.
if (ctx.Type == Reflector.DictionaryEntryType)
{
if (ctx.TypeNeeded)
{
ctx.Writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(ctx.Type));
}
SerializeMembers(ctx.Object, ctx.Writer, ctx.Visibility);
return(true);
}
// 2.) KeyValue 2: KeyValuePair: properties are read-only so special support needed
if (ctx.Type.IsGenericTypeOf(Reflector.KeyValuePairType))
{
if (ctx.TypeNeeded)
{
ctx.Writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(ctx.Type));
}
object key = Accessors.GetPropertyValue(ctx.Object, nameof(KeyValuePair <_, _> .Key));
object value = Accessors.GetPropertyValue(ctx.Object, nameof(KeyValuePair <_, _> .Value));
ctx.Writer.WriteStartElement(nameof(KeyValuePair <_, _> .Key));
if (key == null)
{
ctx.Writer.WriteEndElement();
}
else
{
SerializeObject(key, key.GetType() != ctx.Type.GetGenericArguments()[0], ctx.Writer, ctx.Visibility);
ctx.Writer.WriteFullEndElement();
}
ctx.Writer.WriteStartElement(nameof(KeyValuePair <_, _> .Value));
if (value == null)
{
ctx.Writer.WriteEndElement();
}
else
{
SerializeObject(value, value.GetType() != ctx.Type.GetGenericArguments()[1], ctx.Writer, ctx.Visibility);
ctx.Writer.WriteFullEndElement();
}
return(true);
}
return(false);
}
bool TrySerializeComplexObject(ref SerializeObjectContext ctx)
{
// 1.) collection: if can be trusted in all circumstances
if (ctx.Object is IEnumerable enumerable)
{
Type elementType = null;
// if can be trusted in all circumstances
if (IsTrustedCollection(ctx.Type)
// or recursive is requested
|| ((ctx.Visibility == DesignerSerializationVisibility.Content || RecursiveSerializationAsFallback)
// and is a supported collection or serialization is forced
&& (ForceReadonlyMembersAndCollections || ctx.Type.IsSupportedCollectionForReflection(out var _, out var _, out elementType, out var _))))
{
SerializeCollection(enumerable, elementType ?? ctx.Type.GetCollectionElementType(), ctx.TypeNeeded, ctx.Writer, ctx.Visibility);
return(true);
}
if (ctx.Visibility == DesignerSerializationVisibility.Content || RecursiveSerializationAsFallback)
{
Throw.SerializationException(Res.XmlSerializationCannotSerializeUnsupportedCollection(ctx.Type, Options));
}
Throw.SerializationException(Res.XmlSerializationCannotSerializeCollection(ctx.Type, Options));
}
// 2.) recursive serialization of any object, if requested
if (RecursiveSerializationAsFallback || ctx.Visibility == DesignerSerializationVisibility.Content
// or when it has public properties/fields only
|| IsTrustedType(ctx.Type))
{
if (ctx.TypeNeeded)
{
ctx.Writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(ctx.Type));
}
SerializeMembers(ctx.Object, ctx.Writer, ctx.Visibility);
return(true);
}
return(false);
}
#endregion
if (obj == null)
{
return;
}
Type type = obj.GetType();
// a.) If type can be natively parsed, simple writing
if (type.CanBeParsedNatively())
{
if (typeNeeded)
{
writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(type));
}
WriteStringValue(obj, writer);
return;
}
// b.) IXmlSerializable
if (obj is IXmlSerializable xmlSerializable && ProcessXmlSerializable)
{
if (typeNeeded)
{
writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(type));
}
SerializeXmlSerializable(xmlSerializable, writer);
return;
}
// c.) Using type converter of the type if applicable
TypeConverter converter = TypeDescriptor.GetConverter(type);
if (converter.CanConvertTo(Reflector.StringType) && converter.CanConvertFrom(Reflector.StringType))
{
if (typeNeeded)
{
writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(type));
}
// ReSharper disable once AssignNullToNotNullAttribute
writer.WriteString(converter.ConvertToInvariantString(obj));
return;
}
var context = new SerializeObjectContext {
Object = obj, Type = type, TypeNeeded = typeNeeded, Writer = writer, Visibility = visibility
};
// d.) Key/Value
if (TrySerializeKeyValue(ref context))
{
return;
}
// e.) value type as binary only if enabled
if (type.IsValueType && CompactSerializationOfStructures && BinarySerializer.TrySerializeValueType((ValueType)obj, out byte[] data))
public DesignerSerializationVisibilityAttribute (DesignerSerializationVisibility vis)
{
visibility = vis;
}
/// <summary>
/// Serializing a collection by XmlWriter
/// </summary>
private void SerializeCollection(IEnumerable collection, Type elementType, bool typeNeeded, XmlWriter writer, DesignerSerializationVisibility visibility)
{
if (collection == null)
{
return;
}
// array collection
if (collection is Array array)
{
if (typeNeeded)
{
writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(collection.GetType()));
}
// multidimensional or nonzero-based array
if (array.Rank > 1 || array.GetLowerBound(0) != 0)
{
StringBuilder dim = new StringBuilder();
for (int i = 0; i < array.Rank; i++)
{
int low;
if ((low = array.GetLowerBound(i)) != 0)
{
dim.Append(low + ".." + (low + array.GetLength(i) - 1));
}
else
{
dim.Append(array.GetLength(i));
}
if (i < array.Rank - 1)
{
dim.Append(',');
}
}
writer.WriteAttributeString(XmlSerializer.AttributeDim, dim.ToString());
}
else
{
writer.WriteAttributeString(XmlSerializer.AttributeLength, array.Length.ToString(CultureInfo.InvariantCulture));
}
if (array.Length == 0)
{
// signing that collection is not null - now it will be at least <Collection></Collection> instead of <Collection />
writer.WriteString(String.Empty);
return;
}
// array of a primitive type
if (elementType.IsPrimitive && (Options & XmlSerializationOptions.CompactSerializationOfPrimitiveArrays) != XmlSerializationOptions.None)
{
byte[] data = new byte[Buffer.ByteLength(array)];
Buffer.BlockCopy(array, 0, data, 0, data.Length);
if ((Options & XmlSerializationOptions.OmitCrcAttribute) == XmlSerializationOptions.None)
{
writer.WriteAttributeString(XmlSerializer.AttributeCrc, Crc32.CalculateHash(data).ToString("X8", CultureInfo.InvariantCulture));
}
writer.WriteString(Convert.ToBase64String(data));
return;
}
// non-primitive type array or compact serialization is not enabled
if (elementType.IsPointer)
{
Throw.NotSupportedException(Res.SerializationPointerArrayTypeNotSupported(collection.GetType()));
}
foreach (var item in array)
{
writer.WriteStartElement(XmlSerializer.ElementItem);
if (item == null)
{
writer.WriteEndElement();
}
else
{
SerializeObject(item, !elementType.IsSealed && item.GetType() != elementType, writer, visibility);
writer.WriteFullEndElement();
}
}
return;
}
// non-array collection
if (typeNeeded)
{
writer.WriteAttributeString(XmlSerializer.AttributeType, GetTypeString(collection.GetType()));
}
// serializing main properties first
SerializeMembers(collection, writer, visibility);
// serializing items
foreach (var item in collection)
{
writer.WriteStartElement(XmlSerializer.ElementItem);
if (item == null)
{
writer.WriteEndElement();
}
else
{
SerializeObject(item, !elementType.IsSealed && item.GetType() != elementType, writer, visibility);
writer.WriteFullEndElement();
}
}
}
internal MemberReflector()
{
this._designerSerializationVisibility = (DesignerSerializationVisibility)0x7fffffff;
}
GetTypeDependencyPropertiesCacheItem(
Object serializableObject
)
{
if (serializableObject == null)
{
throw new ArgumentNullException("serializableObject");
}
Type type = serializableObject.GetType();
TypeDependencyPropertiesCacheItem
cachedItem = (TypeDependencyPropertiesCacheItem)_typesDependencyPropertiesCacheTable[type];
if (cachedItem == null)
{
//
// This means that the type was not seen before
// We have to create a new entry to that type
//
DependencyObject objectAsDependencyObject = serializableObject as DependencyObject;
if (objectAsDependencyObject != null)
{
//
// First we have to figure out if this dependency
// object has any dependency properties that can be
// serializable and this has to happen before creating
// any cache
//
DependencyPropertyList list = new DependencyPropertyList(1);
for (LocalValueEnumerator localValues = objectAsDependencyObject.GetLocalValueEnumerator();
localValues.MoveNext();)
{
DependencyProperty dependencyProperty = localValues.Current.Property;
list.Add(dependencyProperty);
}
if (list.Count > 0)
{
int numOfSerializableDependencyProperties = 0;
TypeDependencyPropertyCache[] dependencyPropertiesCache = new TypeDependencyPropertyCache[list.Count];
for (int indexInDependencyPropertyList = 0;
indexInDependencyPropertyList < list.Count;
indexInDependencyPropertyList++)
{
DependencyProperty dependencyProperty = list.List[indexInDependencyPropertyList];
DesignerSerializationVisibility visibility = DesignerSerializationVisibility.Visible;
Type serializerTypeForProperty = null;
TypeConverter typeConverterForProperty = null;
DefaultValueAttribute defaultValueAttr = null;
DesignerSerializationOptionsAttribute
designerSerializationFlagsAttr = null;
Type propertyType = dependencyProperty.PropertyType;
//
// Get the static setter member for the DependencyProperty
//
MemberInfo memberInfo = dependencyProperty.
OwnerType.
GetMethod("Get" + dependencyProperty.Name,
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Static | BindingFlags.FlattenHierarchy);
// Note: This is because the IService model does not abide
// by this pattern of declaring the DependencyProperty on
// the OwnerType. That is the only exception case.
if (memberInfo == null)
{
//
// Create a PropertyInfo
//
PropertyInfo propertyInfo = null;
PropertyInfo[] properties = dependencyProperty.OwnerType.GetProperties();
String name = dependencyProperty.Name;
for (int i = 0;
i < properties.Length && propertyInfo == null;
i++)
{
if (properties[i].Name == name)
{
propertyInfo = properties[i];
}
}
if (propertyInfo != null)
{
Debug.Assert(propertyInfo.PropertyType == dependencyProperty.PropertyType,
"The property type of the CLR wrapper must match that of the DependencyProperty itself.");
memberInfo = propertyInfo;
//
// We have to special case Print Tickets here.
// Print Tickets are defined on as dependency properties on
// fixed objects of types:
// o FixedDocumentSequence
// o FixedDocument
// o FixedPage
// and in order to eliminate the dependency between
// PresentationFramework and System.printing assemblies,
// those dependency properties are defined as of type "object"
// and hence if we are here and we have a property of name
// "PrintTicket" and owned by one of the above mentioned types
// we try to get the serializer for the PrintTicket object
//
if (propertyInfo.Name == XpsNamedProperties.PrintTicketProperty &&
((dependencyProperty.OwnerType == typeof(System.Windows.Documents.FixedPage)) ||
(dependencyProperty.OwnerType == typeof(System.Windows.Documents.FixedDocument)) ||
(dependencyProperty.OwnerType == typeof(System.Windows.Documents.FixedDocumentSequence))))
{
propertyType = typeof(PrintTicket);
}
}
}
if (memberInfo != null &&
TypeDependencyPropertyCache.
CanSerializeProperty(memberInfo,
this,
out visibility,
out serializerTypeForProperty,
out typeConverterForProperty,
out defaultValueAttr,
out designerSerializationFlagsAttr) == true)
{
TypeCacheItem typeCacheItem = GetTypeCacheItem(propertyType);
serializerTypeForProperty = serializerTypeForProperty == null ? typeCacheItem.SerializerType : serializerTypeForProperty;
typeConverterForProperty = typeConverterForProperty == null ? typeCacheItem.TypeConverter : typeConverterForProperty;
TypeDependencyPropertyCache
dependencyPropertyCache = new TypeDependencyPropertyCache(memberInfo,
dependencyProperty,
visibility,
serializerTypeForProperty,
typeConverterForProperty,
defaultValueAttr,
designerSerializationFlagsAttr);
dependencyPropertiesCache[numOfSerializableDependencyProperties++] = dependencyPropertyCache;
}
}
if (numOfSerializableDependencyProperties > 0)
{
TypeDependencyPropertyCache[] serializableDependencyPropertiesCache =
new TypeDependencyPropertyCache[numOfSerializableDependencyProperties];
for (int indexInSerializableProperties = 0;
indexInSerializableProperties < numOfSerializableDependencyProperties;
indexInSerializableProperties++)
{
serializableDependencyPropertiesCache[indexInSerializableProperties] =
dependencyPropertiesCache[indexInSerializableProperties];
}
cachedItem = new TypeDependencyPropertiesCacheItem(type,
serializableDependencyPropertiesCache);
_typesDependencyPropertiesCacheTable[type] = cachedItem;
}
}
}
}
return(cachedItem);
}
GetClrSerializableProperties(
SerializersCacheManager serializersCacheManager
)
{
if (clrSerializableProperties == null)
{
PropertyInfo[] properties = type.GetProperties();
//
// Separate out the serializable Clr properties
//
int IndexOfSerializableProperties = 0;
int[] propertiesIndex = new int[properties.Length];
TypePropertyCache[] cachedProperties = new TypePropertyCache[properties.Length];
for (int indexInProperties = 0;
indexInProperties < properties.Length;
indexInProperties++)
{
PropertyInfo propertyInfo = properties[indexInProperties];
DesignerSerializationVisibility visibility = DesignerSerializationVisibility.Visible;
Type serializerTypeForProperty = null;
TypeConverter typeConverterForProperty = null;
DefaultValueAttribute defaultValueAttr = null;
DesignerSerializationOptionsAttribute
designerSerializationFlagsAttr = null;
if (CanSerializeProperty(propertyInfo,
serializersCacheManager,
out visibility,
out serializerTypeForProperty,
out typeConverterForProperty,
out defaultValueAttr,
out designerSerializationFlagsAttr) == true)
{
//
// Figure out the Serializer or TypeConverter associated with the
// type of that property. This would potentially be cached in 2
// different places
// 1. The Type Cache
// 2. The TypePropertyCache.
//
TypeCacheItem typeCacheItem = serializersCacheManager.GetTypeCacheItem(propertyInfo.PropertyType);
serializerTypeForProperty = typeCacheItem.SerializerType;
typeConverterForProperty = typeCacheItem.TypeConverter;
//
// We create a cache of this property and all the information we
// deduced about it
//
TypePropertyCache propertyCache = new TypePropertyCache(propertyInfo,
visibility,
serializerTypeForProperty,
typeConverterForProperty,
defaultValueAttr,
designerSerializationFlagsAttr);
propertiesIndex[IndexOfSerializableProperties] = indexInProperties;
cachedProperties[IndexOfSerializableProperties++] = propertyCache;
}
}
clrSerializableProperties = new TypePropertyCache[IndexOfSerializableProperties];
for (int indexInClrProperties = 0;
indexInClrProperties < IndexOfSerializableProperties;
indexInClrProperties++)
{
clrSerializableProperties[indexInClrProperties] = cachedProperties[indexInClrProperties];
}
}
return(clrSerializableProperties);
}
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility visibility)
{
}
public DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility v) { }
CanSerializeProperty(
PropertyInfo propertyInfo,
SerializersCacheManager serializersCacheManager,
out DesignerSerializationVisibility visibility,
out Type serializerTypeForProperty,
out TypeConverter typeConverterForProperty,
out DefaultValueAttribute defaultValueAttr,
out DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
)
{
bool canSerializeProperty = false;
visibility = DesignerSerializationVisibility.Visible;
serializerTypeForProperty = null;
typeConverterForProperty = null;
defaultValueAttr = null;
designerSerializationFlagsAttr = null;
// The conditions that we care about in those properties are as follows
// 1. Readable properties
// 2. None Indexable Properteis.
// So we can't deal with properties that take name: Item OR
// take the form this[index1, index2, ...]
// 3. Properties that are not backed up by a dependency property
// 4. Properties that are decorated with the DesignerSerializationVisibility
// and that are not hidden
//
if (propertyInfo.CanRead &&
propertyInfo.GetIndexParameters().GetLength(0) == 0)
{
MemberInfo memberInfo = (MemberInfo)propertyInfo;
Attribute[] attributes = Attribute.GetCustomAttributes(memberInfo);
for (int numberOfAttributes = 0;
numberOfAttributes < attributes.Length;
numberOfAttributes++)
{
//
// Based on the attribute type, different properties could be set
//
Attribute attribute = attributes[numberOfAttributes];
if (attribute is DesignerSerializationVisibilityAttribute)
{
visibility = ((DesignerSerializationVisibilityAttribute)attribute).Visibility;
}
else if (attribute is DefaultValueAttribute)
{
defaultValueAttr = (DefaultValueAttribute)attribute;
}
else if (attribute is DesignerSerializationOptionsAttribute)
{
designerSerializationFlagsAttr = (DesignerSerializationOptionsAttribute)attribute;
}
}
object DependencyPropertyORPropertyInfo =
DependencyProperty.FromName(propertyInfo.Name, propertyInfo.DeclaringType);
if (DependencyPropertyORPropertyInfo == null &&
visibility != DesignerSerializationVisibility.Hidden &&
(propertyInfo.CanWrite || visibility == DesignerSerializationVisibility.Content))
{
if (visibility != DesignerSerializationVisibility.Hidden)
{
canSerializeProperty = true;
}
}
}
return(canSerializeProperty);
}
internal MemberReflector()
{
this._designerSerializationVisibility = (DesignerSerializationVisibility) 0x7fffffff;
}