/// <summary>
/// Adds the type to the known types if the type is serializable.
/// </summary>
/// <param name="typeToAdd">The type to add.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type is serializable; otherwise <c>false</c>.</returns>
protected virtual bool AddTypeToKnownTypesIfSerializable(Type typeToAdd, XmlSerializerTypeInfo serializerTypeInfo)
{
// Collection first, this collection of types is smaller so if we have a hit, we exit sooner
if (serializerTypeInfo.IsCollectionAlreadyHandled(typeToAdd))
{
return(true);
}
if (serializerTypeInfo.ContainsKnownType(typeToAdd))
{
return(true);
}
serializerTypeInfo.AddCollectionAsHandled(typeToAdd);
// If this is a special collection type (generic), then we need to make sure that if the inner type is
// an interface, we do not add it again if already added.
// See this issue http://catel.codeplex.com/workitem/7167
if (serializerTypeInfo.IsSpecialCollectionType(typeToAdd))
{
// Always ignore
return(false);
}
return(serializerTypeInfo.AddKnownType(typeToAdd));
}
/// <summary>
/// Determines whether the type should be handled.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type should be handled; otherwise, <c>false</c>.</returns>
protected virtual bool ShouldTypeBeIgnored(Type type, XmlSerializerTypeInfo serializerTypeInfo)
{
if (type == null)
{
return(true);
}
// Note, although resharper says this isn't possible, it might be
var fullName = type.GetSafeFullName();
if (string.IsNullOrWhiteSpace(fullName))
{
serializerTypeInfo.AddTypeAsHandled(type);
return(true);
}
// Ignore non-generic .NET
if (!type.IsGenericTypeEx() && type.GetSafeFullName().StartsWith("System."))
{
// Log.Debug("Non-generic .NET system type, can be ignored");
serializerTypeInfo.AddTypeAsHandled(type);
return(true);
}
if (type.IsCOMObjectEx())
{
serializerTypeInfo.AddTypeAsHandled(type);
return(true);
}
return(serializerTypeInfo.ContainsKnownType(type) ||
serializerTypeInfo.IsTypeAlreadyHandled(type) ||
serializerTypeInfo.IsCollectionAlreadyHandled(type));
}
/// <summary>
/// Adds the type to the known types if the type is serializable.
/// </summary>
/// <param name="typeToAdd">The type to add.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type is serializable; otherwise <c>false</c>.</returns>
protected virtual bool AddTypeToKnownTypesIfSerializable(Type typeToAdd, XmlSerializerTypeInfo serializerTypeInfo)
{
// Collection first, this collection of types is smaller so if we have a hit, we exit sooner
if (serializerTypeInfo.IsCollectionAlreadyHandled(typeToAdd))
{
return(true);
}
if (serializerTypeInfo.ContainsKnownType(typeToAdd))
{
return(true);
}
serializerTypeInfo.AddCollectionAsHandled(typeToAdd);
// If this is a special collection type (generic), then we need to make sure that if the inner type is
// an interface, we do not add it again if already added.
// See this issue http://catel.codeplex.com/workitem/7167
if (serializerTypeInfo.IsSpecialCollectionType(typeToAdd))
{
// Always ignore as a test
return(false);
// TODO: Also check interfaces
// // It might be a base type, loop all
// var baseType = typeToAdd;
// while (baseType != null)
// {
// if (baseType.IsGenericTypeEx())
// {
// if (baseType.GetGenericArgumentsEx()[0].IsInterfaceEx())
// {
// var genericTypeDefinition = baseType.GetGenericTypeDefinitionEx();
// var allPossibleMatchingTypes = (from type in serializerTypeInfo.SpecialGenericCollectionTypes
// where type.GetGenericTypeDefinitionEx() == genericTypeDefinition
// select type).ToList();
// if (allPossibleMatchingTypes.Count > 0)
// {
// Log.Debug("Skipping type '{0}' because there already exists such a type which does the same", typeToAdd.GetSafeFullName());
// return false;
// }
// }
// }
// baseType = baseType.GetBaseTypeEx();
// }
}
return(serializerTypeInfo.AddKnownType(typeToAdd));
}
/// <summary>
/// Determines whether the type should be handled.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type should be handled; otherwise, <c>false</c>.</returns>
protected virtual bool ShouldTypeBeIgnored(Type type, XmlSerializerTypeInfo serializerTypeInfo)
{
if (type == null)
{
return(true);
}
// Never include generic type definitions, otherwise we will get this:
// Error while getting known types for Type 'Catel.Tests.Data.PropertyDataManagerFacts+SupportsGenericClasses+GenericClass`1[T]'. The type must not be an open or partial generic class.
if (type.IsGenericTypeDefinitionEx())
{
return(true);
}
// Note, although resharper says this isn't possible, it might be
var fullName = type.GetSafeFullName(false);
if (string.IsNullOrWhiteSpace(fullName))
{
serializerTypeInfo.AddTypeAsHandled(type);
return(true);
}
// Ignore non-generic .NET
if (!type.IsGenericTypeEx() && fullName.StartsWith("System."))
{
// Log.Debug("Non-generic .NET system type, can be ignored");
serializerTypeInfo.AddTypeAsHandled(type);
return(true);
}
if (type.IsCOMObjectEx())
{
serializerTypeInfo.AddTypeAsHandled(type);
return(true);
}
return(serializerTypeInfo.ContainsKnownType(type) ||
serializerTypeInfo.IsTypeAlreadyHandled(type) ||
serializerTypeInfo.IsCollectionAlreadyHandled(type));
}
/// <summary>
/// Adds the type to the known types if the type is serializable.
/// </summary>
/// <param name="typeToAdd">The type to add.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type is serializable; otherwise <c>false</c>.</returns>
protected virtual bool AddTypeToKnownTypesIfSerializable(Type typeToAdd, XmlSerializerTypeInfo serializerTypeInfo)
{
// Collection first, this collection of types is smaller so if we have a hit, we exit sooner
if (serializerTypeInfo.IsCollectionAlreadyHandled(typeToAdd))
{
return true;
}
if (serializerTypeInfo.ContainsKnownType(typeToAdd))
{
return true;
}
serializerTypeInfo.AddCollectionAsHandled(typeToAdd);
// If this is a special collection type (generic), then we need to make sure that if the inner type is
// an interface, we do not add it again if already added.
// See this issue http://catel.codeplex.com/workitem/7167
if (serializerTypeInfo.IsSpecialCollectionType(typeToAdd))
{
// Always ignore
return false;
}
return serializerTypeInfo.AddKnownType(typeToAdd);
}
/// <summary>
/// Determines whether the type should be handled.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type should be handled; otherwise, <c>false</c>.</returns>
protected virtual bool ShouldTypeBeIgnored(Type type, XmlSerializerTypeInfo serializerTypeInfo)
{
if (type == null)
{
return true;
}
// Never include generic type definitions, otherwise we will get this:
// Error while getting known types for Type 'Catel.Test.Data.PropertyDataManagerFacts+SupportsGenericClasses+GenericClass`1[T]'. The type must not be an open or partial generic class.
if (type.IsGenericTypeDefinitionEx())
{
return true;
}
// Note, although resharper says this isn't possible, it might be
var fullName = type.GetSafeFullName();
if (string.IsNullOrWhiteSpace(fullName))
{
serializerTypeInfo.AddTypeAsHandled(type);
return true;
}
// Ignore non-generic .NET
if (!type.IsGenericTypeEx() && fullName.StartsWith("System."))
{
// Log.Debug("Non-generic .NET system type, can be ignored");
serializerTypeInfo.AddTypeAsHandled(type);
return true;
}
if (type.IsCOMObjectEx())
{
serializerTypeInfo.AddTypeAsHandled(type);
return true;
}
return serializerTypeInfo.ContainsKnownType(type) ||
serializerTypeInfo.IsTypeAlreadyHandled(type) ||
serializerTypeInfo.IsCollectionAlreadyHandled(type);
}
/// <summary>
/// Adds the type to the known types if the type is serializable.
/// </summary>
/// <param name="typeToAdd">The type to add.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type is serializable; otherwise <c>false</c>.</returns>
protected virtual bool AddTypeToKnownTypesIfSerializable(Type typeToAdd, XmlSerializerTypeInfo serializerTypeInfo)
{
// Collection first, this collection of types is smaller so if we have a hit, we exit sooner
if (serializerTypeInfo.IsCollectionAlreadyHandled(typeToAdd))
{
return true;
}
if (serializerTypeInfo.ContainsKnownType(typeToAdd))
{
return true;
}
serializerTypeInfo.AddCollectionAsHandled(typeToAdd);
// If this is a special collection type (generic), then we need to make sure that if the inner type is
// an interface, we do not add it again if already added.
// See this issue http://catel.codeplex.com/workitem/7167
if (serializerTypeInfo.IsSpecialCollectionType(typeToAdd))
{
// Always ignore as a test
return false;
// TODO: Also check interfaces
// // It might be a base type, loop all
// var baseType = typeToAdd;
// while (baseType != null)
// {
// if (baseType.IsGenericTypeEx())
// {
// if (baseType.GetGenericArgumentsEx()[0].IsInterfaceEx())
// {
// var genericTypeDefinition = baseType.GetGenericTypeDefinitionEx();
// var allPossibleMatchingTypes = (from type in serializerTypeInfo.SpecialGenericCollectionTypes
// where type.GetGenericTypeDefinitionEx() == genericTypeDefinition
// select type).ToList();
// if (allPossibleMatchingTypes.Count > 0)
// {
// Log.Debug("Skipping type '{0}' because there already exists such a type which does the same", typeToAdd.GetSafeFullName());
// return false;
// }
// }
// }
// baseType = baseType.GetBaseTypeEx();
// }
}
return serializerTypeInfo.AddKnownType(typeToAdd);
}
/// <summary>
/// Determines whether the type should be handled.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="serializerTypeInfo">The serializer type info.</param>
/// <returns><c>true</c> if the type should be handled; otherwise, <c>false</c>.</returns>
protected virtual bool ShouldTypeBeIgnored(Type type, XmlSerializerTypeInfo serializerTypeInfo)
{
if (type == null)
{
return true;
}
// Note, although resharper says this isn't possible, it might be
if (type.FullName == null)
{
serializerTypeInfo.AddTypeAsHandled(type);
return true;
}
// Ignore non-generic .NET
if (!type.IsGenericTypeEx() && type.GetSafeFullName().StartsWith("System."))
{
// Log.Debug("Non-generic .NET system type, can be ignored");
serializerTypeInfo.AddTypeAsHandled(type);
return true;
}
return serializerTypeInfo.ContainsKnownType(type) || serializerTypeInfo.IsTypeAlreadyHandled(type);
}
