Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Print / Reach / Serialization / manager / ReachSerializationCacheItems.cs / 1 / ReachSerializationCacheItems.cs
/*++
Copyright (C) 2004- 2005 Microsoft Corporation
All rights reserved.
Module Name:
ReachSerializationCacheItems.cs
Abstract:
Author:
[....] ([....]) 1-December-2004
Revision History:
--*/
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Reflection;
using System.Xml;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.ComponentModel.Design.Serialization;
using System.Windows.Xps.Packaging;
using System.Windows.Documents;
using System.Windows.Media;
using System.Windows.Markup;
namespace System.Windows.Xps.Serialization
{
internal class TypeDependencyPropertiesCacheItem
{
internal
TypeDependencyPropertiesCacheItem(
Type type,
TypeDependencyPropertyCache[] properties
)
{
this.objectType = type;
this.serializableDependencyProperties = properties;
}
internal
TypeDependencyPropertyCache[]
GetSerializableDependencyProperties(
)
{
return serializableDependencyProperties;
}
private
Type objectType;
private
TypeDependencyPropertyCache[] serializableDependencyProperties;
};
internal class TypeCacheItem
{
internal
TypeCacheItem(
Type type
)
{
this.type = type;
this.serializerType = null;
this.typeConverter = null;
clrSerializableProperties = null;
}
internal
TypeCacheItem(
Type type,
Type serializerType
)
{
this.type = type;
this.serializerType = serializerType;
this.typeConverter = null;
clrSerializableProperties = null;
}
internal
TypeCacheItem(
Type type,
TypeConverter typeConverter
)
{
this.type = type;
this.serializerType = null;
this.typeConverter = typeConverter;
clrSerializableProperties = null;
}
internal
TypePropertyCache[]
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;
}
internal
Type
SerializerType
{
get
{
return serializerType;
}
}
internal
TypeConverter
TypeConverter
{
get
{
return typeConverter;
}
}
private
bool
CanSerializeProperty(
PropertyInfo propertyInfo,
SerializersCacheManager serializersCacheManager,
out DesignerSerializationVisibility visibility,
out Type serializerTypeForProperty,
out TypeConverter typeConverterForProperty,
out DefaultValueAttribute defaultValueAttr,
out DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
)
{
bool canSerializeProperty = false;
visibility = DesignerSerializationVisibility.Visible;
serializerTypeForProperty = null;
typeConverterForProperty = null;
defaultValueAttr = null;
designerSerializationFlagsAttr = null;
// The conditions that we care about in those properties are as follows
// 1. Readable properties
// 2. None Indexable Properteis.
// So we can't deal with properties that take name: Item OR
// take the form this[index1, index2, ...]
// 3. Properties that are not backed up by a dependency property
// 4. Properties that are decorated with the DesignerSerializationVisibility
// and that are not hidden
//
if (propertyInfo.CanRead &&
propertyInfo.GetIndexParameters().GetLength(0) == 0)
{
MemberInfo memberInfo = (MemberInfo) propertyInfo;
Attribute[] attributes = Attribute.GetCustomAttributes(memberInfo);
for(int numberOfAttributes = 0;
numberOfAttributes < attributes.Length;
numberOfAttributes++)
{
//
// Based on the attribute type, different properties could be set
//
Attribute attribute = attributes[numberOfAttributes];
if (attribute is DesignerSerializationVisibilityAttribute)
{
visibility = ((DesignerSerializationVisibilityAttribute)attribute).Visibility;
}
else if (attribute is DefaultValueAttribute)
{
defaultValueAttr = (DefaultValueAttribute)attribute;
}
else if (attribute is DesignerSerializationOptionsAttribute)
{
designerSerializationFlagsAttr = (DesignerSerializationOptionsAttribute)attribute;
}
}
object DependencyPropertyORPropertyInfo =
DependencyProperty.FromName(propertyInfo.Name, propertyInfo.DeclaringType);
if(DependencyPropertyORPropertyInfo == null &&
visibility != DesignerSerializationVisibility.Hidden &&
(propertyInfo.CanWrite || visibility == DesignerSerializationVisibility.Content))
{
if(visibility != DesignerSerializationVisibility.Hidden)
{
canSerializeProperty = true;
}
}
}
return canSerializeProperty;
}
private
Type type;
private
Type serializerType;
private
TypeConverter typeConverter;
private
TypePropertyCache[] clrSerializableProperties;
};
internal class TypePropertyCache
{
internal
TypePropertyCache(
)
{
}
internal
TypePropertyCache(
PropertyInfo propertyInfo
)
{
if(propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
this.propertyInfo = propertyInfo;
this.visibility = DesignerSerializationVisibility.Visible;
this.serializerTypeForProperty = null;
this.typeConverterForProperty = null;
this.defaultValueAttr = null;
this.designerSerializationFlagsAttr = null;
this.propertyValue = null;
}
internal
TypePropertyCache(
PropertyInfo propertyInfo,
DesignerSerializationVisibility visibility,
Type serializerTypeForProperty,
TypeConverter typeConverterForProperty,
DefaultValueAttribute defaultValueAttr,
DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
)
{
if(propertyInfo == null)
{
throw new ArgumentNullException("propertyInfo");
}
this.propertyInfo = propertyInfo;
this.visibility = visibility;
this.serializerTypeForProperty = serializerTypeForProperty;
this.typeConverterForProperty = typeConverterForProperty;
this.defaultValueAttr = defaultValueAttr;
this.designerSerializationFlagsAttr = designerSerializationFlagsAttr;
this.propertyValue = null;
}
internal
DesignerSerializationVisibility
Visibility
{
get
{
return visibility;
}
set
{
visibility = value;
}
}
internal
Type
SerializerTypeForProperty
{
get
{
return serializerTypeForProperty;
}
set
{
serializerTypeForProperty = value;
}
}
internal
TypeConverter
TypeConverterForProperty
{
get
{
return typeConverterForProperty;
}
set
{
typeConverterForProperty = value;
}
}
internal
DefaultValueAttribute
DefaultValueAttr
{
get
{
return defaultValueAttr;
}
set
{
defaultValueAttr = value;
}
}
internal
DesignerSerializationOptionsAttribute
DesignerSerializationOptionsAttr
{
get
{
return designerSerializationFlagsAttr;
}
set
{
designerSerializationFlagsAttr = value;
}
}
internal
PropertyInfo
PropertyInfo
{
get
{
return propertyInfo;
}
set
{
propertyInfo = value;
}
}
internal
object
PropertyValue
{
get
{
return propertyValue;
}
set
{
propertyValue = value;
}
}
private
DesignerSerializationVisibility visibility;
private
Type serializerTypeForProperty;
private
TypeConverter typeConverterForProperty;
private
DefaultValueAttribute defaultValueAttr;
private
DesignerSerializationOptionsAttribute designerSerializationFlagsAttr;
private
PropertyInfo propertyInfo;
private
object propertyValue;
};
internal class TypeDependencyPropertyCache:
TypePropertyCache
{
internal
TypeDependencyPropertyCache(
MemberInfo memberInfo,
Object dependencyProperty,
DesignerSerializationVisibility visibility,
Type serializerTypeForProperty,
TypeConverter typeConverterForProperty,
DefaultValueAttribute defaultValueAttr,
DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
):
base()
{
this.MemberInfo = memberInfo;
this.DependencyProperty = dependencyProperty;
this.PropertyInfo = memberInfo as PropertyInfo;
this.Visibility = visibility;
this.SerializerTypeForProperty = serializerTypeForProperty;
this.TypeConverterForProperty = typeConverterForProperty;
this.DefaultValueAttr = defaultValueAttr;
this.DesignerSerializationOptionsAttr = designerSerializationFlagsAttr;
this.PropertyValue = null;
}
internal
static
bool
CanSerializeProperty(
MemberInfo memberInfo,
SerializersCacheManager serializersCacheManager,
out DesignerSerializationVisibility visibility,
out Type serializerTypeForProperty,
out TypeConverter typeConverterForProperty,
out DefaultValueAttribute defaultValueAttr,
out DesignerSerializationOptionsAttribute designerSerializationFlagsAttr
)
{
bool canSerializeProperty = false;
// The conditions that we care about in those properties are as follows
// 1. Properties that are decorated with the DesignerSerializationVisibility
// and that are not hidden
//
visibility = DesignerSerializationVisibility.Visible;
serializerTypeForProperty = null;
typeConverterForProperty = null;
defaultValueAttr = null;
designerSerializationFlagsAttr = null;
Attribute[] attributes = Attribute.GetCustomAttributes(memberInfo);
for(int numberOfAttributes = 0;
numberOfAttributes < attributes.Length;
numberOfAttributes++)
{
//
// Based on the attribute type, different properties could be set
//
Attribute attribute = attributes[numberOfAttributes];
if (attribute is DesignerSerializationVisibilityAttribute)
{
visibility = ((DesignerSerializationVisibilityAttribute)attribute).Visibility;
}
else if (attribute is DefaultValueAttribute)
{
defaultValueAttr = (DefaultValueAttribute)attribute;
}
else if (attribute is DesignerSerializationOptionsAttribute)
{
designerSerializationFlagsAttr = (DesignerSerializationOptionsAttribute)attribute;
}
}
if(visibility != DesignerSerializationVisibility.Hidden)
{
canSerializeProperty = true;
}
return canSerializeProperty;
}
internal
static
bool
CanSerializeValue(
object serializableObject,
TypeDependencyPropertyCache propertyCache
)
{
bool canSerializeValue = false;
//
// For readonly properties check for DesignerSerializationVisibility.Content
//
bool isReadOnly = ((DependencyProperty)propertyCache.DependencyProperty).ReadOnly;
if (isReadOnly &&
propertyCache.Visibility == DesignerSerializationVisibility.Content)
{
//
// If there is a Visibility.Content attribute honor it and
// populate the property value in this data structure
//
//
DependencyObject targetDO = serializableObject as DependencyObject;
propertyCache.PropertyValue = targetDO.ReadLocalValue((DependencyProperty)propertyCache.DependencyProperty);
canSerializeValue = true;
}
else if (propertyCache.DefaultValueAttr == null)
{
//
// Populate the property value in this data structure
//
DependencyObject targetDO = serializableObject as DependencyObject;
propertyCache.PropertyValue = targetDO.ReadLocalValue((DependencyProperty)propertyCache.DependencyProperty);
canSerializeValue = true;
}
else
{
//
// Populate the property value in this data structure
// as it is required to evaluate the default value
//
DependencyObject targetDO = serializableObject as DependencyObject;
propertyCache.PropertyValue = targetDO.ReadLocalValue((DependencyProperty)propertyCache.DependencyProperty);
//
// 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;
}
}
if(canSerializeValue)
{
if ((propertyCache.PropertyValue == null) ||
(propertyCache.PropertyValue == System.Windows.DependencyProperty.UnsetValue))
{
canSerializeValue = false;
}
}
return canSerializeValue;
}
internal
MemberInfo
MemberInfo
{
get
{
return memberInfo;
}
set
{
memberInfo = value;
}
}
internal
Object
DependencyProperty
{
get
{
return dependencyProperty;
}
set
{
dependencyProperty = value;
}
}
private
MemberInfo memberInfo;
private
object dependencyProperty;
};
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SqlRowUpdatingEvent.cs
- OleAutBinder.cs
- Block.cs
- SQLBinary.cs
- MobileRedirect.cs
- LambdaCompiler.Address.cs
- Pair.cs
- SyndicationItemFormatter.cs
- KeyedHashAlgorithm.cs
- SeparatorAutomationPeer.cs
- EntityClassGenerator.cs
- _ServiceNameStore.cs
- TextBreakpoint.cs
- Trace.cs
- DbException.cs
- DataObjectAttribute.cs
- ResourceCodeDomSerializer.cs
- FolderLevelBuildProvider.cs
- CachedCompositeFamily.cs
- XmlSerializerVersionAttribute.cs
- RecordsAffectedEventArgs.cs
- RowTypePropertyElement.cs
- StringExpressionSet.cs
- SystemIPGlobalStatistics.cs
- IxmlLineInfo.cs
- DataPagerFieldCollection.cs
- ImportContext.cs
- DataGridViewRow.cs
- JpegBitmapDecoder.cs
- ProfileGroupSettingsCollection.cs
- WebPartCollection.cs
- RepeaterItemEventArgs.cs
- DataGridTableCollection.cs
- MaskDescriptors.cs
- TableRowGroup.cs
- DesignerGeometryHelper.cs
- BamlBinaryWriter.cs
- DataGridViewBindingCompleteEventArgs.cs
- ThumbAutomationPeer.cs
- ReadOnlyHierarchicalDataSource.cs
- GenericNameHandler.cs
- peernodestatemanager.cs
- NonVisualControlAttribute.cs
- OdbcCommand.cs
- RecordBuilder.cs
- RpcResponse.cs
- COM2TypeInfoProcessor.cs
- HttpException.cs
- PropertyItemInternal.cs
- RoutedEventValueSerializer.cs
- ProcessProtocolHandler.cs
- FunctionMappingTranslator.cs
- XmlReader.cs
- BodyGlyph.cs
- SetStoryboardSpeedRatio.cs
- Repeater.cs
- iisPickupDirectory.cs
- AsyncCodeActivity.cs
- WebPartEditVerb.cs
- SafeFileMapViewHandle.cs
- OperatorExpressions.cs
- ReflectionHelper.cs
- WebPartCatalogCloseVerb.cs
- InkCollectionBehavior.cs
- ScaleTransform3D.cs
- TypeSystem.cs
- XmlTypeAttribute.cs
- SerializationFieldInfo.cs
- AnnotationResourceCollection.cs
- DetailsView.cs
- SourceInterpreter.cs
- DesignerAdapterUtil.cs
- DbConnectionPoolIdentity.cs
- HostingPreferredMapPath.cs
- WebPartConnectionsCancelEventArgs.cs
- RSAPKCS1SignatureFormatter.cs
- DataColumnCollection.cs
- FormViewDeletedEventArgs.cs
- SettingsBindableAttribute.cs
- DataGridViewRowHeightInfoNeededEventArgs.cs
- CommonDialog.cs
- autovalidator.cs
- ProfileEventArgs.cs
- KeyMatchBuilder.cs
- WebPartConnectVerb.cs
- RecommendedAsConfigurableAttribute.cs
- CustomExpression.cs
- HashHelper.cs
- LogStore.cs
- RoutedPropertyChangedEventArgs.cs
- FixedSOMTable.cs
- StringAnimationUsingKeyFrames.cs
- TemplateEditingService.cs
- WindowsAuthenticationModule.cs
- ValidationHelper.cs
- ResourceType.cs
- ListCollectionView.cs
- SrgsText.cs
- SqlWebEventProvider.cs
- PrintingPermission.cs