|
//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.Runtime.Serialization
{
using System;
using System.Collections;
using System.Reflection;
using System.Security;
using System.Xml;
[Fx.Tag.SecurityNote(Critical = "Class holds static instances used for code generation during serialization."
+ " Static fields are marked SecurityCritical or readonly to prevent data from being modified or leaked to other components in appdomain.",
Safe = "All get-only properties marked safe since they only need to be protected for write.")]
static class XmlFormatGeneratorStatics
{
[SecurityCritical]
static MethodInfo writeStartElementMethod2;
internal static MethodInfo WriteStartElementMethod2
{
[SecuritySafeCritical]
get
{
if (writeStartElementMethod2 == null)
writeStartElementMethod2 = typeof(XmlWriterDelegator).GetMethod("WriteStartElement", Globals.ScanAllMembers, null, new Type[] { typeof(XmlDictionaryString), typeof(XmlDictionaryString) }, null);
return writeStartElementMethod2;
}
}
[SecurityCritical]
static MethodInfo writeStartElementMethod3;
internal static MethodInfo WriteStartElementMethod3
{
[SecuritySafeCritical]
get
{
if (writeStartElementMethod3 == null)
writeStartElementMethod3 = typeof(XmlWriterDelegator).GetMethod("WriteStartElement", Globals.ScanAllMembers, null, new Type[] { typeof(string), typeof(XmlDictionaryString), typeof(XmlDictionaryString) }, null);
return writeStartElementMethod3;
}
}
[SecurityCritical]
static MethodInfo writeEndElementMethod;
internal static MethodInfo WriteEndElementMethod
{
[SecuritySafeCritical]
get
{
if (writeEndElementMethod == null)
writeEndElementMethod = typeof(XmlWriterDelegator).GetMethod("WriteEndElement", Globals.ScanAllMembers, null, new Type[] { }, null);
return writeEndElementMethod;
}
}
[SecurityCritical]
static MethodInfo writeNamespaceDeclMethod;
internal static MethodInfo WriteNamespaceDeclMethod
{
[SecuritySafeCritical]
get
{
if (writeNamespaceDeclMethod == null)
writeNamespaceDeclMethod = typeof(XmlWriterDelegator).GetMethod("WriteNamespaceDecl", Globals.ScanAllMembers, null, new Type[] { typeof(XmlDictionaryString) }, null);
return writeNamespaceDeclMethod;
}
}
[SecurityCritical]
static PropertyInfo extensionDataProperty;
internal static PropertyInfo ExtensionDataProperty
{
[SecuritySafeCritical]
get
{
if (extensionDataProperty == null)
extensionDataProperty = typeof(IExtensibleDataObject).GetProperty("ExtensionData");
return extensionDataProperty;
}
}
[SecurityCritical]
static MethodInfo boxPointer;
internal static MethodInfo BoxPointer
{
[SecuritySafeCritical]
get
{
if (boxPointer == null)
boxPointer = typeof(Pointer).GetMethod("Box");
return boxPointer;
}
}
[SecurityCritical]
static ConstructorInfo dictionaryEnumeratorCtor;
internal static ConstructorInfo DictionaryEnumeratorCtor
{
[SecuritySafeCritical]
get
{
if (dictionaryEnumeratorCtor == null)
dictionaryEnumeratorCtor = Globals.TypeOfDictionaryEnumerator.GetConstructor(Globals.ScanAllMembers, null, new Type[] { Globals.TypeOfIDictionaryEnumerator }, null);
return dictionaryEnumeratorCtor;
}
}
[SecurityCritical]
static MethodInfo ienumeratorMoveNextMethod;
internal static MethodInfo MoveNextMethod
{
[SecuritySafeCritical]
get
{
if (ienumeratorMoveNextMethod == null)
ienumeratorMoveNextMethod = typeof(IEnumerator).GetMethod("MoveNext");
return ienumeratorMoveNextMethod;
}
}
[SecurityCritical]
static MethodInfo ienumeratorGetCurrentMethod;
internal static MethodInfo GetCurrentMethod
{
[SecuritySafeCritical]
get
{
if (ienumeratorGetCurrentMethod == null)
ienumeratorGetCurrentMethod = typeof(IEnumerator).GetProperty("Current").GetGetMethod();
return ienumeratorGetCurrentMethod;
}
}
[SecurityCritical]
static MethodInfo getItemContractMethod;
internal static MethodInfo GetItemContractMethod
{
[SecuritySafeCritical]
get
{
if (getItemContractMethod == null)
getItemContractMethod = typeof(CollectionDataContract).GetProperty("ItemContract", Globals.ScanAllMembers).GetGetMethod(true/*nonPublic*/);
return getItemContractMethod;
}
}
[SecurityCritical]
static MethodInfo isStartElementMethod2;
internal static MethodInfo IsStartElementMethod2
{
[SecuritySafeCritical]
get
{
if (isStartElementMethod2 == null)
isStartElementMethod2 = typeof(XmlReaderDelegator).GetMethod("IsStartElement", Globals.ScanAllMembers, null, new Type[] { typeof(XmlDictionaryString), typeof(XmlDictionaryString) }, null);
return isStartElementMethod2;
}
}
[SecurityCritical]
static MethodInfo isStartElementMethod0;
internal static MethodInfo IsStartElementMethod0
{
[SecuritySafeCritical]
get
{
if (isStartElementMethod0 == null)
isStartElementMethod0 = typeof(XmlReaderDelegator).GetMethod("IsStartElement", Globals.ScanAllMembers, null, new Type[] { }, null);
return isStartElementMethod0;
}
}
[SecurityCritical]
static MethodInfo getUninitializedObjectMethod;
internal static MethodInfo GetUninitializedObjectMethod
{
[SecuritySafeCritical]
get
{
if (getUninitializedObjectMethod == null)
getUninitializedObjectMethod = typeof(XmlFormatReaderGenerator).GetMethod("UnsafeGetUninitializedObject", Globals.ScanAllMembers, null, new Type[] { typeof(int) }, null);
return getUninitializedObjectMethod;
}
}
[SecurityCritical]
static MethodInfo onDeserializationMethod;
internal static MethodInfo OnDeserializationMethod
{
[SecuritySafeCritical]
get
{
if (onDeserializationMethod == null)
onDeserializationMethod = typeof(IDeserializationCallback).GetMethod("OnDeserialization");
return onDeserializationMethod;
}
}
[SecurityCritical]
static MethodInfo unboxPointer;
internal static MethodInfo UnboxPointer
{
[SecuritySafeCritical]
get
{
if (unboxPointer == null)
unboxPointer = typeof(Pointer).GetMethod("Unbox");
return unboxPointer;
}
}
[SecurityCritical]
static PropertyInfo nodeTypeProperty;
internal static PropertyInfo NodeTypeProperty
{
[SecuritySafeCritical]
get
{
if (nodeTypeProperty == null)
nodeTypeProperty = typeof(XmlReaderDelegator).GetProperty("NodeType", Globals.ScanAllMembers);
return nodeTypeProperty;
}
}
[SecurityCritical]
static ConstructorInfo serializationExceptionCtor;
internal static ConstructorInfo SerializationExceptionCtor
{
[SecuritySafeCritical]
get
{
if (serializationExceptionCtor == null)
serializationExceptionCtor = typeof(SerializationException).GetConstructor(new Type[] { typeof(string) });
return serializationExceptionCtor;
}
}
[SecurityCritical]
static ConstructorInfo extensionDataObjectCtor;
internal static ConstructorInfo ExtensionDataObjectCtor
{
[SecuritySafeCritical]
get
{
if (extensionDataObjectCtor == null)
extensionDataObjectCtor = typeof(ExtensionDataObject).GetConstructor(Globals.ScanAllMembers, null, new Type[] { }, null);
return extensionDataObjectCtor;
}
}
[SecurityCritical]
static ConstructorInfo hashtableCtor;
internal static ConstructorInfo HashtableCtor
{
[SecuritySafeCritical]
get
{
if (hashtableCtor == null)
hashtableCtor = Globals.TypeOfHashtable.GetConstructor(Globals.ScanAllMembers, null, Globals.EmptyTypeArray, null);
return hashtableCtor;
}
}
[SecurityCritical]
static MethodInfo getStreamingContextMethod;
internal static MethodInfo GetStreamingContextMethod
{
[SecuritySafeCritical]
get
{
if (getStreamingContextMethod == null)
getStreamingContextMethod = typeof(XmlObjectSerializerContext).GetMethod("GetStreamingContext", Globals.ScanAllMembers);
return getStreamingContextMethod;
}
}
[SecurityCritical]
static MethodInfo getCollectionMemberMethod;
internal static MethodInfo GetCollectionMemberMethod
{
[SecuritySafeCritical]
get
{
if (getCollectionMemberMethod == null)
getCollectionMemberMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetCollectionMember", Globals.ScanAllMembers);
return getCollectionMemberMethod;
}
}
[SecurityCritical]
static MethodInfo storeCollectionMemberInfoMethod;
internal static MethodInfo StoreCollectionMemberInfoMethod
{
[SecuritySafeCritical]
get
{
if (storeCollectionMemberInfoMethod == null)
storeCollectionMemberInfoMethod = typeof(XmlObjectSerializerReadContext).GetMethod("StoreCollectionMemberInfo", Globals.ScanAllMembers, null, new Type[] { typeof(object) }, null);
return storeCollectionMemberInfoMethod;
}
}
[SecurityCritical]
static MethodInfo storeIsGetOnlyCollectionMethod;
internal static MethodInfo StoreIsGetOnlyCollectionMethod
{
[SecuritySafeCritical]
get
{
if (storeIsGetOnlyCollectionMethod == null)
storeIsGetOnlyCollectionMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("StoreIsGetOnlyCollection", Globals.ScanAllMembers);
return storeIsGetOnlyCollectionMethod;
}
}
[SecurityCritical]
static MethodInfo throwNullValueReturnedForGetOnlyCollectionExceptionMethod;
internal static MethodInfo ThrowNullValueReturnedForGetOnlyCollectionExceptionMethod
{
[SecuritySafeCritical]
get
{
if (throwNullValueReturnedForGetOnlyCollectionExceptionMethod == null)
throwNullValueReturnedForGetOnlyCollectionExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ThrowNullValueReturnedForGetOnlyCollectionException", Globals.ScanAllMembers);
return throwNullValueReturnedForGetOnlyCollectionExceptionMethod;
}
}
static MethodInfo throwArrayExceededSizeExceptionMethod;
internal static MethodInfo ThrowArrayExceededSizeExceptionMethod
{
[SecuritySafeCritical]
get
{
if (throwArrayExceededSizeExceptionMethod == null)
throwArrayExceededSizeExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ThrowArrayExceededSizeException", Globals.ScanAllMembers);
return throwArrayExceededSizeExceptionMethod;
}
}
[SecurityCritical]
static MethodInfo incrementItemCountMethod;
internal static MethodInfo IncrementItemCountMethod
{
[SecuritySafeCritical]
get
{
if (incrementItemCountMethod == null)
incrementItemCountMethod = typeof(XmlObjectSerializerContext).GetMethod("IncrementItemCount", Globals.ScanAllMembers);
return incrementItemCountMethod;
}
}
[Fx.Tag.SecurityNote(Critical = "Holds instance of SecurityPermission that we will Demand for SerializationFormatter."
+ " Should not be modified to something else.")]
[SecurityCritical]
static MethodInfo demandSerializationFormatterPermissionMethod;
internal static MethodInfo DemandSerializationFormatterPermissionMethod
{
[Fx.Tag.SecurityNote(Critical = "Demands SerializationFormatter permission. Demanding the right permission is critical.",
Safe = "No data or control leaks in or out, must be callable from transparent generated IL.")]
[SecuritySafeCritical]
get
{
if (demandSerializationFormatterPermissionMethod == null)
demandSerializationFormatterPermissionMethod = typeof(XmlObjectSerializerContext).GetMethod("DemandSerializationFormatterPermission", Globals.ScanAllMembers);
return demandSerializationFormatterPermissionMethod;
}
}
[Fx.Tag.SecurityNote(Critical = "Holds instance of SecurityPermission that we will Demand for MemberAccess."
+ " Should not be modified to something else.")]
[SecurityCritical]
static MethodInfo demandMemberAccessPermissionMethod;
internal static MethodInfo DemandMemberAccessPermissionMethod
{
[Fx.Tag.SecurityNote(Critical = "Demands MemberAccess permission. Demanding the right permission is critical.",
Safe = "No data or control leaks in or out, must be callable from transparent generated IL.")]
[SecuritySafeCritical]
get
{
if (demandMemberAccessPermissionMethod == null)
demandMemberAccessPermissionMethod = typeof(XmlObjectSerializerContext).GetMethod("DemandMemberAccessPermission", Globals.ScanAllMembers);
return demandMemberAccessPermissionMethod;
}
}
[SecurityCritical]
static MethodInfo internalDeserializeMethod;
internal static MethodInfo InternalDeserializeMethod
{
[SecuritySafeCritical]
get
{
if (internalDeserializeMethod == null)
internalDeserializeMethod = typeof(XmlObjectSerializerReadContext).GetMethod("InternalDeserialize", Globals.ScanAllMembers, null, new Type[] { typeof(XmlReaderDelegator), typeof(int), typeof(RuntimeTypeHandle), typeof(string), typeof(string) }, null);
return internalDeserializeMethod;
}
}
[SecurityCritical]
static MethodInfo moveToNextElementMethod;
internal static MethodInfo MoveToNextElementMethod
{
[SecuritySafeCritical]
get
{
if (moveToNextElementMethod == null)
moveToNextElementMethod = typeof(XmlObjectSerializerReadContext).GetMethod("MoveToNextElement", Globals.ScanAllMembers);
return moveToNextElementMethod;
}
}
[SecurityCritical]
static MethodInfo getMemberIndexMethod;
internal static MethodInfo GetMemberIndexMethod
{
[SecuritySafeCritical]
get
{
if (getMemberIndexMethod == null)
getMemberIndexMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetMemberIndex", Globals.ScanAllMembers);
return getMemberIndexMethod;
}
}
[SecurityCritical]
static MethodInfo getMemberIndexWithRequiredMembersMethod;
internal static MethodInfo GetMemberIndexWithRequiredMembersMethod
{
[SecuritySafeCritical]
get
{
if (getMemberIndexWithRequiredMembersMethod == null)
getMemberIndexWithRequiredMembersMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetMemberIndexWithRequiredMembers", Globals.ScanAllMembers);
return getMemberIndexWithRequiredMembersMethod;
}
}
[SecurityCritical]
static MethodInfo throwRequiredMemberMissingExceptionMethod;
internal static MethodInfo ThrowRequiredMemberMissingExceptionMethod
{
[SecuritySafeCritical]
get
{
if (throwRequiredMemberMissingExceptionMethod == null)
throwRequiredMemberMissingExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ThrowRequiredMemberMissingException", Globals.ScanAllMembers);
return throwRequiredMemberMissingExceptionMethod;
}
}
[SecurityCritical]
static MethodInfo skipUnknownElementMethod;
internal static MethodInfo SkipUnknownElementMethod
{
[SecuritySafeCritical]
get
{
if (skipUnknownElementMethod == null)
skipUnknownElementMethod = typeof(XmlObjectSerializerReadContext).GetMethod("SkipUnknownElement", Globals.ScanAllMembers);
return skipUnknownElementMethod;
}
}
[SecurityCritical]
static MethodInfo readIfNullOrRefMethod;
internal static MethodInfo ReadIfNullOrRefMethod
{
[SecuritySafeCritical]
get
{
if (readIfNullOrRefMethod == null)
readIfNullOrRefMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ReadIfNullOrRef", Globals.ScanAllMembers, null, new Type[] { typeof(XmlReaderDelegator), typeof(Type), typeof(bool) }, null);
return readIfNullOrRefMethod;
}
}
[SecurityCritical]
static MethodInfo readAttributesMethod;
internal static MethodInfo ReadAttributesMethod
{
[SecuritySafeCritical]
get
{
if (readAttributesMethod == null)
readAttributesMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ReadAttributes", Globals.ScanAllMembers);
return readAttributesMethod;
}
}
[SecurityCritical]
static MethodInfo resetAttributesMethod;
internal static MethodInfo ResetAttributesMethod
{
[SecuritySafeCritical]
get
{
if (resetAttributesMethod == null)
resetAttributesMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ResetAttributes", Globals.ScanAllMembers);
return resetAttributesMethod;
}
}
[SecurityCritical]
static MethodInfo getObjectIdMethod;
internal static MethodInfo GetObjectIdMethod
{
[SecuritySafeCritical]
get
{
if (getObjectIdMethod == null)
getObjectIdMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetObjectId", Globals.ScanAllMembers);
return getObjectIdMethod;
}
}
[SecurityCritical]
static MethodInfo getArraySizeMethod;
internal static MethodInfo GetArraySizeMethod
{
[SecuritySafeCritical]
get
{
if (getArraySizeMethod == null)
getArraySizeMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetArraySize", Globals.ScanAllMembers);
return getArraySizeMethod;
}
}
[SecurityCritical]
static MethodInfo addNewObjectMethod;
internal static MethodInfo AddNewObjectMethod
{
[SecuritySafeCritical]
get
{
if (addNewObjectMethod == null)
addNewObjectMethod = typeof(XmlObjectSerializerReadContext).GetMethod("AddNewObject", Globals.ScanAllMembers);
return addNewObjectMethod;
}
}
[SecurityCritical]
static MethodInfo addNewObjectWithIdMethod;
internal static MethodInfo AddNewObjectWithIdMethod
{
[SecuritySafeCritical]
get
{
if (addNewObjectWithIdMethod == null)
addNewObjectWithIdMethod = typeof(XmlObjectSerializerReadContext).GetMethod("AddNewObjectWithId", Globals.ScanAllMembers);
return addNewObjectWithIdMethod;
}
}
[SecurityCritical]
static MethodInfo replaceDeserializedObjectMethod;
internal static MethodInfo ReplaceDeserializedObjectMethod
{
[SecuritySafeCritical]
get
{
if (replaceDeserializedObjectMethod == null)
replaceDeserializedObjectMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ReplaceDeserializedObject", Globals.ScanAllMembers);
return replaceDeserializedObjectMethod;
}
}
[SecurityCritical]
static MethodInfo getExistingObjectMethod;
internal static MethodInfo GetExistingObjectMethod
{
[SecuritySafeCritical]
get
{
if (getExistingObjectMethod == null)
getExistingObjectMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetExistingObject", Globals.ScanAllMembers);
return getExistingObjectMethod;
}
}
[SecurityCritical]
static MethodInfo getRealObjectMethod;
internal static MethodInfo GetRealObjectMethod
{
[SecuritySafeCritical]
get
{
if (getRealObjectMethod == null)
getRealObjectMethod = typeof(XmlObjectSerializerReadContext).GetMethod("GetRealObject", Globals.ScanAllMembers);
return getRealObjectMethod;
}
}
[SecurityCritical]
static MethodInfo readMethod;
internal static MethodInfo ReadMethod
{
[SecuritySafeCritical]
get
{
if (readMethod == null)
readMethod = typeof(XmlObjectSerializerReadContext).GetMethod("Read", Globals.ScanAllMembers);
return readMethod;
}
}
[SecurityCritical]
static MethodInfo ensureArraySizeMethod;
internal static MethodInfo EnsureArraySizeMethod
{
[SecuritySafeCritical]
get
{
if (ensureArraySizeMethod == null)
ensureArraySizeMethod = typeof(XmlObjectSerializerReadContext).GetMethod("EnsureArraySize", Globals.ScanAllMembers);
return ensureArraySizeMethod;
}
}
[SecurityCritical]
static MethodInfo trimArraySizeMethod;
internal static MethodInfo TrimArraySizeMethod
{
[SecuritySafeCritical]
get
{
if (trimArraySizeMethod == null)
trimArraySizeMethod = typeof(XmlObjectSerializerReadContext).GetMethod("TrimArraySize", Globals.ScanAllMembers);
return trimArraySizeMethod;
}
}
[SecurityCritical]
static MethodInfo checkEndOfArrayMethod;
internal static MethodInfo CheckEndOfArrayMethod
{
[SecuritySafeCritical]
get
{
if (checkEndOfArrayMethod == null)
checkEndOfArrayMethod = typeof(XmlObjectSerializerReadContext).GetMethod("CheckEndOfArray", Globals.ScanAllMembers);
return checkEndOfArrayMethod;
}
}
[SecurityCritical]
static MethodInfo getArrayLengthMethod;
internal static MethodInfo GetArrayLengthMethod
{
[SecuritySafeCritical]
get
{
if (getArrayLengthMethod == null)
getArrayLengthMethod = Globals.TypeOfArray.GetProperty("Length").GetGetMethod();
return getArrayLengthMethod;
}
}
[SecurityCritical]
static MethodInfo readSerializationInfoMethod;
internal static MethodInfo ReadSerializationInfoMethod
{
[SecuritySafeCritical]
get
{
if (readSerializationInfoMethod == null)
readSerializationInfoMethod = typeof(XmlObjectSerializerReadContext).GetMethod("ReadSerializationInfo", Globals.ScanAllMembers);
return readSerializationInfoMethod;
}
}
[SecurityCritical]
static MethodInfo createUnexpectedStateExceptionMethod;
internal static MethodInfo CreateUnexpectedStateExceptionMethod
{
[SecuritySafeCritical]
get
{
if (createUnexpectedStateExceptionMethod == null)
createUnexpectedStateExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("CreateUnexpectedStateException", Globals.ScanAllMembers, null, new Type[] { typeof(XmlNodeType), typeof(XmlReaderDelegator) }, null);
return createUnexpectedStateExceptionMethod;
}
}
[SecurityCritical]
static MethodInfo internalSerializeReferenceMethod;
internal static MethodInfo InternalSerializeReferenceMethod
{
[SecuritySafeCritical]
get
{
if (internalSerializeReferenceMethod == null)
internalSerializeReferenceMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("InternalSerializeReference", Globals.ScanAllMembers);
return internalSerializeReferenceMethod;
}
}
[SecurityCritical]
static MethodInfo internalSerializeMethod;
internal static MethodInfo InternalSerializeMethod
{
[SecuritySafeCritical]
get
{
if (internalSerializeMethod == null)
internalSerializeMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("InternalSerialize", Globals.ScanAllMembers);
return internalSerializeMethod;
}
}
[SecurityCritical]
static MethodInfo writeNullMethod;
internal static MethodInfo WriteNullMethod
{
[SecuritySafeCritical]
get
{
if (writeNullMethod == null)
writeNullMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("WriteNull", Globals.ScanAllMembers, null, new Type[] { typeof(XmlWriterDelegator), typeof(Type), typeof(bool) }, null);
return writeNullMethod;
}
}
[SecurityCritical]
static MethodInfo incrementArrayCountMethod;
internal static MethodInfo IncrementArrayCountMethod
{
[SecuritySafeCritical]
get
{
if (incrementArrayCountMethod == null)
incrementArrayCountMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("IncrementArrayCount", Globals.ScanAllMembers);
return incrementArrayCountMethod;
}
}
[SecurityCritical]
static MethodInfo incrementCollectionCountMethod;
internal static MethodInfo IncrementCollectionCountMethod
{
[SecuritySafeCritical]
get
{
if (incrementCollectionCountMethod == null)
incrementCollectionCountMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("IncrementCollectionCount", Globals.ScanAllMembers, null, new Type[] { typeof(XmlWriterDelegator), typeof(ICollection) }, null);
return incrementCollectionCountMethod;
}
}
[SecurityCritical]
static MethodInfo incrementCollectionCountGenericMethod;
internal static MethodInfo IncrementCollectionCountGenericMethod
{
[SecuritySafeCritical]
get
{
if (incrementCollectionCountGenericMethod == null)
incrementCollectionCountGenericMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("IncrementCollectionCountGeneric", Globals.ScanAllMembers);
return incrementCollectionCountGenericMethod;
}
}
[SecurityCritical]
static MethodInfo getDefaultValueMethod;
internal static MethodInfo GetDefaultValueMethod
{
[SecuritySafeCritical]
get
{
if (getDefaultValueMethod == null)
getDefaultValueMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("GetDefaultValue", Globals.ScanAllMembers);
return getDefaultValueMethod;
}
}
[SecurityCritical]
static MethodInfo getNullableValueMethod;
internal static MethodInfo GetNullableValueMethod
{
[SecuritySafeCritical]
get
{
if (getNullableValueMethod == null)
getNullableValueMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("GetNullableValue", Globals.ScanAllMembers);
return getNullableValueMethod;
}
}
[SecurityCritical]
static MethodInfo throwRequiredMemberMustBeEmittedMethod;
internal static MethodInfo ThrowRequiredMemberMustBeEmittedMethod
{
[SecuritySafeCritical]
get
{
if (throwRequiredMemberMustBeEmittedMethod == null)
throwRequiredMemberMustBeEmittedMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("ThrowRequiredMemberMustBeEmitted", Globals.ScanAllMembers);
return throwRequiredMemberMustBeEmittedMethod;
}
}
[SecurityCritical]
static MethodInfo getHasValueMethod;
internal static MethodInfo GetHasValueMethod
{
[SecuritySafeCritical]
get
{
if (getHasValueMethod == null)
getHasValueMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("GetHasValue", Globals.ScanAllMembers);
return getHasValueMethod;
}
}
[SecurityCritical]
static MethodInfo writeISerializableMethod;
internal static MethodInfo WriteISerializableMethod
{
[SecuritySafeCritical]
get
{
if (writeISerializableMethod == null)
writeISerializableMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("WriteISerializable", Globals.ScanAllMembers);
return writeISerializableMethod;
}
}
[SecurityCritical]
static MethodInfo writeExtensionDataMethod;
internal static MethodInfo WriteExtensionDataMethod
{
[SecuritySafeCritical]
get
{
if (writeExtensionDataMethod == null)
writeExtensionDataMethod = typeof(XmlObjectSerializerWriteContext).GetMethod("WriteExtensionData", Globals.ScanAllMembers);
return writeExtensionDataMethod;
}
}
[SecurityCritical]
static MethodInfo writeXmlValueMethod;
internal static MethodInfo WriteXmlValueMethod
{
[SecuritySafeCritical]
get
{
if (writeXmlValueMethod == null)
writeXmlValueMethod = typeof(DataContract).GetMethod("WriteXmlValue", Globals.ScanAllMembers);
return writeXmlValueMethod;
}
}
[SecurityCritical]
static MethodInfo readXmlValueMethod;
internal static MethodInfo ReadXmlValueMethod
{
[SecuritySafeCritical]
get
{
if (readXmlValueMethod == null)
readXmlValueMethod = typeof(DataContract).GetMethod("ReadXmlValue", Globals.ScanAllMembers);
return readXmlValueMethod;
}
}
[SecurityCritical]
static MethodInfo throwTypeNotSerializableMethod;
internal static MethodInfo ThrowTypeNotSerializableMethod
{
[SecuritySafeCritical]
get
{
if (throwTypeNotSerializableMethod == null)
throwTypeNotSerializableMethod = typeof(DataContract).GetMethod("ThrowTypeNotSerializable", Globals.ScanAllMembers);
return throwTypeNotSerializableMethod;
}
}
[SecurityCritical]
static PropertyInfo namespaceProperty;
internal static PropertyInfo NamespaceProperty
{
[SecuritySafeCritical]
get
{
if (namespaceProperty == null)
namespaceProperty = typeof(DataContract).GetProperty("Namespace", Globals.ScanAllMembers);
return namespaceProperty;
}
}
[SecurityCritical]
static FieldInfo contractNamespacesField;
internal static FieldInfo ContractNamespacesField
{
[SecuritySafeCritical]
get
{
if (contractNamespacesField == null)
contractNamespacesField = typeof(ClassDataContract).GetField("ContractNamespaces", Globals.ScanAllMembers);
return contractNamespacesField;
}
}
[SecurityCritical]
static FieldInfo memberNamesField;
internal static FieldInfo MemberNamesField
{
[SecuritySafeCritical]
get
{
if (memberNamesField == null)
memberNamesField = typeof(ClassDataContract).GetField("MemberNames", Globals.ScanAllMembers);
return memberNamesField;
}
}
[SecurityCritical]
static MethodInfo extensionDataSetExplicitMethodInfo;
internal static MethodInfo ExtensionDataSetExplicitMethodInfo
{
[SecuritySafeCritical]
get
{
if (extensionDataSetExplicitMethodInfo == null)
extensionDataSetExplicitMethodInfo = typeof(IExtensibleDataObject).GetMethod(Globals.ExtensionDataSetMethod);
return extensionDataSetExplicitMethodInfo;
}
}
[SecurityCritical]
static PropertyInfo childElementNamespacesProperty;
internal static PropertyInfo ChildElementNamespacesProperty
{
[SecuritySafeCritical]
get
{
if (childElementNamespacesProperty == null)
childElementNamespacesProperty = typeof(ClassDataContract).GetProperty("ChildElementNamespaces", Globals.ScanAllMembers);
return childElementNamespacesProperty;
}
}
[SecurityCritical]
static PropertyInfo collectionItemNameProperty;
internal static PropertyInfo CollectionItemNameProperty
{
[SecuritySafeCritical]
get
{
if (collectionItemNameProperty == null)
collectionItemNameProperty = typeof(CollectionDataContract).GetProperty("CollectionItemName", Globals.ScanAllMembers);
return collectionItemNameProperty;
}
}
[SecurityCritical]
static PropertyInfo childElementNamespaceProperty;
internal static PropertyInfo ChildElementNamespaceProperty
{
[SecuritySafeCritical]
get
{
if (childElementNamespaceProperty == null)
childElementNamespaceProperty = typeof(CollectionDataContract).GetProperty("ChildElementNamespace", Globals.ScanAllMembers);
return childElementNamespaceProperty;
}
}
[SecurityCritical]
static MethodInfo getDateTimeOffsetMethod;
internal static MethodInfo GetDateTimeOffsetMethod
{
[SecuritySafeCritical]
get
{
if (getDateTimeOffsetMethod == null)
getDateTimeOffsetMethod = typeof(DateTimeOffsetAdapter).GetMethod("GetDateTimeOffset", Globals.ScanAllMembers);
return getDateTimeOffsetMethod;
}
}
[SecurityCritical]
static MethodInfo getDateTimeOffsetAdapterMethod;
internal static MethodInfo GetDateTimeOffsetAdapterMethod
{
[SecuritySafeCritical]
get
{
if (getDateTimeOffsetAdapterMethod == null)
getDateTimeOffsetAdapterMethod = typeof(DateTimeOffsetAdapter).GetMethod("GetDateTimeOffsetAdapter", Globals.ScanAllMembers);
return getDateTimeOffsetAdapterMethod;
}
}
[SecurityCritical]
static MethodInfo traceInstructionMethod;
internal static MethodInfo TraceInstructionMethod
{
[SecuritySafeCritical]
get
{
if (traceInstructionMethod == null)
traceInstructionMethod = typeof(SerializationTrace).GetMethod("TraceInstruction", Globals.ScanAllMembers);
return traceInstructionMethod;
}
}
[SecurityCritical]
static MethodInfo throwInvalidDataContractExceptionMethod;
internal static MethodInfo ThrowInvalidDataContractExceptionMethod
{
[SecuritySafeCritical]
get
{
if (throwInvalidDataContractExceptionMethod == null)
throwInvalidDataContractExceptionMethod = typeof(DataContract).GetMethod("ThrowInvalidDataContractException", Globals.ScanAllMembers, null, new Type[] { typeof(string), typeof(Type) }, null);
return throwInvalidDataContractExceptionMethod;
}
}
[SecurityCritical]
static PropertyInfo serializeReadOnlyTypesProperty;
internal static PropertyInfo SerializeReadOnlyTypesProperty
{
[SecuritySafeCritical]
get
{
if (serializeReadOnlyTypesProperty == null)
serializeReadOnlyTypesProperty = typeof(XmlObjectSerializerWriteContext).GetProperty("SerializeReadOnlyTypes", Globals.ScanAllMembers);
return serializeReadOnlyTypesProperty;
}
}
[SecurityCritical]
static PropertyInfo classSerializationExceptionMessageProperty;
internal static PropertyInfo ClassSerializationExceptionMessageProperty
{
[SecuritySafeCritical]
get
{
if (classSerializationExceptionMessageProperty == null)
classSerializationExceptionMessageProperty = typeof(ClassDataContract).GetProperty("SerializationExceptionMessage", Globals.ScanAllMembers);
return classSerializationExceptionMessageProperty;
}
}
[SecurityCritical]
static PropertyInfo collectionSerializationExceptionMessageProperty;
internal static PropertyInfo CollectionSerializationExceptionMessageProperty
{
[SecuritySafeCritical]
get
{
if (collectionSerializationExceptionMessageProperty == null)
collectionSerializationExceptionMessageProperty = typeof(CollectionDataContract).GetProperty("SerializationExceptionMessage", Globals.ScanAllMembers);
return collectionSerializationExceptionMessageProperty;
}
}
}
}
|