/// <summary>
/// Gets the fields to serialize for the specified object.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of fields to serialize.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public virtual HashSet<string> GetFieldsToSerialize(Type type)
{
Argument.IsNotNull("type", type);
return _fieldsToSerializeCache.GetFromCacheOrFetch(type, () =>
{
var fields = new List<string>();
var typeFields = type.GetFieldsEx();
foreach (var typeField in typeFields)
{
if (AttributeHelper.IsDecoratedWithAttribute<IncludeInSerializationAttribute>(typeField))
{
fields.Add(typeField.Name);
}
}
return new HashSet<string>(fields);
});
}
private void AddTypeMembers(Type type, XmlSerializerTypeInfo serializerTypeInfo)
{
var typesToCheck = new List<Type>();
var isModelBase = type.IsModelBase();
if (isModelBase)
{
// No need to check members, they will be serialized by ModelBase
//var catelTypeInfo = PropertyDataManager.Default.GetCatelTypeInfo(type);
//var modelBaseProperties = catelTypeInfo.GetCatelProperties();
//foreach (var modelBaseProperty in modelBaseProperties)
//{
// typesToCheck.Add(modelBaseProperty.Value.Type);
//}
}
else
{
var allowNonPublicReflection = AllowNonPublicReflection(type);
// Fields
var fields = type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(false, false, allowNonPublicReflection));
foreach (var field in fields)
{
typesToCheck.Add(field.FieldType);
}
// Properties
var properties = type.GetPropertiesEx(BindingFlagsHelper.GetFinalBindingFlags(false, false, allowNonPublicReflection));
foreach (var property in properties)
{
typesToCheck.Add(property.PropertyType);
}
}
foreach (var typeToCheck in typesToCheck)
{
if (serializerTypeInfo.IsTypeAlreadyHandled(typeToCheck))
{
continue;
}
if (!IsTypeSerializable(typeToCheck, serializerTypeInfo))
{
serializerTypeInfo.AddTypeAsHandled(typeToCheck);
continue;
}
var propertyTypeFullName = typeToCheck.GetSafeFullName();
if (propertyTypeFullName == null)
{
serializerTypeInfo.AddTypeAsHandled(typeToCheck);
continue;
}
GetKnownTypes(typeToCheck, serializerTypeInfo);
}
}
/// <summary>
/// Finds the fields that represent a <see cref="PropertyData"/>.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of <see cref="PropertyData"/> elements found as fields.</returns>
/// <exception cref="InvalidOperationException">One ore more fields are not declared correctly.</exception>
private IEnumerable<PropertyData> FindCatelFields(Type type)
{
// CTL-212: Generic types are not supported for FieldInfo.GetValue
if (type.ContainsGenericParametersEx())
{
return new PropertyData[] { };
}
// Fields - safety checks for non-static fields
var nonStaticFields = (from field in type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, false, true))
where field.FieldType == typeof(PropertyData)
select field).ToList();
foreach (var nonStaticField in nonStaticFields)
{
string error = string.Format("The field '{0}' of type 'PropertyData' declared as instance, but they can only be used as static", nonStaticField.Name);
Log.Error(error);
throw new InvalidOperationException(error);
}
// Fields - safety checks for non-public fields
var nonPublicFields = (from field in type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, true, true))
where field.FieldType == typeof(PropertyData) && !field.IsPublic
select field).ToList();
foreach (var nonPublicField in nonPublicFields)
{
string error = string.Format("The field '{0}' of type 'PropertyData' declared as non-public, but they can only be used as public", nonPublicField.Name);
Log.Error(error);
throw new InvalidOperationException(error);
}
// Fields - actual addition
var foundFields = new List<PropertyData>();
var fields = new List<FieldInfo>();
fields.AddRange(type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, true, false)));
foreach (var field in fields)
{
if (field.FieldType == typeof(PropertyData))
{
var propertyValue = (field.IsStatic ? field.GetValue(null) : field.GetValue(this)) as PropertyData;
if (propertyValue != null)
{
foundFields.Add(propertyValue);
}
}
}
return foundFields;
}
private void AddTypeMembers(Type type, XmlSerializerTypeInfo serializerTypeInfo)
{
var isModelBase = (type == typeof(ModelBase)) || typeof(ModelBase).IsAssignableFromEx(type);
if (isModelBase)
{
var catelTypeInfo = PropertyDataManager.Default.GetCatelTypeInfo(type);
var modelBaseProperties = catelTypeInfo.GetCatelProperties();
foreach (var modelBaseProperty in modelBaseProperties)
{
var propertyType = modelBaseProperty.Value.Type;
if (propertyType.FullName != null)
{
GetKnownTypes(propertyType, serializerTypeInfo);
}
else
{
serializerTypeInfo.AddTypeAsHandled(propertyType);
}
}
}
else
{
bool allowNonPublicReflection = AllowNonPublicReflection(type);
// Fields
var fields = type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(false, false, allowNonPublicReflection));
foreach (var field in fields)
{
var fieldType = field.FieldType;
if (fieldType.FullName != null)
{
GetKnownTypes(fieldType, serializerTypeInfo);
}
else
{
serializerTypeInfo.AddTypeAsHandled(fieldType);
}
}
// Properties
var properties = type.GetPropertiesEx(BindingFlagsHelper.GetFinalBindingFlags(false, false, allowNonPublicReflection));
foreach (var property in properties)
{
var propertyType = property.PropertyType;
if (propertyType.FullName != null)
{
GetKnownTypes(propertyType, serializerTypeInfo);
}
else
{
serializerTypeInfo.AddTypeAsHandled(propertyType);
}
}
}
}
/// <summary>
/// Gets the fields
/// </summary>
/// <param name="type">Type of the model.</param>
/// <returns>A hash set containing the fields.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="type"/> is <c>null</c>.</exception>
public Dictionary<string, MemberMetadata> GetFields(Type type)
{
Argument.IsNotNull("type", type);
return _fieldsCache.GetFromCacheOrFetch(type, () =>
{
var dictionary = new Dictionary<string, MemberMetadata>();
var fields = type.GetFieldsEx();
foreach (var fieldInfo in fields)
{
if (fieldInfo.Name.Contains("__BackingField") ||
fieldInfo.DeclaringType == typeof (ModelBase))
{
continue;
}
var memberMetadata = new MemberMetadata(type, fieldInfo.FieldType, SerializationMemberGroup.Field, fieldInfo.Name)
{
Tag = fieldInfo
};
var nameOverride = GetNameOverrideForSerialization(fieldInfo);
if (!string.IsNullOrWhiteSpace(nameOverride))
{
memberMetadata.MemberNameForSerialization = nameOverride;
}
dictionary[fieldInfo.Name] = memberMetadata;
}
return dictionary;
});
}
internal static object TryParseEnum(string name, Type type)
{
if (type.IsEnum())
{
foreach (var field in type.GetFieldsEx(MemberFlags.Public | MemberFlags.Static))
{
if (field.Name.Equals(name, StringComparison.CurrentCultureIgnoreCase))
return field.GetValue(null);
}
}
return null;
}
private void PreventWrongDeclaredFields(Type type)
{
// Fields - safety checks for non-static fields
var nonStaticFields = (from field in type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, false, true))
where field.FieldType == typeof(PropertyData)
select field).ToList();
foreach (var nonStaticField in nonStaticFields)
{
throw Log.ErrorAndCreateException<InvalidOperationException>("The field '{0}' of type 'PropertyData' declared as instance, but they can only be used as static", nonStaticField.Name);
}
// Fields - safety checks for non-public fields
var nonPublicFields = (from field in type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, true, true))
where field.FieldType == typeof(PropertyData) && !field.IsPublic
select field).ToList();
foreach (var nonPublicField in nonPublicFields)
{
throw Log.ErrorAndCreateException<InvalidOperationException>("The field '{0}' of type 'PropertyData' declared as non-public, but they can only be used as public", nonPublicField.Name);
}
}
/// <summary>
/// Finds the fields that represent a <see cref="PropertyData"/>.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>The list of <see cref="PropertyData"/> elements found as fields.</returns>
/// <exception cref="InvalidOperationException">One ore more fields are not declared correctly.</exception>
private IEnumerable<PropertyData> FindCatelFields(Type type)
{
// CTL-212: Generic types are not supported for FieldInfo.GetValue
if (type.ContainsGenericParametersEx())
{
return new PropertyData[] { };
}
PreventWrongDeclaredFields(type);
// Fields - actual addition
var foundFields = new List<PropertyData>();
var fields = new List<FieldInfo>();
fields.AddRange(type.GetFieldsEx(BindingFlagsHelper.GetFinalBindingFlags(true, true, false)));
foreach (var field in fields)
{
if (field.FieldType == typeof(PropertyData))
{
var propertyValue = (field.IsStatic ? field.GetValue(null) : field.GetValue(this)) as PropertyData;
if (propertyValue != null)
{
foundFields.Add(propertyValue);
}
}
}
return foundFields;
}
