CanSerializeClrProperty(
Object serializableObject,
TypePropertyCache property,
ReachSerializationServices reachSerializationServices
)
{
bool canSerialize = true;
if (serializableObject != null &&
property != null &&
property.PropertyInfo != null)
{
String name = property.PropertyInfo.Name;
Hashtable clrPropertiesTable = (Hashtable)reachSerializationServices.
TypeNoneSerializableClrProperties[serializableObject.GetType()];
if (clrPropertiesTable != null)
{
if (clrPropertiesTable.Contains(name))
{
canSerialize = false;
}
}
}
return(canSerialize);
}
CanSerializeClrProperty(
Object serializableObject,
TypePropertyCache property
)
{
return(true);
}
CanSerializeClrProperty(
Object serializableObject,
TypePropertyCache property
)
{
return(CanSerializeClrProperty(serializableObject, property, _reachSerializationServices));
}
GetClrSerializableProperties(
Object serializableObject
)
{
TypeCacheItem item = GetTypeCacheItem(serializableObject);
TypePropertyCache[] clrProperties = item.GetClrSerializableProperties(this);
int[] serializableIndeces = new int[clrProperties.Length];
int serializablePropertiesIndex = 0;
//
// Not everything we get can be serializable, so we have to figure out which
// ones are but checking if we can also serialize the value of the property
// values would be added to the cache as well.
//
for (int indexInClrProperties = 0;
indexInClrProperties < clrProperties.Length;
indexInClrProperties++)
{
if (CanSerializeValue(serializableObject,
clrProperties[indexInClrProperties]) &&
_serializationManager.CanSerializeClrProperty(serializableObject,
clrProperties[indexInClrProperties]))
{
serializableIndeces[serializablePropertiesIndex++] = indexInClrProperties;
}
}
TypePropertyCache[] clrSerializableProperties = new TypePropertyCache[serializablePropertiesIndex];
for (int indexInClrSerializableProperties = 0;
indexInClrSerializableProperties < serializablePropertiesIndex;
indexInClrSerializableProperties++)
{
TypePropertyCache propertyCache = clrProperties[serializableIndeces[indexInClrSerializableProperties]];
TypePropertyCache serializablePropertyCache = new TypePropertyCache(propertyCache.PropertyInfo,
propertyCache.Visibility,
propertyCache.SerializerTypeForProperty,
propertyCache.TypeConverterForProperty,
propertyCache.DefaultValueAttr,
propertyCache.DesignerSerializationOptionsAttr);
serializablePropertyCache.PropertyValue = propertyCache.PropertyValue;
clrSerializableProperties[indexInClrSerializableProperties] = serializablePropertyCache;
}
//
// Clear all set values
//
for (int indexInClrProperties = 0;
indexInClrProperties < clrProperties.Length;
indexInClrProperties++)
{
clrProperties[indexInClrProperties].PropertyValue = null;
}
return(clrSerializableProperties);
}
CanSerializeValue(
object serializableObject,
TypePropertyCache propertyCache
)
{
bool canSerializeValue = false;
//
// For readonly properties check for DesignerSerializationVisibility.Content
//
bool isReadOnly = !propertyCache.PropertyInfo.CanWrite;
if ((isReadOnly &&
propertyCache.Visibility == DesignerSerializationVisibility.Content) ||
propertyCache.DefaultValueAttr == null)
{
//
// Populate the property value in this data structure
//
propertyCache.PropertyValue = propertyCache.PropertyInfo.GetValue(serializableObject, null);
canSerializeValue = true;
}
else
{
//
// Populate the property value in this data structure
// as it is required to evaluate the default value
//
propertyCache.PropertyValue = propertyCache.PropertyInfo.GetValue(serializableObject, null);
// For Clr properties with a DefaultValueAttribute
// check if the current value equals the default
canSerializeValue = !object.Equals(propertyCache.DefaultValueAttr.Value,
propertyCache.PropertyValue);
if (!canSerializeValue)
{
propertyCache.PropertyValue = null;
}
}
return(canSerializeValue);
}
InitializeSerializableClrProperties(
)
{
TypePropertyCache[] clrProperties = _serializationManager.CacheManager.GetClrSerializableProperties(_target);
if (clrProperties != null)
{
for (int indexInClrSerializableProperties = 0;
indexInClrSerializableProperties < clrProperties.Length;
indexInClrSerializableProperties++)
{
TypePropertyCache propertyCache = clrProperties[indexInClrSerializableProperties];
//
// Create SerializablePropertyContext out of the cache retrieved
//
SerializablePropertyContext propertyContext = new SerializablePropertyContext(_target,
propertyCache);
propertyContext.Name = propertyContext.TypePropertyCache.PropertyInfo.Name;
//
// We have to differentiate between simple properties and complex properties.
// o Simple properties would be considered as attributes within the markup and
// would not require new writers
// o Complex properties would be considered elements within the markup and might
// require a new writer
//
if (propertyContext.IsComplexProperty(_serializationManager))
{
propertyContext.IsComplex = true;
_complexPropertyCollection.Enqueue(propertyContext);
}
else
{
propertyContext.IsComplex = false;
_simplePropertyCollection.Enqueue(propertyContext);
}
}
}
}
SerializablePropertyContext(
object target,
TypePropertyCache propertyCache) :
base()
{
//
// Validate Input Arguments
//
if (target == null)
{
throw new ArgumentNullException("target");
}
if (propertyCache == null)
{
throw new ArgumentNullException("propertyCache");
}
_targetObject = target;
_propertyInfo = propertyCache;
this._isComplex = false;
}
GetClrSerializableProperties(
SerializersCacheManager serializersCacheManager
)
{
if (clrSerializableProperties == null)
{
PropertyInfo[] properties = type.GetProperties();
//
// Separate out the serializable Clr properties
//
int IndexOfSerializableProperties = 0;
int[] propertiesIndex = new int[properties.Length];
TypePropertyCache[] cachedProperties = new TypePropertyCache[properties.Length];
for (int indexInProperties = 0;
indexInProperties < properties.Length;
indexInProperties++)
{
PropertyInfo propertyInfo = properties[indexInProperties];
DesignerSerializationVisibility visibility = DesignerSerializationVisibility.Visible;
Type serializerTypeForProperty = null;
TypeConverter typeConverterForProperty = null;
DefaultValueAttribute defaultValueAttr = null;
DesignerSerializationOptionsAttribute
designerSerializationFlagsAttr = null;
if (CanSerializeProperty(propertyInfo,
serializersCacheManager,
out visibility,
out serializerTypeForProperty,
out typeConverterForProperty,
out defaultValueAttr,
out designerSerializationFlagsAttr) == true)
{
//
// Figure out the Serializer or TypeConverter associated with the
// type of that property. This would potentially be cached in 2
// different places
// 1. The Type Cache
// 2. The TypePropertyCache.
//
TypeCacheItem typeCacheItem = serializersCacheManager.GetTypeCacheItem(propertyInfo.PropertyType);
serializerTypeForProperty = typeCacheItem.SerializerType;
typeConverterForProperty = typeCacheItem.TypeConverter;
//
// We create a cache of this property and all the information we
// deduced about it
//
TypePropertyCache propertyCache = new TypePropertyCache(propertyInfo,
visibility,
serializerTypeForProperty,
typeConverterForProperty,
defaultValueAttr,
designerSerializationFlagsAttr);
propertiesIndex[IndexOfSerializableProperties] = indexInProperties;
cachedProperties[IndexOfSerializableProperties++] = propertyCache;
}
}
clrSerializableProperties = new TypePropertyCache[IndexOfSerializableProperties];
for (int indexInClrProperties = 0;
indexInClrProperties < IndexOfSerializableProperties;
indexInClrProperties++)
{
clrSerializableProperties[indexInClrProperties] = cachedProperties[indexInClrProperties];
}
}
return(clrSerializableProperties);
}
