public XmlProperty(
PropertyInfo propertyInfo,
XmlName name,
XmlMappingType mappingType = XmlMappingType.Element,
bool isRequired = false,
XmlTypeHandling?typeHandling = null,
XmlNullValueHandling?nullValueHandling = null,
XmlDefaultValueHandling?defaultValueHandling = null,
object defaultValue = null,
XmlItem item = null,
IEnumerable <XmlKnownType> knownTypes = null,
bool isCollection = false,
int order = -1)
: base(propertyInfo.PropertyType, name, mappingType, typeHandling, nullValueHandling, defaultValueHandling, defaultValue, item, knownTypes)
{
if (isCollection)
{
if (!propertyInfo.PropertyType.IsEnumerable())
{
throw new ArgumentException("Collection flag is available only for the IEnumerable type.");
}
this.isCollection = true;
}
this.propertyInfo = propertyInfo;
this.isRequired = isRequired;
this.order = order;
hasGetterAndSetter = propertyInfo.CanRead && propertyInfo.CanWrite;
}
public static XmlObjectContractBuilder <T> SetProperty <T, TProperty>(
this XmlObjectContractBuilder <T> builder,
Expression <Func <T, TProperty> > expression,
XmlName name = null,
XmlMappingType mappingType = XmlMappingType.Element)
{
return(SetProperty(builder, expression, x => x.SetName(name).SetMappingType(mappingType)));
}
public static TBuilder SetProperty <TBuilder>(
this TBuilder builder,
string propertyName,
XmlName name = null,
XmlMappingType mappingType = XmlMappingType.Element)
where TBuilder : XmlObjectContractBuilder
{
return(SetProperty(builder, propertyName, x => x.SetName(name).SetMappingType(mappingType)));
}
public XmlMember Match(XmlMappingType mappingType, XmlReader reader)
{
if (mappingType == Property.MappingType)
{
if (NameRef.Match(reader))
{
return(Property);
}
if (KnownNameRefs != null)
{
for (var i = 0; i < KnownNameRefs.Length; i++)
{
if (KnownNameRefs[i].Match(reader))
{
return((Item ?? Property).KnownTypes[i]);
}
}
}
}
return(null);
}
private void ReadProperty(XmlReader reader, object target, XmlPropertyInfo[] propertyInfos, XmlMappingType mappingType, XmlSerializationContext context)
{
for (var i = 0; i < propertyInfos.Length; i++)
{
var member = propertyInfos[i].Match(mappingType, reader);
if (member != null)
{
if (propertyInfos[i].CollectionProxy == null)
{
var value = context.Deserialize(reader, member);
SetValue(target, propertyInfos[i].Property, value);
}
else
{
var value = context.Deserialize(reader, propertyInfos[i].Property.Item);
propertyInfos[i].CollectionProxy.Add(value);
}
propertyInfos[i].Assigned = true;
return;
}
}
OnUnknownProperty(reader, target, context);
}
public static XmlPropertyBuilder SetMappingType(this XmlPropertyBuilder builder, XmlMappingType mappingType)
{
builder.MappingType = mappingType;
return(builder);
}
internal XmlMember(
Type valueType,
XmlName name,
XmlMappingType mappingType = XmlMappingType.Element,
XmlTypeHandling?typeHandling = null,
XmlNullValueHandling?nullValueHandling = null,
XmlDefaultValueHandling?defaultValueHandling = null,
object defaultValue = null,
XmlItem item = null,
IEnumerable <XmlKnownType> knownTypes = null)
{
if (valueType == null)
{
throw new ArgumentNullException("valueType");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
var isFinalType = valueType.IsFinalType();
this.valueType = valueType;
this.name = name;
this.typeHandling = typeHandling;
this.defaultValueHandling = defaultValueHandling;
this.defaultValue = defaultValue;
isOpenType = !isFinalType && valueType.IsVisible;
this.item = item;
this.nullValueHandling = nullValueHandling;
this.mappingType = mappingType;
if (knownTypes != null)
{
var count = knownTypes.Count();
if (count > 0)
{
if (mappingType != XmlMappingType.Element)
{
throw new ArgumentException("Known types may be set only for XML Element.", "knownTypes");
}
if (isFinalType)
{
throw new ArgumentException("Known types cannot be set for final value type.", "knownTypes");
}
this.knownTypes = new List <XmlKnownType>(count);
foreach (var knownType in knownTypes)
{
if (valueType == knownType.valueType)
{
throw new ArgumentException(string.Format("Known type \"{0}\" cannot be equal to the value type.", valueType), "knownTypes");
}
if (!valueType.IsAssignableFrom(knownType.ValueType))
{
throw new ArgumentException(string.Format("Known type \"{0}\" must be inherits from \"{1}\".", knownType.ValueType, valueType), "knownTypes");
}
this.knownTypes.Add(knownType);
}
}
}
}
