if (!settingsInitalized)
{
NameValueCollection appSettingsSection = null;
+#if !NO_CONFIGURATION
try
{
appSettingsSection = ConfigurationManager.AppSettings;
}
finally
{
+#endif
if ((appSettingsSection == null) || !int.TryParse(appSettingsSection[MaxMimePartsAppSettingsString], out maxMimeParts))
{
maxMimeParts = DefaultMaxMimeParts;
}
settingsInitalized = true;
+#if !NO_CONFIGURATION
}
+#endif
}
}
}
[Fx.Tag.SecurityNote(Critical = "XmlDictionaryString representing the XML namespaces for members of class."
+ "Statically cached and used from IL generated code.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical]
+#endif
XmlDictionaryString[] childElementNamespaces;
[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.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical]
+#endif
ClassDataContractCriticalHelper helper;
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'",
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'",
Safe = "Doesn't leak anything.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecuritySafeCritical]
+#endif
internal ClassDataContract(Type type)
: base(new ClassDataContractCriticalHelper(type))
{
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical field 'helper'",
Safe = "Doesn't leak anything.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecuritySafeCritical]
+#endif
ClassDataContract(Type type, XmlDictionaryString ns, string[] memberNames)
: base(new ClassDataContractCriticalHelper(type, ns, memberNames))
{
}
[Fx.Tag.SecurityNote(Critical = "Initializes SecurityCritical fields; called from all constructors.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical]
+#endif
void InitClassDataContract()
{
this.helper = base.Helper as ClassDataContractCriticalHelper;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing classes."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class ClassDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
ClassDataContract baseContract;
using System.Reflection;
using System.Threading;
using System.Xml;
+#if !NO_CONFIGURATION
using System.Runtime.Serialization.Configuration;
+#endif
using DataContractDictionary = System.Collections.Generic.Dictionary<System.Xml.XmlQualifiedName, DataContract>;
using System.Security;
using System.Security.Permissions;
}
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing collections. Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class CollectionDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
static Type[] _knownInterfaces;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
+#if !NO_CONFIGURATION
using System.Runtime.Serialization.Configuration;
+#endif
using System.Runtime.Serialization.Diagnostics.Application;
using System.Security;
using System.Text;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing types."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
#if USE_REFEMIT
public class DataContractCriticalHelper
#else
ThrowInvalidDataContractException(SR.GetString(SR.TypeNotSerializable, type), type);
}
+#if !NO_CONFIGURATION
[Fx.Tag.SecurityNote(Critical = "configSection value is fetched under an elevation; need to protected access to it.")]
[SecurityCritical]
static DataContractSerializerSection configSection;
return configSection;
}
}
+#endif
internal static DataContractDictionary ImportKnownTypeAttributes(Type type)
{
[SecuritySafeCritical]
static void LoadKnownTypesFromConfig(Type type, Dictionary<Type, Type> typesChecked, ref DataContractDictionary knownDataContracts)
{
+#if !NO_CONFIGURATION
// Pull known types from config
if (ConfigSection != null)
{
}
}
}
+#endif
}
private static void CheckRootTypeInConfigIsGeneric(Type type, ref Type rootType, ref Type[] genArgs)
ProcessedContracts.Add(dataContract, dataContract);
}
+#if !NO_CODEDOM
internal ContractCodeDomInfo GetContractCodeDomInfo(DataContract dataContract)
{
object info;
{
ProcessedContracts.Add(dataContract, info);
}
+#endif
Dictionary<XmlQualifiedName, object> GetReferencedTypes()
{
if (referencedTypesDictionary == null)
}
[Fx.Tag.SecurityNote(Critical = "Critical.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class CriticalHelper
{
DataContract memberTypeContract;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing enums."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class EnumDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
static Dictionary<Type, XmlQualifiedName> typeToName;
[Fx.Tag.SecurityNote(Critical = "Holds state used for deaing with generic parameters."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class GenericParameterDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
int parameterPosition;
object GetCustomDataToExport(Type clrType, Type dataContractType);
void GetKnownCustomDataTypes(Collection<Type> customDataTypes);
Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData);
+#if !NO_CODEDOM
CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit);
+#endif
}
static class DataContractSurrogateCaller
return null;
return surrogate.GetReferencedTypeOnImport(typeName, typeNamespace, customData);
}
+#if !NO_CODEDOM
internal static CodeTypeDeclaration ProcessImportedType(IDataContractSurrogate surrogate, CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit)
{
return surrogate.ProcessImportedType(typeDeclaration, compileUnit);
}
+#endif
}
}
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing types."
+ "Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
#pragma warning disable 618 // have not moved to the v4 security model yet
[SecurityCritical(SecurityCriticalScope.Everything)]
#pragma warning restore 618
+#endif
class JsonClassDataContractCriticalHelper : JsonDataContractCriticalHelper
{
JsonFormatClassReaderDelegate jsonFormatReaderDelegate;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing types."
+ "Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
#pragma warning disable 618 // have not moved to the v4 security model yet
[SecurityCritical(SecurityCriticalScope.Everything)]
#pragma warning restore 618
+#endif
class JsonCollectionDataContractCriticalHelper : JsonDataContractCriticalHelper
{
JsonFormatCollectionReaderDelegate jsonFormatReaderDelegate;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing types."
+ "Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
#pragma warning disable 618 // have not moved to the v4 security model yet
[SecurityCritical(SecurityCriticalScope.Everything)]
#pragma warning restore 618
+#endif
#if USE_REFEMIT
public class JsonDataContractCriticalHelper
#else
[Fx.Tag.SecurityNote(Critical = "Holds all state used for (de)serializing types."
+ "Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
#pragma warning disable 618 // have not moved to the v4 security model yet
[SecurityCritical(SecurityCriticalScope.Everything)]
#pragma warning restore 618
+#endif
class JsonEnumDataContractCriticalHelper : JsonDataContractCriticalHelper
{
bool isULong;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters;
using System.Collections.Generic;
+#if !NO_CONFIGURATION
using System.Runtime.Serialization.Configuration;
+#endif
using System.Reflection;
public sealed class NetDataContractSerializer : XmlObjectSerializer, IFormatter
{
if (unsafeTypeForwardingEnabled == null)
{
+#if NO_CONFIGURATION
+ unsafeTypeForwardingEnabled = false;
+#else
NetDataContractSerializerSection section;
if (NetDataContractSerializerSection.TryUnsafeGetSection(out section))
{
{
unsafeTypeForwardingEnabled = false;
}
+#endif
}
Fx.Assert(unsafeTypeForwardingEnabled != null, "unsafeTypeForwardingEnabled should not be null.");
return unsafeTypeForwardingEnabled.Value;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for for (de)serializing primitives."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class PrimitiveDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
MethodInfo xmlFormatWriterMethod;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for for (de)serializing known types like System.Enum, System.ValueType, etc."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class SpecialTypeDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
internal SpecialTypeDataContractCriticalHelper(Type type)
[Fx.Tag.SecurityNote(Critical = "Holds all state used for for (de)serializing with ISerializationSurrogate."
+ " Since it accesses data on the base type that is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class SurrogateDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
ISerializationSurrogate serializationSurrogate;
[Fx.Tag.SecurityNote(Critical = "Holds all state used for for (de)serializing XML types."
+ " Since the data is cached statically, we lock down access to it.")]
+#if !NO_SECURITY_ATTRIBUTES
[SecurityCritical(SecurityCriticalScope.Everything)]
+#endif
class XmlDataContractCriticalHelper : DataContract.DataContractCriticalHelper
{
DataContractDictionary knownDataContracts;
{
if (sourceAssembly != destinationAssembly && !NetDataContractSerializer.UnsafeTypeForwardingEnabled && !sourceAssembly.IsFullyTrusted)
{
+#if !NO_DESKTOP_SECURITY
// We have a TypeForwardedTo attribute
if (!destinationAssembly.PermissionSet.IsSubsetOf(sourceAssembly.PermissionSet))
{
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.GetString(SR.CannotDeserializeForwardedType, DataContract.GetClrTypeFullName(resolvedType))));
}
+#endif
}
}
nodes[i].WriteTo(xmlWriter);
}
+#if !MOBILE
internal static string AddDefaultSchemaMethodName = "AddDefaultSchema";
public static void AddDefaultSchema(XmlSchemaSet schemas, XmlQualifiedName typeQName)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("typeQName");
SchemaExporter.AddDefaultXmlType(schemas, typeQName.Name, typeQName.Namespace);
}
+#endif
}
}
projects / mono.git / commitdiff