/// <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 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); }