/// <summary> /// Should the property be removed from serialization? /// </summary> /// <param name = "info"></param> /// <param name = "property"></param> /// <returns> /// true if the property: /// - is in the PropertiesToIgnore, /// - contains ExcludeFromSerializationAttribute, /// - does not have it's set or get accessor /// - is indexer /// </returns> protected virtual bool IgnoreProperty(TypeInfo info, PropertyInfo property) { // Soll die Eigenschaft ignoriert werden if (PropertiesToIgnore.Contains(info.Type, property.Name)) { return(true); } if (ContainsExcludeFromSerializationAttribute(property)) { return(true); } if (!property.CanRead || !property.CanWrite) { return(true); } ParameterInfo[] indexParameters = property.GetIndexParameters(); if (indexParameters.Length > 0) { // Indexer return(true); } return(false); }
/// <summary> /// Gives all properties back which: /// - are public /// - are not static /// - does not contain ExcludeFromSerializationAttribute /// - have their set and get accessors /// - are not indexers /// </summary> /// <param name = "typeInfo"></param> /// <returns></returns> public IList <PropertyInfo> GetProperties(TypeInfo typeInfo) { // Search in cache var propertyInfos = Cache.TryGetPropertyInfos(typeInfo.Type); if (propertyInfos != null) { return(propertyInfos); } // Creating infos PropertyInfo[] properties = GetAllProperties(typeInfo.Type); var result = new List <PropertyInfo>(); foreach (PropertyInfo property in properties) { if (!IgnoreProperty(typeInfo, property)) { result.Add(property); } } // adding result to Cache Cache.Add(typeInfo.Type, result); return(result); }
public override bool IgnoreCollectionItems(Polenter.Serialization.Serializing.TypeInfo info) { return(!collectionItemHandlerCallback(info.Type)); }
protected override bool IgnoreProperty(Polenter.Serialization.Serializing.TypeInfo info, PropertyInfo property) { return(!propertyHandlerCallback(info.Type, property)); }
/// <summary> /// /// </summary> /// <param name="typeInfo"></param> /// <param name="type"></param> /// <returns>true if the key and value definition was found</returns> private static bool fillKeyAndElementType(TypeInfo typeInfo, Type type) { if (type.IsGenericType) { Type[] arguments = type.GetGenericArguments(); if (typeInfo.IsDictionary) { // in Dictionary there are keys and values typeInfo.KeyType = arguments[0]; typeInfo.ElementType = arguments[1]; } else { // In Collection there are only items typeInfo.ElementType = arguments[0]; } return arguments.Length > 0; } return false; }
///<summary> ///</summary> ///<param name = "type"></param> ///<returns></returns> public static TypeInfo GetTypeInfo(Type type) { // check if Info is in cache TypeInfo typeInfo = Cache.TryGetTypeInfo(type); if (typeInfo == null) { // no info in cache yet typeInfo = new TypeInfo(); typeInfo.Type = type; typeInfo.IsSimple = Tools.IsSimple(type); // new since v.2.16 // check if array of byte if (type==typeof(byte[])) { typeInfo.ElementType = typeof (byte); } // Only not simple types can be Collections if (!typeInfo.IsSimple) { // check if it is an Array typeInfo.IsArray = Tools.IsArray(type); if (typeInfo.IsArray) { // Array? What is its element type? if (type.HasElementType) { typeInfo.ElementType = type.GetElementType(); } // How many dimensions typeInfo.ArrayDimensionCount = type.GetArrayRank(); } else { // It is not Array, maybe Enumerable? typeInfo.IsEnumerable = Tools.IsEnumerable(type); if (typeInfo.IsEnumerable) { // it is Enumerable maybe Collection? typeInfo.IsCollection = Tools.IsCollection(type); if (typeInfo.IsCollection) { // Sure it is a Collection, but maybe Dictionary also? typeInfo.IsDictionary = Tools.IsDictionary(type); // Fill its key and value types, if the listing is generic bool elementTypeDefinitionFound; var examinedType = type; do { elementTypeDefinitionFound = fillKeyAndElementType(typeInfo, examinedType); examinedType = examinedType.BaseType; // until key and element definition was found, or the base typ is an object } while (!elementTypeDefinitionFound && examinedType!=null && examinedType!=typeof(object)); } } } } #if Smartphone Cache.AddIfNotExists(typeInfo); #else Cache.Add(typeInfo); #endif } return typeInfo; }
public virtual bool IgnoreCollectionItems(TypeInfo info) { return(false); }