Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WCF / Serialization / System / Runtime / Serialization / DataMember.cs / 1305376 / DataMember.cs
//------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime.Serialization
{
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Security;
class DataMember
{
[Fx.Tag.SecurityNote(Critical = "Holds instance of CriticalHelper which keeps state that is cached statically for serialization."
+ " Static fields are marked SecurityCritical or readonly to prevent data from being modified or leaked to other components in appdomain.")]
[SecurityCritical]
CriticalHelper helper;
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember()
{
helper = new CriticalHelper();
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember(MemberInfo memberInfo)
{
helper = new CriticalHelper(memberInfo);
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember(string name)
{
helper = new CriticalHelper(name);
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember(DataContract memberTypeContract, string name, bool isNullable, bool isRequired, bool emitDefaultValue, int order)
{
helper = new CriticalHelper(memberTypeContract, name, isNullable, isRequired, emitDefaultValue, order);
}
internal MemberInfo MemberInfo
{
[SecuritySafeCritical]
get { return helper.MemberInfo; }
}
internal string Name
{
[SecuritySafeCritical]
get { return helper.Name; }
[SecurityCritical]
set { helper.Name = value; }
}
internal int Order
{
[SecuritySafeCritical]
get { return helper.Order; }
[SecurityCritical]
set { helper.Order = value; }
}
internal bool IsRequired
{
[SecuritySafeCritical]
get { return helper.IsRequired; }
[SecurityCritical]
set { helper.IsRequired = value; }
}
internal bool EmitDefaultValue
{
[SecuritySafeCritical]
get { return helper.EmitDefaultValue; }
[SecurityCritical]
set { helper.EmitDefaultValue = value; }
}
internal bool IsNullable
{
[SecuritySafeCritical]
get { return helper.IsNullable; }
[SecurityCritical]
set { helper.IsNullable = value; }
}
internal bool IsGetOnlyCollection
{
[SecuritySafeCritical]
get { return helper.IsGetOnlyCollection; }
[SecurityCritical]
set { helper.IsGetOnlyCollection = value; }
}
internal Type MemberType
{
[SecuritySafeCritical]
get { return helper.MemberType; }
}
internal DataContract MemberTypeContract
{
[SecuritySafeCritical]
get { return helper.MemberTypeContract; }
[SecurityCritical]
set { helper.MemberTypeContract = value; }
}
internal bool HasConflictingNameAndType
{
[SecuritySafeCritical]
get { return helper.HasConflictingNameAndType; }
[SecurityCritical]
set { helper.HasConflictingNameAndType = value; }
}
internal DataMember ConflictingMember
{
[SecuritySafeCritical]
get { return helper.ConflictingMember; }
[SecurityCritical]
set { helper.ConflictingMember = value; }
}
[Fx.Tag.SecurityNote(Critical = "Critical.")]
[SecurityCritical(SecurityCriticalScope.Everything)]
class CriticalHelper
{
DataContract memberTypeContract;
string name;
int order;
bool isRequired;
bool emitDefaultValue;
bool isNullable;
bool isGetOnlyCollection = false;
MemberInfo memberInfo;
bool hasConflictingNameAndType;
DataMember conflictingMember;
internal CriticalHelper()
{
this.emitDefaultValue = Globals.DefaultEmitDefaultValue;
}
internal CriticalHelper(MemberInfo memberInfo)
{
this.emitDefaultValue = Globals.DefaultEmitDefaultValue;
this.memberInfo = memberInfo;
}
internal CriticalHelper(string name)
{
this.Name = name;
}
internal CriticalHelper(DataContract memberTypeContract, string name, bool isNullable, bool isRequired, bool emitDefaultValue, int order)
{
this.MemberTypeContract = memberTypeContract;
this.Name = name;
this.IsNullable = isNullable;
this.IsRequired = isRequired;
this.EmitDefaultValue = emitDefaultValue;
this.Order = order;
}
internal MemberInfo MemberInfo
{
get { return memberInfo; }
}
internal string Name
{
get { return name; }
set { name = value; }
}
internal int Order
{
get { return order; }
set { order = value; }
}
internal bool IsRequired
{
get { return isRequired; }
set { isRequired = value; }
}
internal bool EmitDefaultValue
{
get { return emitDefaultValue; }
set { emitDefaultValue = value; }
}
internal bool IsNullable
{
get { return isNullable; }
set { isNullable = value; }
}
internal bool IsGetOnlyCollection
{
get { return isGetOnlyCollection; }
set { isGetOnlyCollection = value; }
}
internal Type MemberType
{
get
{
FieldInfo field = MemberInfo as FieldInfo;
if (field != null)
return field.FieldType;
return ((PropertyInfo)MemberInfo).PropertyType;
}
}
internal DataContract MemberTypeContract
{
get
{
if (memberTypeContract == null)
{
if (MemberInfo != null)
{
if (this.IsGetOnlyCollection)
{
memberTypeContract = DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(MemberType.TypeHandle), MemberType.TypeHandle, MemberType, SerializationMode.SharedContract);
}
else
{
memberTypeContract = DataContract.GetDataContract(MemberType);
}
}
}
return memberTypeContract;
}
set
{
memberTypeContract = value;
}
}
internal bool HasConflictingNameAndType
{
get { return this.hasConflictingNameAndType; }
set { this.hasConflictingNameAndType = value; }
}
internal DataMember ConflictingMember
{
get { return this.conflictingMember; }
set { this.conflictingMember = value; }
}
}
[Fx.Tag.SecurityNote(Miscellaneous = "RequiresReview - checks member visibility to calculate if access to it requires MemberAccessPermission for serialization."
+ " Since this information is used to determine whether to give the generated code access"
+ " permissions to private members, any changes to the logic should be reviewed.")]
internal bool RequiresMemberAccessForGet()
{
MemberInfo memberInfo = MemberInfo;
FieldInfo field = memberInfo as FieldInfo;
if (field != null)
{
return DataContract.FieldRequiresMemberAccess(field);
}
else
{
PropertyInfo property = (PropertyInfo)memberInfo;
MethodInfo getMethod = property.GetGetMethod(true /*nonPublic*/);
if (getMethod != null)
return DataContract.MethodRequiresMemberAccess(getMethod) || !DataContract.IsTypeVisible(property.PropertyType);
}
return false;
}
[Fx.Tag.SecurityNote(Miscellaneous = "RequiresReview - checks member visibility to calculate if access to it requires MemberAccessPermission for deserialization."
+ " Since this information is used to determine whether to give the generated code access"
+ " permissions to private members, any changes to the logic should be reviewed.")]
internal bool RequiresMemberAccessForSet()
{
MemberInfo memberInfo = MemberInfo;
FieldInfo field = memberInfo as FieldInfo;
if (field != null)
{
return DataContract.FieldRequiresMemberAccess(field);
}
else
{
PropertyInfo property = (PropertyInfo)memberInfo;
MethodInfo setMethod = property.GetSetMethod(true /*nonPublic*/);
if (setMethod != null)
return DataContract.MethodRequiresMemberAccess(setMethod) || !DataContract.IsTypeVisible(property.PropertyType);
}
return false;
}
internal DataMember BindGenericParameters(DataContract[] paramContracts, Dictionary boundContracts)
{
DataContract memberTypeContract = this.MemberTypeContract.BindGenericParameters(paramContracts, boundContracts);
DataMember boundDataMember = new DataMember(memberTypeContract,
this.Name,
!memberTypeContract.IsValueType,
this.IsRequired,
this.EmitDefaultValue,
this.Order);
return boundDataMember;
}
internal bool Equals(object other, Dictionary checkedContracts)
{
if ((object) this == other)
return true;
DataMember dataMember = other as DataMember;
if (dataMember != null)
{
// Note: comparison does not use Order hint since it influences element order but does not specify exact order
bool thisIsNullable = (MemberTypeContract == null) ? false : !MemberTypeContract.IsValueType;
bool dataMemberIsNullable = (dataMember.MemberTypeContract == null) ? false : !dataMember.MemberTypeContract.IsValueType;
return (Name == dataMember.Name
&& (IsNullable || thisIsNullable) == (dataMember.IsNullable || dataMemberIsNullable)
&& IsRequired == dataMember.IsRequired
&& EmitDefaultValue == dataMember.EmitDefaultValue
&& MemberTypeContract.Equals(dataMember.MemberTypeContract, checkedContracts));
}
return false;
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime.Serialization
{
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Security;
class DataMember
{
[Fx.Tag.SecurityNote(Critical = "Holds instance of CriticalHelper which keeps state that is cached statically for serialization."
+ " Static fields are marked SecurityCritical or readonly to prevent data from being modified or leaked to other components in appdomain.")]
[SecurityCritical]
CriticalHelper helper;
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember()
{
helper = new CriticalHelper();
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember(MemberInfo memberInfo)
{
helper = new CriticalHelper(memberInfo);
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember(string name)
{
helper = new CriticalHelper(name);
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'.",
Safe = "Doesn't leak anything.")]
[SecuritySafeCritical]
internal DataMember(DataContract memberTypeContract, string name, bool isNullable, bool isRequired, bool emitDefaultValue, int order)
{
helper = new CriticalHelper(memberTypeContract, name, isNullable, isRequired, emitDefaultValue, order);
}
internal MemberInfo MemberInfo
{
[SecuritySafeCritical]
get { return helper.MemberInfo; }
}
internal string Name
{
[SecuritySafeCritical]
get { return helper.Name; }
[SecurityCritical]
set { helper.Name = value; }
}
internal int Order
{
[SecuritySafeCritical]
get { return helper.Order; }
[SecurityCritical]
set { helper.Order = value; }
}
internal bool IsRequired
{
[SecuritySafeCritical]
get { return helper.IsRequired; }
[SecurityCritical]
set { helper.IsRequired = value; }
}
internal bool EmitDefaultValue
{
[SecuritySafeCritical]
get { return helper.EmitDefaultValue; }
[SecurityCritical]
set { helper.EmitDefaultValue = value; }
}
internal bool IsNullable
{
[SecuritySafeCritical]
get { return helper.IsNullable; }
[SecurityCritical]
set { helper.IsNullable = value; }
}
internal bool IsGetOnlyCollection
{
[SecuritySafeCritical]
get { return helper.IsGetOnlyCollection; }
[SecurityCritical]
set { helper.IsGetOnlyCollection = value; }
}
internal Type MemberType
{
[SecuritySafeCritical]
get { return helper.MemberType; }
}
internal DataContract MemberTypeContract
{
[SecuritySafeCritical]
get { return helper.MemberTypeContract; }
[SecurityCritical]
set { helper.MemberTypeContract = value; }
}
internal bool HasConflictingNameAndType
{
[SecuritySafeCritical]
get { return helper.HasConflictingNameAndType; }
[SecurityCritical]
set { helper.HasConflictingNameAndType = value; }
}
internal DataMember ConflictingMember
{
[SecuritySafeCritical]
get { return helper.ConflictingMember; }
[SecurityCritical]
set { helper.ConflictingMember = value; }
}
[Fx.Tag.SecurityNote(Critical = "Critical.")]
[SecurityCritical(SecurityCriticalScope.Everything)]
class CriticalHelper
{
DataContract memberTypeContract;
string name;
int order;
bool isRequired;
bool emitDefaultValue;
bool isNullable;
bool isGetOnlyCollection = false;
MemberInfo memberInfo;
bool hasConflictingNameAndType;
DataMember conflictingMember;
internal CriticalHelper()
{
this.emitDefaultValue = Globals.DefaultEmitDefaultValue;
}
internal CriticalHelper(MemberInfo memberInfo)
{
this.emitDefaultValue = Globals.DefaultEmitDefaultValue;
this.memberInfo = memberInfo;
}
internal CriticalHelper(string name)
{
this.Name = name;
}
internal CriticalHelper(DataContract memberTypeContract, string name, bool isNullable, bool isRequired, bool emitDefaultValue, int order)
{
this.MemberTypeContract = memberTypeContract;
this.Name = name;
this.IsNullable = isNullable;
this.IsRequired = isRequired;
this.EmitDefaultValue = emitDefaultValue;
this.Order = order;
}
internal MemberInfo MemberInfo
{
get { return memberInfo; }
}
internal string Name
{
get { return name; }
set { name = value; }
}
internal int Order
{
get { return order; }
set { order = value; }
}
internal bool IsRequired
{
get { return isRequired; }
set { isRequired = value; }
}
internal bool EmitDefaultValue
{
get { return emitDefaultValue; }
set { emitDefaultValue = value; }
}
internal bool IsNullable
{
get { return isNullable; }
set { isNullable = value; }
}
internal bool IsGetOnlyCollection
{
get { return isGetOnlyCollection; }
set { isGetOnlyCollection = value; }
}
internal Type MemberType
{
get
{
FieldInfo field = MemberInfo as FieldInfo;
if (field != null)
return field.FieldType;
return ((PropertyInfo)MemberInfo).PropertyType;
}
}
internal DataContract MemberTypeContract
{
get
{
if (memberTypeContract == null)
{
if (MemberInfo != null)
{
if (this.IsGetOnlyCollection)
{
memberTypeContract = DataContract.GetGetOnlyCollectionDataContract(DataContract.GetId(MemberType.TypeHandle), MemberType.TypeHandle, MemberType, SerializationMode.SharedContract);
}
else
{
memberTypeContract = DataContract.GetDataContract(MemberType);
}
}
}
return memberTypeContract;
}
set
{
memberTypeContract = value;
}
}
internal bool HasConflictingNameAndType
{
get { return this.hasConflictingNameAndType; }
set { this.hasConflictingNameAndType = value; }
}
internal DataMember ConflictingMember
{
get { return this.conflictingMember; }
set { this.conflictingMember = value; }
}
}
[Fx.Tag.SecurityNote(Miscellaneous = "RequiresReview - checks member visibility to calculate if access to it requires MemberAccessPermission for serialization."
+ " Since this information is used to determine whether to give the generated code access"
+ " permissions to private members, any changes to the logic should be reviewed.")]
internal bool RequiresMemberAccessForGet()
{
MemberInfo memberInfo = MemberInfo;
FieldInfo field = memberInfo as FieldInfo;
if (field != null)
{
return DataContract.FieldRequiresMemberAccess(field);
}
else
{
PropertyInfo property = (PropertyInfo)memberInfo;
MethodInfo getMethod = property.GetGetMethod(true /*nonPublic*/);
if (getMethod != null)
return DataContract.MethodRequiresMemberAccess(getMethod) || !DataContract.IsTypeVisible(property.PropertyType);
}
return false;
}
[Fx.Tag.SecurityNote(Miscellaneous = "RequiresReview - checks member visibility to calculate if access to it requires MemberAccessPermission for deserialization."
+ " Since this information is used to determine whether to give the generated code access"
+ " permissions to private members, any changes to the logic should be reviewed.")]
internal bool RequiresMemberAccessForSet()
{
MemberInfo memberInfo = MemberInfo;
FieldInfo field = memberInfo as FieldInfo;
if (field != null)
{
return DataContract.FieldRequiresMemberAccess(field);
}
else
{
PropertyInfo property = (PropertyInfo)memberInfo;
MethodInfo setMethod = property.GetSetMethod(true /*nonPublic*/);
if (setMethod != null)
return DataContract.MethodRequiresMemberAccess(setMethod) || !DataContract.IsTypeVisible(property.PropertyType);
}
return false;
}
internal DataMember BindGenericParameters(DataContract[] paramContracts, Dictionary boundContracts)
{
DataContract memberTypeContract = this.MemberTypeContract.BindGenericParameters(paramContracts, boundContracts);
DataMember boundDataMember = new DataMember(memberTypeContract,
this.Name,
!memberTypeContract.IsValueType,
this.IsRequired,
this.EmitDefaultValue,
this.Order);
return boundDataMember;
}
internal bool Equals(object other, Dictionary checkedContracts)
{
if ((object) this == other)
return true;
DataMember dataMember = other as DataMember;
if (dataMember != null)
{
// Note: comparison does not use Order hint since it influences element order but does not specify exact order
bool thisIsNullable = (MemberTypeContract == null) ? false : !MemberTypeContract.IsValueType;
bool dataMemberIsNullable = (dataMember.MemberTypeContract == null) ? false : !dataMember.MemberTypeContract.IsValueType;
return (Name == dataMember.Name
&& (IsNullable || thisIsNullable) == (dataMember.IsNullable || dataMemberIsNullable)
&& IsRequired == dataMember.IsRequired
&& EmitDefaultValue == dataMember.EmitDefaultValue
&& MemberTypeContract.Equals(dataMember.MemberTypeContract, checkedContracts));
}
return false;
}
public override int GetHashCode()
{
return base.GetHashCode();
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ValidationSummaryDesigner.cs
- DecimalConstantAttribute.cs
- CircleHotSpot.cs
- OracleFactory.cs
- EdgeProfileValidation.cs
- TabItemWrapperAutomationPeer.cs
- WebPartConnectionsConnectVerb.cs
- SafeMILHandle.cs
- DelegatingConfigHost.cs
- ResolveCriteria.cs
- ImageMetadata.cs
- X509Certificate2.cs
- UnauthorizedWebPart.cs
- XmlSchemaFacet.cs
- AppDomainManager.cs
- MenuItemAutomationPeer.cs
- ExpressionParser.cs
- LeaseManager.cs
- SecurityTokenValidationException.cs
- XpsLiterals.cs
- EditorResources.cs
- OdbcConnectionHandle.cs
- LayoutTable.cs
- HandleCollector.cs
- FlowNode.cs
- TerminatorSinks.cs
- GlyphTypeface.cs
- WhitespaceSignificantCollectionAttribute.cs
- EntityClassGenerator.cs
- MergablePropertyAttribute.cs
- ConditionalAttribute.cs
- VirtualPathData.cs
- DefaultEventAttribute.cs
- EventProviderWriter.cs
- LabelInfo.cs
- ConstraintConverter.cs
- BinaryReader.cs
- InternalDuplexChannelListener.cs
- HMAC.cs
- UnaryNode.cs
- DataGridHeaderBorder.cs
- PersonalizationProvider.cs
- ConstraintManager.cs
- XmlHierarchicalDataSourceView.cs
- ExpressionHelper.cs
- BamlReader.cs
- HandledEventArgs.cs
- ActivityBuilderXamlWriter.cs
- IdentityHolder.cs
- Graphics.cs
- StreamWriter.cs
- DefaultCompensation.cs
- ConfigPathUtility.cs
- SerializationInfoEnumerator.cs
- MonthCalendarDesigner.cs
- MatchSingleFxEngineOpcode.cs
- CriticalFinalizerObject.cs
- DataTableCollection.cs
- DeferredReference.cs
- MultipartContentParser.cs
- StandardOleMarshalObject.cs
- CommandHelper.cs
- MarkupExtensionReturnTypeAttribute.cs
- StaticResourceExtension.cs
- LineServicesCallbacks.cs
- HttpAsyncResult.cs
- PixelFormats.cs
- FontCollection.cs
- IDictionary.cs
- IxmlLineInfo.cs
- HtmlTernaryTree.cs
- MD5CryptoServiceProvider.cs
- PersistenceTask.cs
- RuleConditionDialog.Designer.cs
- SoapEnvelopeProcessingElement.cs
- AccessibleObject.cs
- TransformerInfoCollection.cs
- TimeSpanConverter.cs
- SqlExpressionNullability.cs
- WebPartManager.cs
- RegexMatch.cs
- HttpStaticObjectsCollectionWrapper.cs
- UInt64Converter.cs
- HttpHandlersInstallComponent.cs
- ReliableSessionBindingElementImporter.cs
- TranslateTransform.cs
- HtmlImage.cs
- SqlTopReducer.cs
- WebPartDisplayMode.cs
- DateTimeFormatInfo.cs
- RegisteredArrayDeclaration.cs
- DispatcherEventArgs.cs
- PasswordDeriveBytes.cs
- CapabilitiesSection.cs
- AccessibilityHelperForXpWin2k3.cs
- LinqDataSource.cs
- WinFormsSecurity.cs
- XmlDataSourceDesigner.cs
- UntrustedRecipientException.cs
- HttpCapabilitiesSectionHandler.cs