Imported Upstream version 1.1.0upstream/1.1.0

977 files changed, 349392 insertions, 0 deletions

diff --git a/src/mscorlib/src/System/AccessViolationException.cs b/src/mscorlib/src/System/AccessViolationException.cs
new file mode 100644
index 0000000000..308d52e9ed
--- /dev/null
+++ b/src/mscorlib/src/System/AccessViolationException.cs
@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/*=============================================================================
+**
+**
+**
+** Purpose: Exception class representing an AV that was deemed unsafe and may have corrupted the application.
+**
+**
+=============================================================================*/
+
+namespace System 
+{   
+    
+    using System;
+    using System.Runtime.Serialization;
+    [System.Runtime.InteropServices.ComVisible(true)]
+    [Serializable]
+    public class AccessViolationException : SystemException 
+    {
+        public AccessViolationException() 
+            : base(Environment.GetResourceString("Arg_AccessViolationException")) 
+        {
+            SetErrorCode(__HResults.E_POINTER);
+        }
+    
+        public AccessViolationException(String message) 
+            : base(message) 
+        {
+            SetErrorCode(__HResults.E_POINTER);
+        }
+        
+        public AccessViolationException(String message, Exception innerException) 
+            : base(message, innerException) 
+        {
+            SetErrorCode(__HResults.E_POINTER);
+        }
+
+        protected AccessViolationException(SerializationInfo info, StreamingContext context) : base(info, context) {}
+
+#pragma warning disable 169  // Field is not used from managed.
+        private IntPtr _ip;             // Address of faulting instruction.
+        private IntPtr _target;         // Address that could not be accessed.
+        private int _accessType;        // 0:read, 1:write
+#pragma warning restore 169
+
+    }
+
+}
diff --git a/src/mscorlib/src/System/Action.cs b/src/mscorlib/src/System/Action.cs
new file mode 100644
index 0000000000..d6653c7979
--- /dev/null
+++ b/src/mscorlib/src/System/Action.cs
@@ -0,0 +1,78 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// 
+
+namespace System {
+    using System.Runtime.CompilerServices;
+
+    public delegate void Action<in T>(T obj); 
+
+    // Action/Func delegates first shipped with .NET Framework 3.5 in System.Core.dll as part of LINQ
+    // These were type forwarded to mscorlib.dll in .NET Framework 4.0 and in Silverlight 5.0
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate void Action();
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate void Action<in T1,in T2>(T1 arg1, T2 arg2);
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate void Action<in T1,in T2,in T3>(T1 arg1, T2 arg2, T3 arg3);
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate void Action<in T1,in T2,in T3,in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate TResult Func<out TResult>();
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate TResult Func<in T, out TResult>(T arg);
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3);
+
+#if !FEATURE_CORECLR
+    [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
+#endif
+    public delegate TResult Func<in T1, in T2, in T3, in T4, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
+
+
+    public delegate void Action<in T1,in T2,in T3,in T4,in T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
+    public delegate void Action<in T1,in T2,in T3,in T4,in T5,in T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
+    public delegate void Action<in T1,in T2,in T3,in T4,in T5,in T6,in T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
+    public delegate void Action<in T1,in T2,in T3,in T4,in T5,in T6,in T7,in T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
+
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
+    public delegate TResult Func<in T1, in T2, in T3, in T4, in T5, in T6, in T7, in T8, out TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
+
+    public delegate int Comparison<in T>(T x, T y);
+
+    public delegate TOutput Converter<in TInput, out TOutput>(TInput input); 
+    
+    public delegate bool Predicate<in T>(T obj); 
+
+}
+
diff --git a/src/mscorlib/src/System/Activator.cs b/src/mscorlib/src/System/Activator.cs
new file mode 100644
index 0000000000..274b0e7ec5
--- /dev/null
+++ b/src/mscorlib/src/System/Activator.cs
@@ -0,0 +1,688 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//
+// Activator is an object that contains the Activation (CreateInstance/New) 
+//  methods for late bound support.
+//
+// 
+// 
+//
+namespace System {
+
+    using System;
+    using System.Reflection;
+    using System.Runtime.Remoting;
+#if FEATURE_REMOTING    
+    using System.Runtime.Remoting.Activation;
+    using Message = System.Runtime.Remoting.Messaging.Message;
+#endif
+    using System.Security;
+    using CultureInfo = System.Globalization.CultureInfo;
+    using Evidence = System.Security.Policy.Evidence;
+    using StackCrawlMark = System.Threading.StackCrawlMark;
+    using System.Runtime.InteropServices;
+    using System.Runtime.CompilerServices;
+    using System.Security.Permissions;
+    using AssemblyHashAlgorithm = System.Configuration.Assemblies.AssemblyHashAlgorithm;
+    using System.Runtime.Versioning;
+    using System.Diagnostics.Contracts;
+
+    // Only statics, does not need to be marked with the serializable attribute
+    [ClassInterface(ClassInterfaceType.None)]
+    [ComDefaultInterface(typeof(_Activator))]
+[System.Runtime.InteropServices.ComVisible(true)]
+    public sealed class Activator : _Activator
+    {
+        internal const int LookupMask                 = 0x000000FF;
+        internal const BindingFlags ConLookup         = (BindingFlags) (BindingFlags.Instance | BindingFlags.Public);
+        internal const BindingFlags ConstructorDefault= BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance;
+
+        // This class only contains statics, so hide the worthless constructor
+        private Activator()
+        {
+        }
+
+        // CreateInstance
+        // The following methods will create a new instance of an Object
+        // Full Binding Support
+        // For all of these methods we need to get the underlying RuntimeType and
+        //  call the Impl version.
+        static public Object CreateInstance(Type type,
+                                            BindingFlags bindingAttr,
+                                            Binder binder,
+                                            Object[] args,
+                                            CultureInfo culture) 
+        {
+            return CreateInstance(type, bindingAttr, binder, args, culture, null);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        static public Object CreateInstance(Type type,
+                                            BindingFlags bindingAttr,
+                                            Binder binder,
+                                            Object[] args,
+                                            CultureInfo culture,
+                                            Object[] activationAttributes)
+        {
+            if ((object)type == null)
+                throw new ArgumentNullException("type");
+            Contract.EndContractBlock();
+
+            if (type is System.Reflection.Emit.TypeBuilder)
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_CreateInstanceWithTypeBuilder"));
+
+            // If they didn't specify a lookup, then we will provide the default lookup.
+            if ((bindingAttr & (BindingFlags) LookupMask) == 0)
+                bindingAttr |= Activator.ConstructorDefault;
+
+            if (activationAttributes != null && activationAttributes.Length > 0){
+                // If type does not derive from MBR
+                // throw notsupportedexception
+#if FEATURE_REMOTING                
+                if(type.IsMarshalByRef){
+                    // The fix below is preventative.
+                    //
+                    if(!(type.IsContextful)){
+                        if(activationAttributes.Length > 1 || !(activationAttributes[0] is UrlAttribute))
+                           throw new NotSupportedException(Environment.GetResourceString("NotSupported_NonUrlAttrOnMBR"));
+                    }
+                }
+                else
+#endif                    
+                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_ActivAttrOnNonMBR" ));
+            }
+
+            RuntimeType rt = type.UnderlyingSystemType as RuntimeType;
+
+            if (rt == null)
+                throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"),"type");
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return rt.CreateInstanceImpl(bindingAttr,binder,args,culture,activationAttributes, ref stackMark);
+        }
+
+        static public Object CreateInstance(Type type, params Object[] args)
+        {
+            return CreateInstance(type,
+                                  Activator.ConstructorDefault,
+                                  null,
+                                  args,
+                                  null,
+                                  null);
+        }
+
+        static public Object CreateInstance(Type type,
+                                            Object[] args,
+                                            Object[] activationAttributes)
+        {
+             return CreateInstance(type,
+                                   Activator.ConstructorDefault,
+                                   null,
+                                   args,
+                                   null,
+                                   activationAttributes);
+        }
+        
+        static public Object CreateInstance(Type type)
+        {
+            return Activator.CreateInstance(type, false);
+        }
+
+        /*
+         * Create an instance using the name of type and the assembly where it exists. This allows
+         * types to be created remotely without having to load the type locally.
+         */
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        static public ObjectHandle CreateInstance(String assemblyName,
+                                                  String typeName)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return CreateInstance(assemblyName,
+                                  typeName, 
+                                  false,
+                                  Activator.ConstructorDefault,
+                                  null,
+                                  null,
+                                  null,
+                                  null,
+                                  null,
+                                  ref stackMark);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable                                                  
+        static public ObjectHandle CreateInstance(String assemblyName,
+                                                  String typeName,
+                                                  Object[] activationAttributes)
+                                                  
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return CreateInstance(assemblyName,
+                                  typeName, 
+                                  false,
+                                  Activator.ConstructorDefault,
+                                  null,
+                                  null,
+                                  null,
+                                  activationAttributes,
+                                  null,
+                                  ref stackMark);
+        }
+            
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        static public Object CreateInstance(Type type, bool nonPublic)
+        {
+            if ((object)type == null)
+                throw new ArgumentNullException("type");
+            Contract.EndContractBlock();
+
+            RuntimeType rt = type.UnderlyingSystemType as RuntimeType;
+
+            if (rt == null)
+                throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"), "type");
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return rt.CreateInstanceDefaultCtor(!nonPublic, false, true, ref stackMark);
+        }
+
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        static public T CreateInstance<T>()
+        {
+            RuntimeType rt = typeof(T) as RuntimeType;
+
+            // This is a workaround to maintain compatibility with V2. Without this we would throw a NotSupportedException for void[].
+            // Array, Ref, and Pointer types don't have default constructors.
+            if (rt.HasElementType)
+                throw new MissingMethodException(Environment.GetResourceString("Arg_NoDefCTor"));
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+
+            // Skip the CreateInstanceCheckThis call to avoid perf cost and to maintain compatibility with V2 (throwing the same exceptions).
+            return (T)rt.CreateInstanceDefaultCtor(true /*publicOnly*/, true /*skipCheckThis*/, true /*fillCache*/, ref stackMark);
+        }
+
+        static public ObjectHandle CreateInstanceFrom(String assemblyFile,
+                                                      String typeName)
+                                         
+        {
+            return CreateInstanceFrom(assemblyFile, typeName, null);
+        }
+
+        static public ObjectHandle CreateInstanceFrom(String assemblyFile,
+                                                      String typeName,
+                                                      Object[] activationAttributes)
+                                         
+        {
+            return CreateInstanceFrom(assemblyFile,
+                                      typeName, 
+                                      false,
+                                      Activator.ConstructorDefault,
+                                      null,
+                                      null,
+                                      null,
+                                      activationAttributes);
+        }
+                                  
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        static public ObjectHandle CreateInstance(String assemblyName, 
+                                                  String typeName, 
+                                                  bool ignoreCase,
+                                                  BindingFlags bindingAttr, 
+                                                  Binder binder,
+                                                  Object[] args,
+                                                  CultureInfo culture,
+                                                  Object[] activationAttributes,
+                                                  Evidence securityInfo)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return CreateInstance(assemblyName,
+                                  typeName,
+                                  ignoreCase,
+                                  bindingAttr,
+                                  binder,
+                                  args,
+                                  culture,
+                                  activationAttributes,
+                                  securityInfo,
+                                  ref stackMark);
+        }
+
+        [SecuritySafeCritical]
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public static ObjectHandle CreateInstance(string assemblyName,
+                                                  string typeName,
+                                                  bool ignoreCase,
+                                                  BindingFlags bindingAttr,
+                                                  Binder binder,
+                                                  object[] args,
+                                                  CultureInfo culture,
+                                                  object[] activationAttributes)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return CreateInstance(assemblyName,
+                                  typeName,
+                                  ignoreCase,
+                                  bindingAttr,
+                                  binder,
+                                  args,
+                                  culture,
+                                  activationAttributes,
+                                  null,
+                                  ref stackMark);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        static internal ObjectHandle CreateInstance(String assemblyString, 
+                                                    String typeName, 
+                                                    bool ignoreCase,
+                                                    BindingFlags bindingAttr, 
+                                                    Binder binder,
+                                                    Object[] args,
+                                                    CultureInfo culture,
+                                                    Object[] activationAttributes,
+                                                    Evidence securityInfo,
+                                                    ref StackCrawlMark stackMark)
+        {
+#if FEATURE_CAS_POLICY
+            if (securityInfo != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            Type type = null;
+            Assembly assembly = null;
+            if (assemblyString == null) {
+                assembly = RuntimeAssembly.GetExecutingAssembly(ref stackMark);
+            } else {
+                RuntimeAssembly assemblyFromResolveEvent;
+                AssemblyName assemblyName = RuntimeAssembly.CreateAssemblyName(assemblyString, false /*forIntrospection*/, out assemblyFromResolveEvent);
+                if (assemblyFromResolveEvent != null) {
+                    // Assembly was resolved via AssemblyResolve event
+                    assembly = assemblyFromResolveEvent;
+                } else if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime) {
+                    // WinRT type - we have to use Type.GetType
+                    type = Type.GetType(typeName + ", " + assemblyString, true /*throwOnError*/, ignoreCase);
+                } else {
+                    // Classic managed type
+                    assembly = RuntimeAssembly.InternalLoadAssemblyName(
+                        assemblyName, securityInfo, null, ref stackMark,
+                        true /*thrownOnFileNotFound*/, false /*forIntrospection*/, false /*suppressSecurityChecks*/);
+                }
+            }
+
+            if (type == null) {
+                // It's classic managed type (not WinRT type)
+                Log(assembly != null, "CreateInstance:: ", "Loaded " + assembly.FullName, "Failed to Load: " + assemblyString);
+                if(assembly == null) return null;
+
+                type = assembly.GetType(typeName, true /*throwOnError*/, ignoreCase);
+            }
+            
+            Object o = Activator.CreateInstance(type,
+                                                bindingAttr,
+                                                binder,
+                                                args,
+                                                culture,
+                                                activationAttributes);
+
+            Log(o != null, "CreateInstance:: ", "Created Instance of class " + typeName, "Failed to create instance of class " + typeName);
+            if(o == null)
+                return null;
+            else {
+                ObjectHandle Handle = new ObjectHandle(o);
+                return Handle;
+            }
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        static public ObjectHandle CreateInstanceFrom(String assemblyFile,
+                                                      String typeName, 
+                                                      bool ignoreCase,
+                                                      BindingFlags bindingAttr, 
+                                                      Binder binder,
+                                                      Object[] args,
+                                                      CultureInfo culture,
+                                                      Object[] activationAttributes,
+                                                      Evidence securityInfo)
+                                               
+        {
+#if FEATURE_CAS_POLICY
+            if (securityInfo != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            return CreateInstanceFromInternal(assemblyFile,
+                                              typeName,
+                                              ignoreCase,
+                                              bindingAttr,
+                                              binder,
+                                              args,
+                                              culture,
+                                              activationAttributes,
+                                              securityInfo);
+        }
+
+        public static ObjectHandle CreateInstanceFrom(string assemblyFile,
+                                                      string typeName,
+                                                      bool ignoreCase,
+                                                      BindingFlags bindingAttr,
+                                                      Binder binder,
+                                                      object[] args,
+                                                      CultureInfo culture,
+                                                      object[] activationAttributes)
+        {
+            return CreateInstanceFromInternal(assemblyFile,
+                                              typeName,
+                                              ignoreCase,
+                                              bindingAttr,
+                                              binder,
+                                              args,
+                                              culture,
+                                              activationAttributes,
+                                              null);
+        }
+
+        private static ObjectHandle CreateInstanceFromInternal(String assemblyFile,
+                                                               String typeName, 
+                                                               bool ignoreCase,
+                                                               BindingFlags bindingAttr, 
+                                                               Binder binder,
+                                                               Object[] args,
+                                                               CultureInfo culture,
+                                                               Object[] activationAttributes,
+                                                               Evidence securityInfo)
+        {
+#if FEATURE_CAS_POLICY
+            Contract.Assert(AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled || securityInfo == null);
+#endif // FEATURE_CAS_POLICY
+
+#pragma warning disable 618
+            Assembly assembly = Assembly.LoadFrom(assemblyFile, securityInfo);
+#pragma warning restore 618
+            Type t = assembly.GetType(typeName, true, ignoreCase);
+            
+            Object o = Activator.CreateInstance(t,
+                                                bindingAttr,
+                                                binder,
+                                                args,
+                                                culture,
+                                                activationAttributes);
+
+            Log(o != null, "CreateInstanceFrom:: ", "Created Instance of class " + typeName, "Failed to create instance of class " + typeName);
+            if(o == null)
+                return null;
+            else {
+                ObjectHandle Handle = new ObjectHandle(o);
+                return Handle;
+            }
+        }
+
+        //
+        // This API is designed to be used when a host needs to execute code in an AppDomain
+        // with restricted security permissions. In that case, we demand in the client domain
+        // and assert in the server domain because the server domain might not be trusted enough
+        // to pass the security checks when activating the type.
+        //
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public static ObjectHandle CreateInstance (AppDomain domain, string assemblyName, string typeName) {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+            return domain.InternalCreateInstanceWithNoSecurity(assemblyName, typeName);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public static ObjectHandle CreateInstance (AppDomain domain,
+                                                   string assemblyName,
+                                                   string typeName,
+                                                   bool ignoreCase,
+                                                   BindingFlags bindingAttr,
+                                                   Binder binder,
+                                                   Object[] args,
+                                                   CultureInfo culture,
+                                                   Object[] activationAttributes,
+                                                   Evidence securityAttributes) {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+
+#if FEATURE_CAS_POLICY
+            if (securityAttributes != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            return domain.InternalCreateInstanceWithNoSecurity(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
+        }
+
+        [SecurityCritical]
+        public static ObjectHandle CreateInstance(AppDomain domain,
+                                                  string assemblyName,
+                                                  string typeName,
+                                                  bool ignoreCase,
+                                                  BindingFlags bindingAttr,
+                                                  Binder binder,
+                                                  object[] args,
+                                                  CultureInfo culture,
+                                                  object[] activationAttributes)
+        {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+
+            return domain.InternalCreateInstanceWithNoSecurity(assemblyName,
+                                                               typeName,
+                                                               ignoreCase,
+                                                               bindingAttr,
+                                                               binder,
+                                                               args,
+                                                               culture,
+                                                               activationAttributes,
+                                                               null);
+        }
+
+        //
+        // This API is designed to be used when a host needs to execute code in an AppDomain
+        // with restricted security permissions. In that case, we demand in the client domain
+        // and assert in the server domain because the server domain might not be trusted enough
+        // to pass the security checks when activating the type.
+        //
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public static ObjectHandle CreateInstanceFrom (AppDomain domain, string assemblyFile, string typeName) {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+            return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile, typeName);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("Methods which use Evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public static ObjectHandle CreateInstanceFrom (AppDomain domain,
+                                                       string assemblyFile,
+                                                       string typeName,
+                                                       bool ignoreCase,
+                                                       BindingFlags bindingAttr,
+                                                       Binder binder,
+                                                       Object[] args,
+                                                       CultureInfo culture,
+                                                       Object[] activationAttributes,
+                                                       Evidence securityAttributes) {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+
+#if FEATURE_CAS_POLICY
+            if (securityAttributes != null && !AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
+        }
+
+        [SecurityCritical]
+        public static ObjectHandle CreateInstanceFrom(AppDomain domain,
+                                                      string assemblyFile,
+                                                      string typeName,
+                                                      bool ignoreCase,
+                                                      BindingFlags bindingAttr,
+                                                      Binder binder,
+                                                      object[] args,
+                                                      CultureInfo culture,
+                                                      object[] activationAttributes)
+        {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+
+            return domain.InternalCreateInstanceFromWithNoSecurity(assemblyFile,
+                                                                   typeName,
+                                                                   ignoreCase,
+                                                                   bindingAttr,
+                                                                   binder,
+                                                                   args,
+                                                                   culture,
+                                                                   activationAttributes,
+                                                                   null);
+        }
+
+#if FEATURE_CLICKONCE
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public static ObjectHandle CreateInstance (ActivationContext activationContext) {
+            AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
+            if (domainManager == null)
+                domainManager = new AppDomainManager();
+
+            return domainManager.ApplicationActivator.CreateInstance(activationContext);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public static ObjectHandle CreateInstance (ActivationContext activationContext, string[] activationCustomData) {
+            AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
+            if (domainManager == null)
+                domainManager = new AppDomainManager();
+
+            return domainManager.ApplicationActivator.CreateInstance(activationContext, activationCustomData);
+        }
+#endif // FEATURE_CLICKONCE
+
+        public static ObjectHandle CreateComInstanceFrom(String assemblyName,
+                                                         String typeName)                                         
+        {
+            return CreateComInstanceFrom(assemblyName,
+                                         typeName,
+                                         null,
+                                         AssemblyHashAlgorithm.None);
+                                         
+        }
+                                         
+        public static ObjectHandle CreateComInstanceFrom(String assemblyName,
+                                                         String typeName,
+                                                         byte[] hashValue, 
+                                                         AssemblyHashAlgorithm hashAlgorithm)
+        {
+            Assembly assembly = Assembly.LoadFrom(assemblyName, hashValue, hashAlgorithm);
+
+            Type t = assembly.GetType(typeName, true, false);
+
+            Object[] Attr = t.GetCustomAttributes(typeof(ComVisibleAttribute),false);
+            if (Attr.Length > 0)
+            {
+                if (((ComVisibleAttribute)Attr[0]).Value == false)
+                    throw new TypeLoadException(Environment.GetResourceString( "Argument_TypeMustBeVisibleFromCom" ));
+            }
+
+            Log(assembly != null, "CreateInstance:: ", "Loaded " + assembly.FullName, "Failed to Load: " + assemblyName);
+
+            if(assembly == null) return null;
+
+  
+            Object o = Activator.CreateInstance(t,
+                                                Activator.ConstructorDefault,
+                                                null,
+                                                null,
+                                                null,
+                                                null);
+
+            Log(o != null, "CreateInstance:: ", "Created Instance of class " + typeName, "Failed to create instance of class " + typeName);
+            if(o == null)
+                return null;
+            else {
+                ObjectHandle Handle = new ObjectHandle(o);
+                return Handle;
+            }
+        }
+
+#if FEATURE_REMOTING
+        //  This method is a helper method and delegates to the remoting 
+        //  services to do the actual work. 
+        [System.Security.SecurityCritical]  // auto-generated_required
+        static public Object GetObject(Type type, String url)
+        {
+            return GetObject(type, url, null);
+        }
+        
+        //  This method is a helper method and delegates to the remoting 
+        //  services to do the actual work. 
+        [System.Security.SecurityCritical]  // auto-generated_required
+        static public Object GetObject(Type type, String url, Object state)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            Contract.EndContractBlock();
+            return RemotingServices.Connect(type, url, state);
+        }
+#endif
+
+        [System.Diagnostics.Conditional("_DEBUG")]
+        private static void Log(bool test, string title, string success, string failure)
+        {
+#if FEATURE_REMOTING
+            if(test)
+                BCLDebug.Trace("REMOTE", "{0}{1}", title, success);
+            else
+                BCLDebug.Trace("REMOTE", "{0}{1}", title, failure);
+#endif            
+        }
+        
+        void _Activator.GetTypeInfoCount(out uint pcTInfo)
+        {
+            throw new NotImplementedException();
+        }
+
+        void _Activator.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
+        {
+            throw new NotImplementedException();
+        }
+
+        void _Activator.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
+        {
+            throw new NotImplementedException();
+        }
+
+        // If you implement this method, make sure to include _Activator.Invoke in VM\DangerousAPIs.h and
+        // include _Activator in SystemDomain::IsReflectionInvocationMethod in AppDomain.cpp.
+        void _Activator.Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
+
diff --git a/src/mscorlib/src/System/AggregateException.cs b/src/mscorlib/src/System/AggregateException.cs
new file mode 100644
index 0000000000..064432aaaa
--- /dev/null
+++ b/src/mscorlib/src/System/AggregateException.cs
@@ -0,0 +1,497 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+//
+//
+//
+// Public type to communicate multiple failures to an end-user.
+//
+// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Globalization;
+using System.Runtime.ExceptionServices;
+using System.Runtime.Serialization;
+using System.Security;
+using System.Text;
+using System.Threading;
+
+namespace System
+{
+
+    /// <summary>Represents one or more errors that occur during application execution.</summary>
+    /// <remarks>
+    /// <see cref="AggregateException"/> is used to consolidate multiple failures into a single, throwable
+    /// exception object.
+    /// </remarks>
+    [Serializable]
+    [DebuggerDisplay("Count = {InnerExceptionCount}")]
+    public class AggregateException : Exception
+    {
+
+        private ReadOnlyCollection<Exception> m_innerExceptions; // Complete set of exceptions.
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class.
+        /// </summary>
+        public AggregateException()
+            : base(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"))
+        {
+            m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[0]);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with
+        /// a specified error message.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        public AggregateException(string message)
+            : base(message)
+        {
+            m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[0]);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with a specified error
+        /// message and a reference to the inner exception that is the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerException"/> argument
+        /// is null.</exception>
+        public AggregateException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+            if (innerException == null)
+            {
+                throw new ArgumentNullException("innerException");
+            }
+
+            m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[] { innerException });
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with
+        /// references to the inner exceptions that are the cause of this exception.
+        /// </summary>
+        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions"/> is
+        /// null.</exception>
+        public AggregateException(IEnumerable<Exception> innerExceptions) :
+            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with
+        /// references to the inner exceptions that are the cause of this exception.
+        /// </summary>
+        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions"/> is
+        /// null.</exception>
+        public AggregateException(params Exception[] innerExceptions) :
+            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with a specified error
+        /// message and references to the inner exceptions that are the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions"/> is
+        /// null.</exception>
+        public AggregateException(string message, IEnumerable<Exception> innerExceptions)
+            // If it's already an IList, pass that along (a defensive copy will be made in the delegated ctor).  If it's null, just pass along
+            // null typed correctly.  Otherwise, create an IList from the enumerable and pass that along. 
+            : this(message, innerExceptions as IList<Exception> ?? (innerExceptions == null ? (List<Exception>)null : new List<Exception>(innerExceptions)))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with a specified error
+        /// message and references to the inner exceptions that are the cause of this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions"/> is
+        /// null.</exception>
+        public AggregateException(string message, params Exception[] innerExceptions) :
+            this(message, (IList<Exception>)innerExceptions)
+        {
+        }
+
+        /// <summary>
+        /// Allocates a new aggregate exception with the specified message and list of inner exceptions.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions"/> is
+        /// null.</exception>
+        private AggregateException(string message, IList<Exception> innerExceptions)
+            : base(message, innerExceptions != null && innerExceptions.Count > 0 ? innerExceptions[0] : null)
+        {
+            if (innerExceptions == null)
+            {
+                throw new ArgumentNullException("innerExceptions");
+            }
+
+            // Copy exceptions to our internal array and validate them. We must copy them,
+            // because we're going to put them into a ReadOnlyCollection which simply reuses
+            // the list passed in to it. We don't want callers subsequently mutating.
+            Exception[] exceptionsCopy = new Exception[innerExceptions.Count];
+
+            for (int i = 0; i < exceptionsCopy.Length; i++)
+            {
+                exceptionsCopy[i] = innerExceptions[i];
+
+                if (exceptionsCopy[i] == null)
+                {
+                    throw new ArgumentException(Environment.GetResourceString("AggregateException_ctor_InnerExceptionNull"));
+                }
+            }
+
+            m_innerExceptions = new ReadOnlyCollection<Exception>(exceptionsCopy);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with
+        /// references to the inner exception dispatch info objects that represent the cause of this exception.
+        /// </summary>
+        /// <param name="innerExceptionInfos">
+        /// Information about the exceptions that are the cause of the current exception.
+        /// </param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptionInfos"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptionInfos"/> is
+        /// null.</exception>
+        internal AggregateException(IEnumerable<ExceptionDispatchInfo> innerExceptionInfos) :
+            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptionInfos)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with a specified error
+        /// message and references to the inner exception dispatch info objects that represent the cause of 
+        /// this exception.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerExceptionInfos">
+        /// Information about the exceptions that are the cause of the current exception.
+        /// </param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptionInfos"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptionInfos"/> is
+        /// null.</exception>
+        internal AggregateException(string message, IEnumerable<ExceptionDispatchInfo> innerExceptionInfos)
+            // If it's already an IList, pass that along (a defensive copy will be made in the delegated ctor).  If it's null, just pass along
+            // null typed correctly.  Otherwise, create an IList from the enumerable and pass that along. 
+            : this(message, innerExceptionInfos as IList<ExceptionDispatchInfo> ?? 
+                                (innerExceptionInfos == null ? 
+                                    (List<ExceptionDispatchInfo>)null : 
+                                    new List<ExceptionDispatchInfo>(innerExceptionInfos)))
+        {
+        }
+
+        /// <summary>
+        /// Allocates a new aggregate exception with the specified message and list of inner 
+        /// exception dispatch info objects.
+        /// </summary>
+        /// <param name="message">The error message that explains the reason for the exception.</param>
+        /// <param name="innerExceptionInfos">
+        /// Information about the exceptions that are the cause of the current exception.
+        /// </param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptionInfos"/> argument
+        /// is null.</exception>
+        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptionInfos"/> is
+        /// null.</exception>
+        private AggregateException(string message, IList<ExceptionDispatchInfo> innerExceptionInfos)
+            : base(message, innerExceptionInfos != null && innerExceptionInfos.Count > 0 && innerExceptionInfos[0] != null ?
+                                innerExceptionInfos[0].SourceException : null)
+        {
+            if (innerExceptionInfos == null)
+            {
+                throw new ArgumentNullException("innerExceptionInfos");
+            }
+
+            // Copy exceptions to our internal array and validate them. We must copy them,
+            // because we're going to put them into a ReadOnlyCollection which simply reuses
+            // the list passed in to it. We don't want callers subsequently mutating.
+            Exception[] exceptionsCopy = new Exception[innerExceptionInfos.Count];
+
+            for (int i = 0; i < exceptionsCopy.Length; i++)
+            {
+                var edi = innerExceptionInfos[i];
+                if (edi != null) exceptionsCopy[i] = edi.SourceException;
+
+                if (exceptionsCopy[i] == null)
+                {
+                    throw new ArgumentException(Environment.GetResourceString("AggregateException_ctor_InnerExceptionNull"));
+                }
+            }
+
+            m_innerExceptions = new ReadOnlyCollection<Exception>(exceptionsCopy);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateException"/> class with serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds
+        /// the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that
+        /// contains contextual information about the source or destination. </param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> argument is null.</exception>
+        /// <exception cref="T:System.Runtime.Serialization.SerializationException">The exception could not be deserialized correctly.</exception>
+        [SecurityCritical]
+        protected AggregateException(SerializationInfo info, StreamingContext context) :
+            base(info, context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException("info");
+            }
+
+            Exception[] innerExceptions = info.GetValue("InnerExceptions", typeof(Exception[])) as Exception[];
+            if (innerExceptions == null)
+            {
+                throw new SerializationException(Environment.GetResourceString("AggregateException_DeserializationFailure"));
+            }
+
+            m_innerExceptions = new ReadOnlyCollection<Exception>(innerExceptions);
+        }
+
+        /// <summary>
+        /// Sets the <see cref="T:System.Runtime.Serialization.SerializationInfo"/> with information about
+        /// the exception.
+        /// </summary>
+        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds
+        /// the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that
+        /// contains contextual information about the source or destination. </param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> argument is null.</exception>
+        [SecurityCritical]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException("info");
+            }
+
+            base.GetObjectData(info, context);
+
+            Exception[] innerExceptions = new Exception[m_innerExceptions.Count];
+            m_innerExceptions.CopyTo(innerExceptions, 0);
+            info.AddValue("InnerExceptions", innerExceptions, typeof(Exception[]));
+        }
+
+        /// <summary>
+        /// Returns the <see cref="System.AggregateException"/> that is the root cause of this exception.
+        /// </summary>
+        public override Exception GetBaseException()
+        {
+            // Returns the first inner AggregateException that contains more or less than one inner exception
+
+            // Recursively traverse the inner exceptions as long as the inner exception of type AggregateException and has only one inner exception
+            Exception back = this;
+            AggregateException backAsAggregate = this;
+            while (backAsAggregate != null && backAsAggregate.InnerExceptions.Count == 1)
+            {
+                back = back.InnerException;
+                backAsAggregate = back as AggregateException;
+            }
+            return back;
+        }
+
+        /// <summary>
+        /// Gets a read-only collection of the <see cref="T:System.Exception"/> instances that caused the
+        /// current exception.
+        /// </summary>
+        public ReadOnlyCollection<Exception> InnerExceptions
+        {
+            get { return m_innerExceptions; }
+        }
+
+
+        /// <summary>
+        /// Invokes a handler on each <see cref="T:System.Exception"/> contained by this <see
+        /// cref="AggregateException"/>.
+        /// </summary>
+        /// <param name="predicate">The predicate to execute for each exception. The predicate accepts as an
+        /// argument the <see cref="T:System.Exception"/> to be processed and returns a Boolean to indicate
+        /// whether the exception was handled.</param>
+        /// <remarks>
+        /// Each invocation of the <paramref name="predicate"/> returns true or false to indicate whether the
+        /// <see cref="T:System.Exception"/> was handled. After all invocations, if any exceptions went
+        /// unhandled, all unhandled exceptions will be put into a new <see cref="AggregateException"/>
+        /// which will be thrown. Otherwise, the <see cref="Handle"/> method simply returns. If any
+        /// invocations of the <paramref name="predicate"/> throws an exception, it will halt the processing
+        /// of any more exceptions and immediately propagate the thrown exception as-is.
+        /// </remarks>
+        /// <exception cref="AggregateException">An exception contained by this <see
+        /// cref="AggregateException"/> was not handled.</exception>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="predicate"/> argument is
+        /// null.</exception>
+        public void Handle(Func<Exception, bool> predicate)
+        {
+            if (predicate == null)
+            {
+                throw new ArgumentNullException("predicate");
+            }
+
+            List<Exception> unhandledExceptions = null;
+            for (int i = 0; i < m_innerExceptions.Count; i++)
+            {
+                // If the exception was not handled, lazily allocate a list of unhandled
+                // exceptions (to be rethrown later) and add it.
+                if (!predicate(m_innerExceptions[i]))
+                {
+                    if (unhandledExceptions == null)
+                    {
+                        unhandledExceptions = new List<Exception>();
+                    }
+
+                    unhandledExceptions.Add(m_innerExceptions[i]);
+                }
+            }
+
+            // If there are unhandled exceptions remaining, throw them.
+            if (unhandledExceptions != null)
+            {
+                throw new AggregateException(Message, unhandledExceptions);
+            }
+        }
+
+
+        /// <summary>
+        /// Flattens an <see cref="AggregateException"/> instances into a single, new instance.
+        /// </summary>
+        /// <returns>A new, flattened <see cref="AggregateException"/>.</returns>
+        /// <remarks>
+        /// If any inner exceptions are themselves instances of
+        /// <see cref="AggregateException"/>, this method will recursively flatten all of them. The
+        /// inner exceptions returned in the new <see cref="AggregateException"/>
+        /// will be the union of all of the the inner exceptions from exception tree rooted at the provided
+        /// <see cref="AggregateException"/> instance.
+        /// </remarks>
+        public AggregateException Flatten()
+        {
+            // Initialize a collection to contain the flattened exceptions.
+            List<Exception> flattenedExceptions = new List<Exception>();
+
+            // Create a list to remember all aggregates to be flattened, this will be accessed like a FIFO queue
+            List<AggregateException> exceptionsToFlatten = new List<AggregateException>();
+            exceptionsToFlatten.Add(this);
+            int nDequeueIndex = 0;
+
+            // Continue removing and recursively flattening exceptions, until there are no more.
+            while (exceptionsToFlatten.Count > nDequeueIndex)
+            {
+                // dequeue one from exceptionsToFlatten
+                IList<Exception> currentInnerExceptions = exceptionsToFlatten[nDequeueIndex++].InnerExceptions;
+
+                for (int i = 0; i < currentInnerExceptions.Count; i++)
+                {
+                    Exception currentInnerException = currentInnerExceptions[i];
+
+                    if (currentInnerException == null)
+                    {
+                        continue;
+                    }
+
+                    AggregateException currentInnerAsAggregate = currentInnerException as AggregateException;
+
+                    // If this exception is an aggregate, keep it around for later.  Otherwise,
+                    // simply add it to the list of flattened exceptions to be returned.
+                    if (currentInnerAsAggregate != null)
+                    {
+                        exceptionsToFlatten.Add(currentInnerAsAggregate);
+                    }
+                    else
+                    {
+                        flattenedExceptions.Add(currentInnerException);
+                    }
+                }
+            }
+
+
+            return new AggregateException(Message, flattenedExceptions);
+        }
+
+        /// <summary>Gets a message that describes the exception.</summary>
+        public override string Message
+        {
+            get
+            {
+                if (m_innerExceptions.Count == 0)
+                {
+                    return base.Message;
+                }
+
+                StringBuilder sb = StringBuilderCache.Acquire();
+                sb.Append(base.Message);
+                sb.Append(' ');
+                for (int i = 0; i < m_innerExceptions.Count; i++)
+                {
+                    sb.Append('(');
+                    sb.Append(m_innerExceptions[i].Message);
+                    sb.Append(") ");
+                }
+                sb.Length -= 1;
+                return StringBuilderCache.GetStringAndRelease(sb);
+            }
+        }
+
+        /// <summary>
+        /// Creates and returns a string representation of the current <see cref="AggregateException"/>.
+        /// </summary>
+        /// <returns>A string representation of the current exception.</returns>
+        public override string ToString()
+        {
+            string text = base.ToString();
+
+            for (int i = 0; i < m_innerExceptions.Count; i++)
+            {
+                text = String.Format(
+                    CultureInfo.InvariantCulture,
+                    Environment.GetResourceString("AggregateException_ToString"),
+                    text, Environment.NewLine, i, m_innerExceptions[i].ToString(), "<---", Environment.NewLine);
+            }
+
+            return text;
+        }
+
+        /// <summary>
+        /// This helper property is used by the DebuggerDisplay.
+        /// 
+        /// Note that we don't want to remove this property and change the debugger display to {InnerExceptions.Count} 
+        /// because DebuggerDisplay should be a single property access or parameterless method call, so that the debugger 
+        /// can use a fast path without using the expression evaluator.
+        /// 
+        /// See http://msdn.microsoft.com/en-us/library/x810d419.aspx
+        /// </summary>
+        private int InnerExceptionCount
+        {
+            get
+            {
+                return InnerExceptions.Count;
+            }
+        }
+    }
+
+}
diff --git a/src/mscorlib/src/System/AppContext/AppContext.cs b/src/mscorlib/src/System/AppContext/AppContext.cs
new file mode 100644
index 0000000000..0b0643d7b4
--- /dev/null
+++ b/src/mscorlib/src/System/AppContext/AppContext.cs
@@ -0,0 +1,189 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+
+using System.Collections.Generic;
+
+namespace System
+{
+    public static class AppContext
+    {
+        [Flags]
+        private enum SwitchValueState
+        {
+            HasFalseValue = 0x1,
+            HasTrueValue = 0x2,
+            HasLookedForOverride = 0x4,
+            UnknownValue = 0x8 // Has no default and could not find an override
+        }
+        private static readonly Dictionary<string, SwitchValueState> s_switchMap = new Dictionary<string, SwitchValueState>();
+
+        public static string BaseDirectory
+        {
+#if FEATURE_CORECLR
+            [System.Security.SecuritySafeCritical]
+#endif
+            get
+            {
+                // The value of APP_CONTEXT_BASE_DIRECTORY key has to be a string and it is not allowed to be any other type. 
+                // Otherwise the caller will get invalid cast exception
+                return (string) AppDomain.CurrentDomain.GetData("APP_CONTEXT_BASE_DIRECTORY") ?? AppDomain.CurrentDomain.BaseDirectory;
+            }
+        }
+
+        public static string TargetFrameworkName
+        {
+            get
+            {
+                // Forward the value that is set on the current domain.
+                return AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName;
+            }
+        }
+
+#if FEATURE_CORECLR
+        [System.Security.SecuritySafeCritical]
+#endif
+        public static object GetData(string name)
+        {
+            return AppDomain.CurrentDomain.GetData(name);
+        }
+
+        #region Switch APIs
+        static AppContext()
+        {
+            // populate the AppContext with the default set of values
+            AppContextDefaultValues.PopulateDefaultValues();
+        }
+
+        /// <summary>
+        /// Try to get the value of the switch.
+        /// </summary>
+        /// <param name="switchName">The name of the switch</param>
+        /// <param name="isEnabled">A variable where to place the value of the switch</param>
+        /// <returns>A return value of true represents that the switch was set and <paramref name="isEnabled"/> contains the value of the switch</returns>
+        public static bool TryGetSwitch(string switchName, out bool isEnabled)
+        {
+            if (switchName == null)
+                throw new ArgumentNullException("switchName");
+            if (switchName.Length == 0)
+                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "switchName");
+
+            // By default, the switch is not enabled.
+            isEnabled = false;
+
+            SwitchValueState switchValue;
+            lock (s_switchMap)
+            {
+                if (s_switchMap.TryGetValue(switchName, out switchValue))
+                {
+                    // The value is in the dictionary. 
+                    // There are 3 cases here:
+                    // 1. The value of the switch is 'unknown'. This means that the switch name is not known to the system (either via defaults or checking overrides).
+                    //    Example: This is the case when, during a servicing event, a switch is added to System.Xml which ships before mscorlib. The value of the switch
+                    //             Will be unknown to mscorlib.dll and we want to prevent checking the overrides every time we check this switch
+                    // 2. The switch has a valid value AND we have read the overrides for it
+                    //    Example: TryGetSwitch is called for a switch set via SetSwitch
+                    // 3. The switch has the default value and we need to check for overrides
+                    //    Example: TryGetSwitch is called for the first time for a switch that has a default value 
+
+                    // 1. The value is unknown
+                    if (switchValue == SwitchValueState.UnknownValue)
+                    {
+                        isEnabled = false;
+                        return false;
+                    }
+
+                    // We get the value of isEnabled from the value that we stored in the dictionary
+                    isEnabled = (switchValue & SwitchValueState.HasTrueValue) == SwitchValueState.HasTrueValue; 
+
+                    // 2. The switch has a valid value AND we have checked for overrides
+                    if ((switchValue & SwitchValueState.HasLookedForOverride) == SwitchValueState.HasLookedForOverride)
+                    {
+                        return true;
+                    }
+
+                    // 3. The switch has a valid value, but we need to check for overrides.
+                    // Regardless of whether or not the switch has an override, we need to update the value to reflect
+                    // the fact that we checked for overrides. 
+                    bool overrideValue;
+                    if (AppContextDefaultValues.TryGetSwitchOverride(switchName, out overrideValue))
+                    {
+                        // we found an override!
+                        isEnabled = overrideValue;
+                    }
+
+                    // Update the switch in the dictionary to mark it as 'checked for override'
+                    s_switchMap[switchName] = (isEnabled ? SwitchValueState.HasTrueValue : SwitchValueState.HasFalseValue)
+                                                | SwitchValueState.HasLookedForOverride;
+
+                    return true;
+                }
+                else
+                {
+                    // The value is NOT in the dictionary
+                    // In this case we need to see if we have an override defined for the value.
+                    // There are 2 cases:
+                    // 1. The value has an override specified. In this case we need to add the value to the dictionary 
+                    //    and mark it as checked for overrides
+                    //    Example: In a servicing event, System.Xml introduces a switch and an override is specified.
+                    //             The value is not found in mscorlib (as System.Xml ships independent of mscorlib)
+                    // 2. The value does not have an override specified
+                    //    In this case, we want to capture the fact that we looked for a value and found nothing by adding 
+                    //    an entry in the dictionary with the 'sentinel' value of 'SwitchValueState.UnknownValue'.
+                    //    Example: This will prevent us from trying to find overrides for values that we don't have in the dictionary
+
+                    // 1. The value has an override specified.
+                    bool overrideValue;
+                    if (AppContextDefaultValues.TryGetSwitchOverride(switchName, out overrideValue))
+                    {
+                        isEnabled = overrideValue;
+
+                        // Update the switch in the dictionary to mark it as 'checked for override'
+                        s_switchMap[switchName] = (isEnabled ? SwitchValueState.HasTrueValue : SwitchValueState.HasFalseValue)
+                                                    | SwitchValueState.HasLookedForOverride;
+
+                        return true;
+                    }
+
+                    // 2. The value does not have an override.
+                    s_switchMap[switchName] = SwitchValueState.UnknownValue;
+                }
+            }
+            return false; // we did not find a value for the switch
+        }
+
+        /// <summary>
+        /// Assign a switch a value
+        /// </summary>
+        /// <param name="switchName">The name of the switch</param>
+        /// <param name="isEnabled">The value to assign</param>
+        public static void SetSwitch(string switchName, bool isEnabled)
+        {
+            if (switchName == null)
+                throw new ArgumentNullException("switchName");
+            if (switchName.Length == 0)
+                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "switchName");
+
+            SwitchValueState switchValue = (isEnabled ? SwitchValueState.HasTrueValue : SwitchValueState.HasFalseValue)
+                                            | SwitchValueState.HasLookedForOverride;
+
+            lock (s_switchMap)
+            {
+                // Store the new value and the fact that we checked in the dictionary
+                s_switchMap[switchName] = switchValue;
+            }
+        }
+
+        /// <summary>
+        /// This method is going to be called from the AppContextDefaultValues class when setting up the 
+        /// default values for the switches. !!!! This method is called during the static constructor so it does not
+        /// take a lock !!!! If you are planning to use this outside of that, please ensure proper locking.
+        /// </summary>
+        internal static void DefineSwitchDefault(string switchName, bool isEnabled)
+        {
+            s_switchMap[switchName] = isEnabled ? SwitchValueState.HasTrueValue : SwitchValueState.HasFalseValue;
+        }
+        #endregion
+    }
+}
diff --git a/src/mscorlib/src/System/AppContext/AppContextDefaultValues.CoreClrOverrides.cs b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.CoreClrOverrides.cs
new file mode 100644
index 0000000000..89893c6bee
--- /dev/null
+++ b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.CoreClrOverrides.cs
@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System
+{
+    internal static partial class AppContextDefaultValues
+    {
+        static partial void TryGetSwitchOverridePartial(string switchName, ref bool overrideFound, ref bool overrideValue)
+        {
+            overrideFound = false;
+            overrideValue = false;
+
+            string value = AppContext.GetData(switchName) as string;
+            if (value != null)
+            {
+                overrideFound = bool.TryParse(value, out overrideValue);
+            }
+        }
+    }
+}
diff --git a/src/mscorlib/src/System/AppContext/AppContextDefaultValues.Defaults.Central.cs b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.Defaults.Central.cs
new file mode 100644
index 0000000000..92c9917113
--- /dev/null
+++ b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.Defaults.Central.cs
@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+
+//
+// This file is used to provide an implementation for defining a default value
+// This should be compiled only in mscorlib where the AppContext class is available
+//
+
+namespace System
+{
+    internal static partial class AppContextDefaultValues
+    {
+        /// <summary>
+        /// This method allows reading the override for a switch. 
+        /// The implementation is platform specific
+        /// </summary>
+        public static bool TryGetSwitchOverride(string switchName, out bool overrideValue)
+        {
+            // The default value for a switch is 'false'
+            overrideValue = false;
+
+            // Read the override value
+            bool overrideFound = false;
+
+            // This partial method will be removed if there are no implementations of it.
+            TryGetSwitchOverridePartial(switchName, ref overrideFound, ref overrideValue);
+
+            return overrideFound;
+        }
+    }
+}
diff --git a/src/mscorlib/src/System/AppContext/AppContextDefaultValues.Defaults.cs b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.Defaults.cs
new file mode 100644
index 0000000000..c80913e3a6
--- /dev/null
+++ b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.Defaults.cs
@@ -0,0 +1,71 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace System
+{
+    internal static partial class AppContextDefaultValues
+    {
+
+        internal static readonly string SwitchNoAsyncCurrentCulture = "Switch.System.Globalization.NoAsyncCurrentCulture";
+        internal static readonly string SwitchThrowExceptionIfDisposedCancellationTokenSource = "Switch.System.Threading.ThrowExceptionIfDisposedCancellationTokenSource";
+        internal static readonly string SwitchPreserveEventListnerObjectIdentity = "Switch.System.Diagnostics.EventSource.PreserveEventListnerObjectIdentity";
+#if FEATURE_PATHCOMPAT
+        internal static readonly string SwitchUseLegacyPathHandling = "Switch.System.IO.UseLegacyPathHandling";
+        internal static readonly string SwitchBlockLongPaths = "Switch.System.IO.BlockLongPaths";
+#endif
+
+        // This is a partial method. Platforms can provide an implementation of it that will set override values
+        // from whatever mechanism is available on that platform. If no implementation is provided, the compiler is going to remove the calls
+        // to it from the code
+        // We are going to have an implementation of this method for the Desktop platform that will read the overrides from app.config, registry and
+        // the shim database. Additional implementation can be provided for other platforms.
+        static partial void PopulateOverrideValuesPartial();
+
+        static partial void PopulateDefaultValuesPartial(string platformIdentifier, string profile, int version)
+        {
+            // When defining a new switch  you should add it to the last known version.
+            // For instance, if you are adding a switch in .NET 4.6 (the release after 4.5.2) you should defined your switch
+            // like this:
+            //    if (version <= 40502) ...
+            // This ensures that all previous versions of that platform (up-to 4.5.2) will get the old behavior by default
+            // NOTE: When adding a default value for a switch please make sure that the default value is added to ALL of the existing platforms!
+            // NOTE: When adding a new if statement for the version please ensure that ALL previous switches are enabled (ie. don't use else if)
+            switch (platformIdentifier)
+            {
+                case ".NETCore":
+                case ".NETFramework":
+                    {
+                        if (version <= 40502)
+                        {
+                            AppContext.DefineSwitchDefault(SwitchNoAsyncCurrentCulture, true);
+                            AppContext.DefineSwitchDefault(SwitchThrowExceptionIfDisposedCancellationTokenSource, true);
+                        }
+#if FEATURE_PATHCOMPAT
+                        if (version <= 40601)
+                        {
+                            AppContext.DefineSwitchDefault(SwitchUseLegacyPathHandling, true);
+                            AppContext.DefineSwitchDefault(SwitchBlockLongPaths, true);
+                        }
+#endif
+                        break;
+                    }
+                case "WindowsPhone":
+                case "WindowsPhoneApp":
+                    {
+                        if (version <= 80100)
+                        {
+                            AppContext.DefineSwitchDefault(SwitchNoAsyncCurrentCulture, true);
+                            AppContext.DefineSwitchDefault(SwitchThrowExceptionIfDisposedCancellationTokenSource, true);
+                        }
+                        break;
+                    }
+            }
+
+            // At this point we should read the overrides if any are defined
+            PopulateOverrideValuesPartial();
+        }
+    }
+}
diff --git a/src/mscorlib/src/System/AppContext/AppContextDefaultValues.cs b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.cs
new file mode 100644
index 0000000000..7ab7ffbc04
--- /dev/null
+++ b/src/mscorlib/src/System/AppContext/AppContextDefaultValues.cs
@@ -0,0 +1,164 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+
+namespace System
+{
+    internal static partial class AppContextDefaultValues
+    {
+        public static void PopulateDefaultValues()
+        {
+            string platformIdentifier, profile;
+            int version;
+
+            ParseTargetFrameworkName(out platformIdentifier, out profile, out version);
+
+            // Call into each library to populate their default switches
+            PopulateDefaultValuesPartial(platformIdentifier, profile, version);
+        }
+
+        /// <summary>
+        /// We have this separate method for getting the parsed elements out of the TargetFrameworkName so we can
+        /// more easily support this on other platforms.
+        /// </summary>
+        private static void ParseTargetFrameworkName(out string identifier, out string profile, out int version)
+        {
+            string targetFrameworkMoniker = AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName;
+
+            if (!TryParseFrameworkName(targetFrameworkMoniker, out identifier, out version, out profile))
+            {
+#if FEATURE_CORECLR
+                // If we can't parse the TFM or we don't have a TFM, default to latest behavior for all 
+                // switches (ie. all of them false).
+                // If we want to use the latest behavior it is enough to set the value of the switch to string.Empty.
+                // When the get to the caller of this method (PopulateDefaultValuesPartial) we are going to use the 
+                // identifier we just set to decide which switches to turn on. By having an empty string as the 
+                // identifier we are simply saying -- don't turn on any switches, and we are going to get the latest
+                // behavior for all the switches
+                identifier = string.Empty;
+#else
+                identifier = ".NETFramework";		
+                version = 40000;		
+                profile = string.Empty;
+#endif
+            }
+        }
+
+        // This code was a constructor copied from the FrameworkName class, which is located in System.dll.
+        // Parses strings in the following format: "<identifier>, Version=[v|V]<version>, Profile=<profile>"
+        //  - The identifier and version is required, profile is optional
+        //  - Only three components are allowed.
+        //  - The version string must be in the System.Version format; an optional "v" or "V" prefix is allowed
+        private static bool TryParseFrameworkName(String frameworkName, out String identifier, out int version, out String profile)
+        {
+            // For parsing a target Framework moniker, from the FrameworkName class
+            const char c_componentSeparator = ',';
+            const char c_keyValueSeparator = '=';
+            const char c_versionValuePrefix = 'v';
+            const String c_versionKey = "Version";
+            const String c_profileKey = "Profile";
+
+            identifier = profile = string.Empty;
+            version = 0;
+
+            if (frameworkName == null || frameworkName.Length == 0)
+            {
+                return false;
+            }
+
+            String[] components = frameworkName.Split(c_componentSeparator);
+            version = 0;
+
+            // Identifer and Version are required, Profile is optional.
+            if (components.Length < 2 || components.Length > 3)
+            {
+                return false;
+            }
+
+            //
+            // 1) Parse the "Identifier", which must come first. Trim any whitespace
+            //
+            identifier = components[0].Trim();
+
+            if (identifier.Length == 0)
+            {
+                return false;
+            }
+
+            bool versionFound = false;
+            profile = null;
+
+            // 
+            // The required "Version" and optional "Profile" component can be in any order
+            //
+            for (int i = 1; i < components.Length; i++)
+            {
+                // Get the key/value pair separated by '='
+                string[] keyValuePair = components[i].Split(c_keyValueSeparator);
+
+                if (keyValuePair.Length != 2)
+                {
+                    return false;
+                }
+
+                // Get the key and value, trimming any whitespace
+                string key = keyValuePair[0].Trim();
+                string value = keyValuePair[1].Trim();
+
+                //
+                // 2) Parse the required "Version" key value
+                //
+                if (key.Equals(c_versionKey, StringComparison.OrdinalIgnoreCase))
+                {
+                    versionFound = true;
+
+                    // Allow the version to include a 'v' or 'V' prefix...
+                    if (value.Length > 0 && (value[0] == c_versionValuePrefix || value[0] == 'V'))
+                    {
+                        value = value.Substring(1);
+                    }
+                    Version realVersion = new Version(value);
+                    // The version class will represent some unset values as -1 internally (instead of 0).
+                    version = realVersion.Major * 10000;
+                    if (realVersion.Minor > 0)
+                        version += realVersion.Minor * 100;
+                    if (realVersion.Build > 0)
+                        version += realVersion.Build;
+                }
+                //
+                // 3) Parse the optional "Profile" key value
+                //
+                else if (key.Equals(c_profileKey, StringComparison.OrdinalIgnoreCase))
+                {
+                    if (!String.IsNullOrEmpty(value))
+                    {
+                        profile = value;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            if (!versionFound)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        // This is a partial method. Platforms (such as Desktop) can provide an implementation of it that will read override value
+        // from whatever mechanism is available on that platform. If no implementation is provided, the compiler is going to remove the calls
+        // to it from the code
+        static partial void TryGetSwitchOverridePartial(string switchName, ref bool overrideFound, ref bool overrideValue);
+
+        /// This is a partial method. This method is responsible for populating the default values based on a TFM.
+        /// It is partial because each library should define this method in their code to contain their defaults.
+        static partial void PopulateDefaultValuesPartial(string platformIdentifier, string profile, int version);
+    }
+}
diff --git a/src/mscorlib/src/System/AppContext/AppContextSwitches.cs b/src/mscorlib/src/System/AppContext/AppContextSwitches.cs
new file mode 100644
index 0000000000..3a96ec2159
--- /dev/null
+++ b/src/mscorlib/src/System/AppContext/AppContextSwitches.cs
@@ -0,0 +1,110 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace System
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    internal static class AppContextSwitches
+    {
+        private static int _noAsyncCurrentCulture;
+        public static bool NoAsyncCurrentCulture
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return GetCachedSwitchValue(AppContextDefaultValues.SwitchNoAsyncCurrentCulture, ref _noAsyncCurrentCulture);
+            }
+        }
+
+        private static int _throwExceptionIfDisposedCancellationTokenSource;
+        public static bool ThrowExceptionIfDisposedCancellationTokenSource
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return GetCachedSwitchValue(AppContextDefaultValues.SwitchThrowExceptionIfDisposedCancellationTokenSource, ref _throwExceptionIfDisposedCancellationTokenSource);
+            }
+        }
+
+        private static int _preserveEventListnerObjectIdentity;
+        public static bool PreserveEventListnerObjectIdentity
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return GetCachedSwitchValue(AppContextDefaultValues.SwitchPreserveEventListnerObjectIdentity, ref _preserveEventListnerObjectIdentity);
+            }
+        }
+
+#if FEATURE_PATHCOMPAT
+        private static int _useLegacyPathHandling;
+
+        /// <summary>
+        /// Use legacy path normalization logic and blocking of extended syntax.
+        /// </summary>
+        public static bool UseLegacyPathHandling
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return GetCachedSwitchValue(AppContextDefaultValues.SwitchUseLegacyPathHandling, ref _useLegacyPathHandling);
+            }
+        }
+
+        private static int _blockLongPaths;
+
+        /// <summary>
+        /// Throw PathTooLongException for paths greater than MAX_PATH or directories greater than 248 (as per CreateDirectory Win32 limitations)
+        /// </summary>
+        public static bool BlockLongPaths
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                return GetCachedSwitchValue(AppContextDefaultValues.SwitchBlockLongPaths, ref _blockLongPaths);
+            }
+        }
+#endif // FEATURE_PATHCOMPAT
+
+        //
+        // Implementation details
+        //
+
+        private static bool DisableCaching { get; set; }
+
+        static AppContextSwitches()
+        {
+            bool isEnabled;
+            if (AppContext.TryGetSwitch(@"TestSwitch.LocalAppContext.DisableCaching", out isEnabled))
+            {
+                DisableCaching = isEnabled;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal static bool GetCachedSwitchValue(string switchName, ref int switchValue)
+        {
+            if (switchValue < 0) return false;
+            if (switchValue > 0) return true;
+
+            return GetCachedSwitchValueInternal(switchName, ref switchValue);
+        }
+
+        private static bool GetCachedSwitchValueInternal(string switchName, ref int switchValue)
+        {
+            bool isSwitchEnabled;
+            AppContext.TryGetSwitch(switchName, out isSwitchEnabled);
+
+            if (DisableCaching)
+            {
+                return isSwitchEnabled;
+            }
+
+            switchValue = isSwitchEnabled ? 1 /*true*/ : -1 /*false*/;
+            return isSwitchEnabled;
+        }
+    }
+}
diff --git a/src/mscorlib/src/System/AppDomain.cs b/src/mscorlib/src/System/AppDomain.cs
new file mode 100644
index 0000000000..abaaf48770
--- /dev/null
+++ b/src/mscorlib/src/System/AppDomain.cs
@@ -0,0 +1,4681 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/*=============================================================================
+**
+**
+**
+** Purpose: Domains represent an application within the runtime. Objects can 
+**          not be shared between domains and each domain can be configured
+**          independently. 
+**
+**
+=============================================================================*/
+
+namespace System {
+    using System;
+#if FEATURE_CLICKONCE    
+    using System.Deployment.Internal.Isolation;
+    using System.Deployment.Internal.Isolation.Manifest;
+    using System.Runtime.Hosting;    
+#endif    
+    using System.Reflection;
+    using System.Runtime;
+    using System.Runtime.CompilerServices;
+#if FEATURE_REMOTING    
+    using System.Runtime.Remoting.Channels;
+    using System.Runtime.Remoting.Contexts;
+#endif    
+    using System.Security;
+    using System.Security.Permissions;
+#if FEATURE_IMPERSONATION
+    using System.Security.Principal;
+#endif
+    using System.Security.Policy;
+    using System.Security.Util;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Runtime.InteropServices;
+    using System.Runtime.Remoting;   
+#if FEATURE_REMOTING        
+    using Context = System.Runtime.Remoting.Contexts.Context;
+#endif
+    using System.Reflection.Emit;
+    using CultureInfo = System.Globalization.CultureInfo;
+#if !FEATURE_CORECLR
+    using System.Globalization;
+#endif
+    using System.IO;
+    using AssemblyHashAlgorithm = System.Configuration.Assemblies.AssemblyHashAlgorithm;
+    using System.Text;
+    using Microsoft.Win32;
+    using System.Runtime.ConstrainedExecution;
+    using System.Runtime.Versioning;
+    using System.Diagnostics.Contracts;
+#if FEATURE_EXCEPTION_NOTIFICATIONS
+    using System.Runtime.ExceptionServices;
+#endif // FEATURE_EXCEPTION_NOTIFICATIONS
+
+    [ComVisible(true)]
+    public class ResolveEventArgs : EventArgs
+    {
+        private String _Name;
+        private Assembly _RequestingAssembly;
+
+        public String Name {
+            get {
+                return _Name;
+            }
+        }
+
+        public Assembly RequestingAssembly 
+        {
+            get
+            {
+                return _RequestingAssembly;
+            }
+        }
+
+        public ResolveEventArgs(String name)
+        {
+            _Name = name;
+        }
+
+        public ResolveEventArgs(String name, Assembly requestingAssembly)
+        {
+            _Name = name;
+            _RequestingAssembly = requestingAssembly;
+        }
+    }
+
+    [ComVisible(true)]
+    public class AssemblyLoadEventArgs : EventArgs
+    {
+        private Assembly _LoadedAssembly;
+
+        public Assembly LoadedAssembly {
+            get {
+                return _LoadedAssembly;
+            }
+        }
+
+        public AssemblyLoadEventArgs(Assembly loadedAssembly)
+        {
+            _LoadedAssembly = loadedAssembly;
+        }
+    }
+
+
+    #if FEATURE_CORECLR
+    [System.Security.SecurityCritical] // auto-generated
+    #endif
+    [Serializable]
+    [ComVisible(true)]
+    public delegate Assembly ResolveEventHandler(Object sender, ResolveEventArgs args);
+
+    [Serializable]
+    [ComVisible(true)]
+    public delegate void AssemblyLoadEventHandler(Object sender, AssemblyLoadEventArgs args);
+
+    [Serializable]
+    [ComVisible(true)]
+    public delegate void AppDomainInitializer(string[] args);
+
+    internal class AppDomainInitializerInfo
+    {
+        internal class ItemInfo
+        {
+            public string TargetTypeAssembly;
+            public string TargetTypeName;
+            public string MethodName;
+        }
+
+        internal ItemInfo[] Info;
+
+        internal AppDomainInitializerInfo(AppDomainInitializer init)
+        {
+            Info=null;
+            if (init==null)
+                return;
+            List<ItemInfo> itemInfo = new List<ItemInfo>();
+            List<AppDomainInitializer> nestedDelegates = new List<AppDomainInitializer>();
+            nestedDelegates.Add(init);
+            int idx=0;
+ 
+            while (nestedDelegates.Count>idx)
+            {
+                AppDomainInitializer curr = nestedDelegates[idx++];
+                Delegate[] list= curr.GetInvocationList();
+                for (int i=0;i<list.Length;i++)
+                {
+                    if (!list[i].Method.IsStatic) 
+                    {
+                        if(list[i].Target==null)
+                            continue;
+                    
+                        AppDomainInitializer nested = list[i].Target as AppDomainInitializer;
+                        if (nested!=null)
+                            nestedDelegates.Add(nested);
+                        else
+                            throw new ArgumentException(Environment.GetResourceString("Arg_MustBeStatic"),
+                               list[i].Method.ReflectedType.FullName+"::"+list[i].Method.Name);
+                    }
+                    else
+                    {
+                        ItemInfo info=new ItemInfo();
+                        info.TargetTypeAssembly=list[i].Method.ReflectedType.Module.Assembly.FullName;
+                        info.TargetTypeName=list[i].Method.ReflectedType.FullName;
+                        info.MethodName=list[i].Method.Name;
+                        itemInfo.Add(info);
+                    }
+                    
+                }
+            }
+
+            Info = itemInfo.ToArray();            
+        }
+        
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        internal AppDomainInitializer Unwrap()
+        {
+            if (Info==null)
+                return null;
+            AppDomainInitializer retVal=null;
+            new ReflectionPermission(ReflectionPermissionFlag.MemberAccess).Assert();
+            for (int i=0;i<Info.Length;i++)
+            {
+                Assembly assembly=Assembly.Load(Info[i].TargetTypeAssembly);
+                AppDomainInitializer newVal=(AppDomainInitializer)Delegate.CreateDelegate(typeof(AppDomainInitializer),
+                        assembly.GetType(Info[i].TargetTypeName),
+                        Info[i].MethodName);
+                if(retVal==null)
+                    retVal=newVal;
+                else
+                    retVal+=newVal;
+            }
+            return retVal;
+        }
+    }
+
+
+    [ClassInterface(ClassInterfaceType.None)]
+    [ComDefaultInterface(typeof(System._AppDomain))]
+    [ComVisible(true)]
+    public sealed class AppDomain :
+#if FEATURE_REMOTING
+        MarshalByRefObject,
+#endif
+        _AppDomain, IEvidenceFactory
+    {
+        // Domain security information
+        // These fields initialized from the other side only. (NOTE: order 
+        // of these fields cannot be changed without changing the layout in 
+        // the EE)
+
+        [System.Security.SecurityCritical] // auto-generated
+        private AppDomainManager _domainManager;
+        private Dictionary<String, Object[]> _LocalStore;
+        private AppDomainSetup   _FusionStore;
+        private Evidence         _SecurityIdentity;
+#pragma warning disable 169
+        private Object[]         _Policies; // Called from the VM.
+#pragma warning restore 169
+        [method: System.Security.SecurityCritical]
+        public event AssemblyLoadEventHandler AssemblyLoad;
+
+        [System.Security.SecurityCritical]
+        private ResolveEventHandler _TypeResolve;
+
+        public event ResolveEventHandler TypeResolve
+        {
+            [System.Security.SecurityCritical]
+            add
+            {
+                lock (this)
+                {
+                    _TypeResolve += value;
+                }
+            }
+
+            [System.Security.SecurityCritical]
+            remove
+            {
+                lock (this)
+                {
+                    _TypeResolve -= value;
+                }
+            }
+        }
+
+        [System.Security.SecurityCritical]
+        private ResolveEventHandler _ResourceResolve;
+
+        public event ResolveEventHandler ResourceResolve
+        {
+            [System.Security.SecurityCritical]
+            add
+            {
+                lock (this)
+                {
+                    _ResourceResolve += value;
+                }
+            }
+
+            [System.Security.SecurityCritical]
+            remove
+            {
+                lock (this)
+                {
+                    _ResourceResolve -= value;
+                }
+            }
+        }
+
+        [System.Security.SecurityCritical]
+        private ResolveEventHandler _AssemblyResolve;
+
+        public event ResolveEventHandler AssemblyResolve
+        {
+            [System.Security.SecurityCritical]
+            add
+            {
+                lock (this)
+                {
+                    _AssemblyResolve += value;
+                }
+            }
+
+            [System.Security.SecurityCritical]
+            remove
+            {
+                lock (this)
+                {
+                    _AssemblyResolve -= value;
+                }
+            }
+        }
+
+#if FEATURE_REFLECTION_ONLY_LOAD
+        [method: System.Security.SecurityCritical]
+        public event ResolveEventHandler ReflectionOnlyAssemblyResolve;
+#endif // FEATURE_REFLECTION_ONLY
+
+#if FEATURE_REMOTING        
+        private Context          _DefaultContext;
+#endif
+
+#if FEATURE_CLICKONCE
+        private ActivationContext _activationContext;        
+        private ApplicationIdentity _applicationIdentity;        
+#endif
+        private ApplicationTrust _applicationTrust;
+
+#if FEATURE_IMPERSONATION
+        private IPrincipal       _DefaultPrincipal;
+#endif // FEATURE_IMPERSONATION
+#if FEATURE_REMOTING
+        private DomainSpecificRemotingData _RemotingData;
+#endif
+        private EventHandler     _processExit;
+
+        #if FEATURE_CORECLR
+        [System.Security.SecurityCritical] 
+        #endif
+        private EventHandler     _domainUnload;
+
+        #if FEATURE_CORECLR
+        [System.Security.SecurityCritical] // auto-generated
+        #endif
+        private UnhandledExceptionEventHandler _unhandledException;
+
+#if FEATURE_APTCA
+        private String[]         _aptcaVisibleAssemblies;
+#endif
+
+        // The compat flags are set at domain creation time to indicate that the given breaking
+        // changes (named in the strings) should not be used in this domain. We only use the 
+        // keys, the vhe values are ignored.
+        private Dictionary<String, object>  _compatFlags;
+
+#if FEATURE_EXCEPTION_NOTIFICATIONS
+        // Delegate that will hold references to FirstChance exception notifications
+        private EventHandler<FirstChanceExceptionEventArgs> _firstChanceException;
+#endif // FEATURE_EXCEPTION_NOTIFICATIONS
+
+        private IntPtr           _pDomain;                      // this is an unmanaged pointer (AppDomain * m_pDomain)` used from the VM.
+
+#if FEATURE_CAS_POLICY
+        private PrincipalPolicy  _PrincipalPolicy;              // this is an enum
+#endif        
+        private bool             _HasSetPolicy;
+        private bool             _IsFastFullTrustDomain;        // quick check to see if the AppDomain is fully trusted and homogenous
+        private bool             _compatFlagsInitialized;
+
+        internal const String TargetFrameworkNameAppCompatSetting = "TargetFrameworkName";
+
+#if FEATURE_APPX
+        private static APPX_FLAGS s_flags;
+
+        //
+        // Keep in async with vm\appdomainnative.cpp
+        //
+        [Flags]
+        private enum APPX_FLAGS
+        {
+            APPX_FLAGS_INITIALIZED =        0x01,
+
+            APPX_FLAGS_APPX_MODEL =         0x02,
+            APPX_FLAGS_APPX_DESIGN_MODE =   0x04,
+            APPX_FLAGS_APPX_NGEN =          0x08,
+            APPX_FLAGS_APPX_MASK =          APPX_FLAGS_APPX_MODEL |
+                                            APPX_FLAGS_APPX_DESIGN_MODE |
+                                            APPX_FLAGS_APPX_NGEN,
+
+            APPX_FLAGS_API_CHECK =          0x10,
+        }
+
+        private static APPX_FLAGS Flags
+        {
+            [SecuritySafeCritical]
+            get
+            {
+                if (s_flags == 0)
+                    s_flags = nGetAppXFlags();
+
+                Contract.Assert(s_flags != 0);
+                return s_flags;
+            }
+        }
+
+        internal static bool ProfileAPICheck
+        {
+            [SecuritySafeCritical]
+            get
+            {
+                return (Flags & APPX_FLAGS.APPX_FLAGS_API_CHECK) != 0;
+            }
+        }
+
+        internal static bool IsAppXNGen
+        {
+            [SecuritySafeCritical]
+            get
+            {
+                return (Flags & APPX_FLAGS.APPX_FLAGS_APPX_NGEN) != 0;
+            }
+        }
+#endif // FEATURE_APPX
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool DisableFusionUpdatesFromADManager(AppDomainHandle domain);
+
+#if FEATURE_APPX
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [return: MarshalAs(UnmanagedType.I4)]
+        private static extern APPX_FLAGS nGetAppXFlags();
+#endif
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        private static extern void GetAppDomainManagerType(AppDomainHandle domain,
+                                                           StringHandleOnStack retAssembly,
+                                                           StringHandleOnStack retType);
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        private static extern void SetAppDomainManagerType(AppDomainHandle domain,
+                                                           string assembly,
+                                                           string type);
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern void nSetHostSecurityManagerFlags (HostSecurityManagerOptions flags);
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void SetSecurityHomogeneousFlag(AppDomainHandle domain,
+                                                              [MarshalAs(UnmanagedType.Bool)] bool runtimeSuppliedHomogenousGrantSet);
+
+#if FEATURE_CAS_POLICY
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void SetLegacyCasPolicyEnabled(AppDomainHandle domain);
+
+        [SecurityCritical]
+        private void SetLegacyCasPolicyEnabled()
+        {
+            SetLegacyCasPolicyEnabled(GetNativeHandle());
+        }
+#endif // FEATURE_CAS_POLICY
+
+        /// <summary>
+        ///     Get a handle used to make a call into the VM pointing to this domain
+        /// </summary>
+        internal AppDomainHandle GetNativeHandle()
+        {
+            // This should never happen under normal circumstances. However, there ar ways to create an
+            // uninitialized object through remoting, etc.
+            if (_pDomain.IsNull())
+            {
+                throw new InvalidOperationException(Environment.GetResourceString("Argument_InvalidHandle"));
+            }
+
+#if FEATURE_REMOTING
+            BCLDebug.Assert(!RemotingServices.IsTransparentProxy(this), "QCalls should be made with the real AppDomain object rather than a transparent proxy");
+#endif // FEATURE_REMOTING
+            return new AppDomainHandle(_pDomain);
+        }
+
+        /// <summary>
+        ///     If this AppDomain is configured to have an AppDomain manager then create the instance of it.
+        ///     This method is also called from the VM to create the domain manager in the default domain.
+        /// </summary>
+        [SecuritySafeCritical]
+        private void CreateAppDomainManager()
+        {
+            Contract.Assert(_domainManager == null, "_domainManager == null");
+
+            AppDomainSetup adSetup = FusionStore;
+#if FEATURE_VERSIONING
+            String trustedPlatformAssemblies = (String)(GetData("TRUSTED_PLATFORM_ASSEMBLIES"));
+            if (trustedPlatformAssemblies != null)
+            {
+                String platformResourceRoots = (String)(GetData("PLATFORM_RESOURCE_ROOTS"));
+                if (platformResourceRoots == null)
+                {
+                    platformResourceRoots = String.Empty;
+                }
+
+                String appPaths = (String)(GetData("APP_PATHS"));
+                if (appPaths == null)
+                {
+                    appPaths = String.Empty;
+                }
+
+                String appNiPaths = (String)(GetData("APP_NI_PATHS"));
+                if (appNiPaths == null)
+                {
+                    appNiPaths = String.Empty;
+                }
+
+                String appLocalWinMD = (String)(GetData("APP_LOCAL_WINMETADATA"));
+                if (appLocalWinMD == null)
+                {
+                    appLocalWinMD = String.Empty;
+                }
+                SetupBindingPaths(trustedPlatformAssemblies, platformResourceRoots, appPaths, appNiPaths, appLocalWinMD);
+            }
+#endif // FEATURE_VERSIONING
+
+            string domainManagerAssembly;
+            string domainManagerType;
+            GetAppDomainManagerType(out domainManagerAssembly, out domainManagerType);
+
+            if (domainManagerAssembly != null && domainManagerType != null)
+            {
+                try
+                {
+                    new PermissionSet(PermissionState.Unrestricted).Assert();
+                    _domainManager = CreateInstanceAndUnwrap(domainManagerAssembly, domainManagerType) as AppDomainManager;
+                    CodeAccessPermission.RevertAssert();
+                }
+                catch (FileNotFoundException e)
+                {
+                    throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"), e);
+                }
+                catch (SecurityException e)
+                {
+                    throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"), e);
+                }
+                catch (TypeLoadException e)
+                {
+                    throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"), e);
+                }
+
+                if (_domainManager == null)
+                {
+                    throw new TypeLoadException(Environment.GetResourceString("Argument_NoDomainManager"));
+                }
+
+                // If this domain was not created by a managed call to CreateDomain, then the AppDomainSetup
+                // will not have the correct values for the AppDomainManager set.
+                FusionStore.AppDomainManagerAssembly = domainManagerAssembly;
+                FusionStore.AppDomainManagerType = domainManagerType;
+
+                bool notifyFusion = _domainManager.GetType() != typeof(System.AppDomainManager) && !DisableFusionUpdatesFromADManager();
+
+
+
+                AppDomainSetup FusionStoreOld = null;
+                if (notifyFusion)
+                    FusionStoreOld = new AppDomainSetup(FusionStore, true);
+
+                // Initialize the AppDomainMAnager and register the instance with the native host if requested
+                _domainManager.InitializeNewDomain(FusionStore);
+
+                if (notifyFusion)
+                    SetupFusionStore(_FusionStore, FusionStoreOld); // Notify Fusion about the changes the user implementation of InitializeNewDomain may have made to the FusionStore object.
+                                
+#if FEATURE_APPDOMAINMANAGER_INITOPTIONS                
+                AppDomainManagerInitializationOptions flags = _domainManager.InitializationFlags;
+                if ((flags & AppDomainManagerInitializationOptions.RegisterWithHost) == AppDomainManagerInitializationOptions.RegisterWithHost)
+                {
+                    _domainManager.RegisterWithHost();
+                }
+#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
+            }
+
+            InitializeCompatibilityFlags();       
+        }
+
+        /// <summary>
+        ///     Initialize the compatibility flags to non-NULL values.
+        ///     This method is also called from the VM when the default domain dosen't have a domain manager.
+        /// </summary>
+        private void InitializeCompatibilityFlags()
+        {
+            AppDomainSetup adSetup = FusionStore;
+            
+            // set up shim flags regardless of whether we create a DomainManager in this method.
+            if (adSetup.GetCompatibilityFlags() != null)
+            {
+                _compatFlags = new Dictionary<String, object>(adSetup.GetCompatibilityFlags(), StringComparer.OrdinalIgnoreCase);
+            }
+
+            // for perf, we don't intialize the _compatFlags dictionary when we don't need to.  However, we do need to make a 
+            // note that we've run this method, because IsCompatibilityFlagsSet needs to return different values for the
+            // case where the compat flags have been setup.
+            Contract.Assert(!_compatFlagsInitialized);
+            _compatFlagsInitialized = true;
+
+            CompatibilitySwitches.InitializeSwitches();
+        }
+
+        // Retrieves a possibly-cached target framework name for this appdomain.  This could be set
+        // either by a host in native, a host in managed using an AppDomainSetup, or by the 
+        // TargetFrameworkAttribute on the executable (VS emits its target framework moniker using this
+        // attribute starting in version 4).
+        [SecuritySafeCritical]
+        internal String GetTargetFrameworkName()
+        {
+            String targetFrameworkName = _FusionStore.TargetFrameworkName;
+
+            if (targetFrameworkName == null && IsDefaultAppDomain() && !_FusionStore.CheckedForTargetFrameworkName)
+            {
+                // This should only be run in the default appdomain.  All other appdomains should have
+                // values copied from the default appdomain and/or specified by the host.
+                Assembly assembly = Assembly.GetEntryAssembly();
+                if (assembly != null)
+                {
+                    TargetFrameworkAttribute[] attrs = (TargetFrameworkAttribute[])assembly.GetCustomAttributes(typeof(TargetFrameworkAttribute));
+                    if (attrs != null && attrs.Length > 0)
+                    {
+                        Contract.Assert(attrs.Length == 1);
+                        targetFrameworkName = attrs[0].FrameworkName;
+                        _FusionStore.TargetFrameworkName = targetFrameworkName;
+                    }
+                }
+                _FusionStore.CheckedForTargetFrameworkName = true;
+            }
+
+            return targetFrameworkName;
+        }
+
+        /// <summary>
+        ///     Returns the setting of the corresponding compatibility config switch (see CreateAppDomainManager for the impact).
+        /// </summary>
+        [SecuritySafeCritical]
+        internal bool DisableFusionUpdatesFromADManager()
+        {
+            return DisableFusionUpdatesFromADManager(GetNativeHandle());
+        }
+
+        /// <summary>
+        ///     Returns whether the current AppDomain follows the AppX rules.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static bool IsAppXModel()
+        {
+#if FEATURE_APPX
+            return (Flags & APPX_FLAGS.APPX_FLAGS_APPX_MODEL) != 0;
+#else
+            return false;
+#endif
+        }
+
+        /// <summary>
+        ///     Returns the setting of the AppXDevMode config switch.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static bool IsAppXDesignMode()
+        {
+#if FEATURE_APPX
+            return (Flags & APPX_FLAGS.APPX_FLAGS_APPX_MASK) == (APPX_FLAGS.APPX_FLAGS_APPX_MODEL | APPX_FLAGS.APPX_FLAGS_APPX_DESIGN_MODE);
+#else
+            return false;
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports Assembly.LoadFrom.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckLoadFromSupported()
+        {
+#if FEATURE_APPX
+            if (IsAppXModel())
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.LoadFrom"));
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports Assembly.LoadFile.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckLoadFileSupported()
+        {
+#if FEATURE_APPX
+            if (IsAppXModel())
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.LoadFile"));
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports Assembly.ReflectionOnlyLoad.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckReflectionOnlyLoadSupported()
+        {
+#if FEATURE_APPX
+            if (IsAppXModel())
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.ReflectionOnlyLoad"));
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports Assembly.LoadWithPartialName.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckLoadWithPartialNameSupported(StackCrawlMark stackMark)
+        {
+#if FEATURE_APPX
+            if (IsAppXModel())
+            {
+                RuntimeAssembly callingAssembly = RuntimeAssembly.GetExecutingAssembly(ref stackMark);
+                bool callerIsFxAssembly = callingAssembly != null && callingAssembly.IsFrameworkAssembly();
+                if (!callerIsFxAssembly)
+                {
+                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.LoadWithPartialName"));
+                }
+            }
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports DefinePInvokeMethod.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckDefinePInvokeSupported()
+        {
+            // We don't want users to use DefinePInvokeMethod in RefEmit to bypass app store validation on allowed native libraries.
+#if FEATURE_APPX
+            if (IsAppXModel())
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "DefinePInvokeMethod"));
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports Assembly.Load(byte[] ...).
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckLoadByteArraySupported()
+        {
+#if FEATURE_APPX
+            if (IsAppXModel())
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "Assembly.Load(byte[], ...)"));
+#endif
+        }
+
+        /// <summary>
+        ///     Checks (and throws on failure) if the domain supports AppDomain.CreateDomain.
+        /// </summary>
+        [SecuritySafeCritical]
+        [Pure]
+        internal static void CheckCreateDomainSupported()
+        {
+#if FEATURE_APPX
+            // Can create a new domain in an AppX process only when DevMode is enabled and
+            // AssemblyLoadingCompat is not enabled (since there is no multi-domain support
+            // for LoadFrom and LoadFile in AppX.
+            if(IsAppXModel())
+            {
+                if (!IsAppXDesignMode())
+                {
+                    throw new NotSupportedException(Environment.GetResourceString("NotSupported_AppX", "AppDomain.CreateDomain"));
+                }
+            }
+#endif
+        }
+
+        /// <summary>
+        ///     Get the name of the assembly and type that act as the AppDomainManager for this domain
+        /// </summary>
+        [SecuritySafeCritical]
+        internal void GetAppDomainManagerType(out string assembly, out string type)
+        {
+            // We can't just use our parameters because we need to ensure that the strings used for hte QCall
+            // are on the stack.
+            string localAssembly = null;
+            string localType = null;
+
+            GetAppDomainManagerType(GetNativeHandle(),
+                                    JitHelpers.GetStringHandleOnStack(ref localAssembly),
+                                    JitHelpers.GetStringHandleOnStack(ref localType));
+
+            assembly = localAssembly;
+            type = localType;
+        }
+
+        /// <summary>
+        ///     Set the assembly and type which act as the AppDomainManager for this domain
+        /// </summary>
+        [SecuritySafeCritical]
+        private void SetAppDomainManagerType(string assembly, string type)
+        {
+            Contract.Assert(assembly != null, "assembly != null");
+            Contract.Assert(type != null, "type != null");
+            SetAppDomainManagerType(GetNativeHandle(), assembly, type);
+        }
+
+#if FEATURE_APTCA
+        internal String[] PartialTrustVisibleAssemblies
+        {
+            get { return _aptcaVisibleAssemblies; }
+
+            [SecuritySafeCritical]
+            set
+            {
+                _aptcaVisibleAssemblies = value;
+
+                // Build up the canonical representaiton of this list to allow the VM to do optimizations in
+                // common cases
+                string canonicalConditionalAptcaList = null;
+                if (value != null)
+                {
+                    StringBuilder conditionalAptcaListBuilder = StringBuilderCache.Acquire();
+                    for (int i = 0; i < value.Length; ++i)
+                    {
+                        if (value[i] != null)
+                        {
+                            conditionalAptcaListBuilder.Append(value[i].ToUpperInvariant());
+                            if (i != value.Length - 1)
+                            {
+                                conditionalAptcaListBuilder.Append(';');
+                            }
+                        }
+                    }
+
+                    canonicalConditionalAptcaList = StringBuilderCache.GetStringAndRelease(conditionalAptcaListBuilder);
+                }
+
+                SetCanonicalConditionalAptcaList(canonicalConditionalAptcaList);
+            }
+        }
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void SetCanonicalConditionalAptcaList(AppDomainHandle appDomain, string canonicalList);
+
+        [SecurityCritical]
+        private void SetCanonicalConditionalAptcaList(string canonicalList)
+        {
+            SetCanonicalConditionalAptcaList(GetNativeHandle(), canonicalList);
+        }
+#endif // FEATURE_APTCA
+
+#if FEATURE_CLICKONCE
+        /// <summary>
+        ///    If the CLR is being started up to run a ClickOnce applicaiton, setup the default AppDomain
+        ///    with information about that application.
+        /// </summary>
+        private void SetupDefaultClickOnceDomain(string fullName, string[] manifestPaths, string[] activationData)
+        {
+            Contract.Requires(fullName != null, "fullName != null");
+            FusionStore.ActivationArguments = new ActivationArguments(fullName, manifestPaths, activationData);
+        }
+#endif // FEATURE_CLICKONCE
+
+        /// <summary>
+        ///     Called for every AppDomain (including the default domain) to initialize the security of the AppDomain)
+        /// </summary>
+        [SecurityCritical]
+        private void InitializeDomainSecurity(Evidence providedSecurityInfo,
+                                              Evidence creatorsSecurityInfo,
+                                              bool generateDefaultEvidence,
+                                              IntPtr parentSecurityDescriptor,
+                                              bool publishAppDomain)
+        {
+            AppDomainSetup adSetup = FusionStore;
+
+#if FEATURE_CAS_POLICY
+            // If the AppDomain is setup to use legacy CAS policy, then set that bit in the application
+            // security descriptor.
+            if (CompatibilitySwitches.IsNetFx40LegacySecurityPolicy)
+            {
+                SetLegacyCasPolicyEnabled();
+            }
+#endif // FEATURE_CAS_POLICY
+
+#if FEATURE_CLICKONCE
+
+            // Check if the domain manager set an ActivationContext (Debug-In-Zone for example)
+            // or if this is an AppDomain with an ApplicationTrust.
+            if (adSetup.ActivationArguments != null) {
+                // Merge the new evidence with the manifest's evidence if applicable
+                ActivationContext activationContext = null;
+                ApplicationIdentity appIdentity = null;
+                string[] activationData = null;
+                CmsUtils.CreateActivationContext(adSetup.ActivationArguments.ApplicationFullName,
+                                                 adSetup.ActivationArguments.ApplicationManifestPaths,
+                                                 adSetup.ActivationArguments.UseFusionActivationContext,
+                                                 out appIdentity, out activationContext);
+                activationData = adSetup.ActivationArguments.ActivationData;
+                providedSecurityInfo = CmsUtils.MergeApplicationEvidence(providedSecurityInfo,
+                                                                         appIdentity,
+                                                                         activationContext,
+                                                                         activationData,
+                                                                         adSetup.ApplicationTrust);
+                SetupApplicationHelper(providedSecurityInfo, creatorsSecurityInfo, appIdentity, activationContext, activationData);
+            }
+            else 
+#endif // FEATURE_CLICKONCE
+            {
+                bool runtimeSuppliedHomogenousGrant = false;
+                ApplicationTrust appTrust = adSetup.ApplicationTrust;
+                
+#if FEATURE_CAS_POLICY
+                // In non-legacy CAS mode, domains should be homogenous.  If the host has not specified a sandbox
+                // of their own, we'll set it up to be fully trusted.  We must read the IsLegacyCasPolicy
+                // enabled property here rathern than just reading the switch from above because the entire
+                // process may also be opted into legacy CAS policy mode.
+                if (appTrust == null && !IsLegacyCasPolicyEnabled) {
+                    _IsFastFullTrustDomain = true;
+                    runtimeSuppliedHomogenousGrant = true;
+                }
+#endif // FEATURE_CAS_POLICY
+
+                if (appTrust != null) {
+                    SetupDomainSecurityForHomogeneousDomain(appTrust, runtimeSuppliedHomogenousGrant);
+                }
+                else if (_IsFastFullTrustDomain) {
+                    SetSecurityHomogeneousFlag(GetNativeHandle(), runtimeSuppliedHomogenousGrant);
+                }
+            }
+
+            // Get the evidence supplied for the domain.  If no evidence was supplied, it means that we want
+            // to use the default evidence creation strategy for this domain
+            Evidence newAppDomainEvidence = (providedSecurityInfo != null ? providedSecurityInfo : creatorsSecurityInfo);
+            if (newAppDomainEvidence == null && generateDefaultEvidence) {
+#if FEATURE_CAS_POLICY
+                newAppDomainEvidence = new Evidence(new AppDomainEvidenceFactory(this));
+#else // !FEATURE_CAS_POLICY
+                newAppDomainEvidence = new Evidence();
+#endif // FEATURE_CAS_POLICY
+            }
+
+#if FEATURE_CAS_POLICY
+            if (_domainManager != null) {
+                // Give the host a chance to alter the AppDomain evidence
+                HostSecurityManager securityManager = _domainManager.HostSecurityManager;
+                if (securityManager != null) {
+                    nSetHostSecurityManagerFlags (securityManager.Flags);
+                    if ((securityManager.Flags & HostSecurityManagerOptions.HostAppDomainEvidence) == HostSecurityManagerOptions.HostAppDomainEvidence) {
+                        newAppDomainEvidence = securityManager.ProvideAppDomainEvidence(newAppDomainEvidence);
+                        // If this is a disconnected evidence collection, then attach it to the AppDomain,
+                        // allowing the host security manager to get callbacks for delay generated evidence
+                        if (newAppDomainEvidence != null && newAppDomainEvidence.Target == null) {
+                            newAppDomainEvidence.Target = new AppDomainEvidenceFactory(this);
+                        }
+                    }
+                }
+            }
+
+#endif // FEATURE_CAS_POLICY
+
+            // Set the evidence on the managed side
+            _SecurityIdentity = newAppDomainEvidence;
+
+            // Set the evidence of the AppDomain in the VM.
+            // Also, now that the initialization is complete, signal that to the security system.
+            // Finish the AppDomain initialization and resolve the policy for the AppDomain evidence.
+            SetupDomainSecurity(newAppDomainEvidence,
+                                parentSecurityDescriptor,
+                                publishAppDomain);
+
+#if FEATURE_CAS_POLICY
+            // The AppDomain is now resolved. Go ahead and set the PolicyLevel
+            // from the HostSecurityManager if specified.
+            if (_domainManager != null)
+                RunDomainManagerPostInitialization(_domainManager);
+#endif // FEATURE_CAS_POLICY
+        }
+
+#if FEATURE_CAS_POLICY
+        [System.Security.SecurityCritical]  // auto-generated
+        private void RunDomainManagerPostInitialization (AppDomainManager domainManager)
+        {
+            // force creation of the HostExecutionContextManager for the current AppDomain
+            HostExecutionContextManager contextManager = domainManager.HostExecutionContextManager;
+
+            if (IsLegacyCasPolicyEnabled)
+            {
+#pragma warning disable 618
+                HostSecurityManager securityManager = domainManager.HostSecurityManager;
+                if (securityManager != null)
+                {
+                    if ((securityManager.Flags & HostSecurityManagerOptions.HostPolicyLevel) == HostSecurityManagerOptions.HostPolicyLevel)
+                    {
+                        // set AppDomain policy if specified
+                        PolicyLevel level = securityManager.DomainPolicy;
+                        if (level != null)
+                            SetAppDomainPolicy(level);
+                    }
+                }
+#pragma warning restore 618
+            }
+        }
+#endif 
+
+
+#if FEATURE_CLICKONCE
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetupApplicationHelper (Evidence providedSecurityInfo, Evidence creatorsSecurityInfo, ApplicationIdentity appIdentity, ActivationContext activationContext, string[] activationData) {
+            Contract.Requires(providedSecurityInfo != null);
+            HostSecurityManager securityManager = AppDomain.CurrentDomain.HostSecurityManager;
+            ApplicationTrust appTrust = securityManager.DetermineApplicationTrust(providedSecurityInfo, creatorsSecurityInfo, new TrustManagerContext());
+            if (appTrust == null || !appTrust.IsApplicationTrustedToRun)
+                throw new PolicyException(Environment.GetResourceString("Policy_NoExecutionPermission"),
+                                          System.__HResults.CORSEC_E_NO_EXEC_PERM,
+                                          null);
+
+            // The application is trusted to run. Set up the AppDomain according to the manifests.
+            if (activationContext != null)
+                SetupDomainForApplication(activationContext, activationData);
+            SetupDomainSecurityForApplication(appIdentity, appTrust);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetupDomainForApplication(ActivationContext activationContext, string[] activationData) {
+            Contract.Requires(activationContext != null);
+            if (IsDefaultAppDomain()) {
+                // make the ActivationArguments available off the AppDomain object.
+                AppDomainSetup adSetup = this.FusionStore;
+                adSetup.ActivationArguments = new ActivationArguments(activationContext, activationData);
+
+                // set the application base to point at where the application resides
+                string entryPointPath = CmsUtils.GetEntryPointFullPath(activationContext);
+                if (!String.IsNullOrEmpty(entryPointPath))
+                    adSetup.SetupDefaults(entryPointPath);
+                else
+                    adSetup.ApplicationBase = activationContext.ApplicationDirectory;
+
+                // update fusion context
+                SetupFusionStore(adSetup, null);
+            }
+
+            // perform app data directory migration.
+            activationContext.PrepareForExecution();
+            activationContext.SetApplicationState(ActivationContext.ApplicationState.Starting);
+            // set current app data directory.
+            activationContext.SetApplicationState(ActivationContext.ApplicationState.Running);
+
+            // make data directory path available.
+            IPermission permission = null;
+            string dataDirectory = activationContext.DataDirectory;
+            if (dataDirectory != null && dataDirectory.Length > 0)
+                permission = new FileIOPermission(FileIOPermissionAccess.PathDiscovery, dataDirectory);
+            this.SetData("DataDirectory", dataDirectory, permission);
+
+            _activationContext = activationContext;
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetupDomainSecurityForApplication(ApplicationIdentity appIdentity,
+                                                       ApplicationTrust appTrust)
+        {
+            // Set the Application trust on the managed side.
+            _applicationIdentity = appIdentity;
+            SetupDomainSecurityForHomogeneousDomain(appTrust, false);
+        }
+#endif // FEATURE_CLICKONCE
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetupDomainSecurityForHomogeneousDomain(ApplicationTrust appTrust,
+                                                             bool runtimeSuppliedHomogenousGrantSet)
+        {
+            // If the CLR has supplied the homogenous grant set (that is, this domain would have been
+            // heterogenous in v2.0), then we need to strip the ApplicationTrust from the AppDomainSetup of
+            // the current domain.  This prevents code which does:
+            //   AppDomain.CreateDomain(..., AppDomain.CurrentDomain.SetupInformation);
+            // 
+            // From looking like it is trying to create a homogenous domain intentionally, and therefore
+            // having its evidence check bypassed.
+            if (runtimeSuppliedHomogenousGrantSet)
+            {
+                BCLDebug.Assert(_FusionStore.ApplicationTrust != null, "Expected to find runtime supplied ApplicationTrust");
+#if FEATURE_CAS_POLICY
+                _FusionStore.ApplicationTrust = null;
+#endif // FEATURE_CAS_POLICY
+            }
+
+            _applicationTrust = appTrust;
+
+            // Set the homogeneous bit in the VM's ApplicationSecurityDescriptor.
+            SetSecurityHomogeneousFlag(GetNativeHandle(),
+                                       runtimeSuppliedHomogenousGrantSet);
+        }
+
+        // This method is called from CorHost2::ExecuteApplication to activate a ClickOnce application in the default AppDomain.
+#if FEATURE_CLICKONCE
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        private int ActivateApplication () {
+            ObjectHandle oh = Activator.CreateInstance(AppDomain.CurrentDomain.ActivationContext);
+            return (int) oh.Unwrap();
+        }
+#endif //FEATURE_CLICKONCE
+
+        public AppDomainManager DomainManager {
+            [System.Security.SecurityCritical]  // auto-generated_required
+            get {
+                return _domainManager;
+            }
+        }
+
+#if FEATURE_CAS_POLICY
+        internal HostSecurityManager HostSecurityManager {
+            [System.Security.SecurityCritical]  // auto-generated
+            get {
+                HostSecurityManager securityManager = null;
+                AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
+                if (domainManager != null)
+                    securityManager = domainManager.HostSecurityManager;
+
+                if (securityManager == null)
+                    securityManager = new HostSecurityManager();
+                return securityManager;
+            }
+        }
+#endif // FEATURE_CAS_POLICY
+#if FEATURE_REFLECTION_ONLY_LOAD        
+        private Assembly ResolveAssemblyForIntrospection(Object sender, ResolveEventArgs args)
+        {
+            Contract.Requires(args != null);
+            return Assembly.ReflectionOnlyLoad(ApplyPolicy(args.Name));
+        }
+        
+        // Helper class for method code:EnableResolveAssembliesForIntrospection
+        private class NamespaceResolverForIntrospection
+        {
+            private IEnumerable<string> _packageGraphFilePaths;
+            public NamespaceResolverForIntrospection(IEnumerable<string> packageGraphFilePaths)
+            {
+                _packageGraphFilePaths = packageGraphFilePaths;
+            }
+            
+            [System.Security.SecurityCritical]
+            public void ResolveNamespace(
+                object sender, 
+                System.Runtime.InteropServices.WindowsRuntime.NamespaceResolveEventArgs args)
+            {
+                Contract.Requires(args != null);
+                
+                IEnumerable<string> fileNames = System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.ResolveNamespace(
+                    args.NamespaceName,
+                    null,   // windowsSdkFilePath ... Use OS installed .winmd files
+                    _packageGraphFilePaths);
+                foreach (string fileName in fileNames)
+                {
+                    args.ResolvedAssemblies.Add(Assembly.ReflectionOnlyLoadFrom(fileName));
+                }
+            }
+        }
+        
+        // Called only by native function code:ValidateWorker
+        [System.Security.SecuritySafeCritical]
+        private void EnableResolveAssembliesForIntrospection(string verifiedFileDirectory)
+        {
+            CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(ResolveAssemblyForIntrospection);
+            
+            string[] packageGraphFilePaths = null;
+            if (verifiedFileDirectory != null)
+                packageGraphFilePaths = new string[] { verifiedFileDirectory };
+            NamespaceResolverForIntrospection namespaceResolver = new NamespaceResolverForIntrospection(packageGraphFilePaths);
+            
+            System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.ReflectionOnlyNamespaceResolve += 
+                new EventHandler<System.Runtime.InteropServices.WindowsRuntime.NamespaceResolveEventArgs>(namespaceResolver.ResolveNamespace);
+        }
+#endif // FEATURE_REFLECTION_ONLY_LOAD
+
+
+        /**********************************************
+        * If an AssemblyName has a public key specified, the assembly is assumed
+        * to have a strong name and a hash will be computed when the assembly
+        * is saved.
+        **********************************************/
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, null,
+                                                 null, null, null, null, ref stackMark, null, SecurityContextSource.CurrentAssembly);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            IEnumerable<CustomAttributeBuilder> assemblyAttributes)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name,
+                                                 access,
+                                                 null, null, null, null, null,
+                                                 ref stackMark,
+                                                 assemblyAttributes, SecurityContextSource.CurrentAssembly);
+        }
+
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Due to the stack crawl mark
+        [SecuritySafeCritical]
+        public AssemblyBuilder DefineDynamicAssembly(AssemblyName name,
+                                                     AssemblyBuilderAccess access,
+                                                     IEnumerable<CustomAttributeBuilder> assemblyAttributes,
+                                                     SecurityContextSource securityContextSource)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name,
+                                                 access,
+                                                 null, null, null, null, null,
+                                                 ref stackMark,
+                                                 assemblyAttributes,
+                                                 securityContextSource);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            String                  dir)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, dir,
+                                                 null, null, null, null,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            Evidence                evidence)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, null,
+                                                 evidence, null, null, null,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            PermissionSet           requiredPermissions,
+            PermissionSet           optionalPermissions,
+            PermissionSet           refusedPermissions)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, null, null,
+                                                 requiredPermissions,
+                                                 optionalPermissions,
+                                                 refusedPermissions,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of DefineDynamicAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            String                  dir,
+            Evidence                evidence)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, dir, evidence,
+                                                 null, null, null, ref stackMark, null, SecurityContextSource.CurrentAssembly);
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            String                  dir,
+            PermissionSet           requiredPermissions,
+            PermissionSet           optionalPermissions,
+            PermissionSet           refusedPermissions)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, dir, null,
+                                                 requiredPermissions,
+                                                 optionalPermissions,
+                                                 refusedPermissions,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            Evidence                evidence,
+            PermissionSet           requiredPermissions,
+            PermissionSet           optionalPermissions,
+            PermissionSet           refusedPermissions)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, null,
+                                                 evidence,
+                                                 requiredPermissions,
+                                                 optionalPermissions,
+                                                 refusedPermissions,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+    
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default.  Please see http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            String                  dir,
+            Evidence                evidence,
+            PermissionSet           requiredPermissions,
+            PermissionSet           optionalPermissions,
+            PermissionSet           refusedPermissions)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name, access, dir,
+                                                 evidence,
+                                                 requiredPermissions,
+                                                 optionalPermissions,
+                                                 refusedPermissions,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+            AssemblyName            name,
+            AssemblyBuilderAccess   access,
+            String                  dir,
+            Evidence                evidence,
+            PermissionSet           requiredPermissions,
+            PermissionSet           optionalPermissions,
+            PermissionSet           refusedPermissions,
+            bool                    isSynchronized)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name,
+                                                 access,
+                                                 dir,
+                                                 evidence,
+                                                 requiredPermissions,
+                                                 optionalPermissions,
+                                                 refusedPermissions,
+                                                 ref stackMark,
+                                                 null,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Assembly level declarative security is obsolete and is no longer enforced by the CLR by default. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public AssemblyBuilder DefineDynamicAssembly(
+                    AssemblyName name,
+                    AssemblyBuilderAccess access,
+                    String dir,
+                    Evidence evidence,
+                    PermissionSet requiredPermissions,
+                    PermissionSet optionalPermissions,
+                    PermissionSet refusedPermissions,
+                    bool isSynchronized,
+                    IEnumerable<CustomAttributeBuilder> assemblyAttributes)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name,
+                                                 access,
+                                                 dir,
+                                                 evidence,
+                                                 requiredPermissions,
+                                                 optionalPermissions,
+                                                 refusedPermissions,
+                                                 ref stackMark,
+                                                 assemblyAttributes,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public AssemblyBuilder DefineDynamicAssembly(
+                    AssemblyName name,
+                    AssemblyBuilderAccess access,
+                    String dir,
+                    bool isSynchronized,
+                    IEnumerable<CustomAttributeBuilder> assemblyAttributes)
+        {
+            Contract.Ensures(Contract.Result<AssemblyBuilder>() != null);
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return InternalDefineDynamicAssembly(name,
+                                                 access,
+                                                 dir,
+                                                 null,
+                                                 null,
+                                                 null,
+                                                 null,
+                                                 ref stackMark,
+                                                 assemblyAttributes,
+                                                 SecurityContextSource.CurrentAssembly);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        private AssemblyBuilder InternalDefineDynamicAssembly(
+            AssemblyName name,
+            AssemblyBuilderAccess access,
+            String dir,
+            Evidence evidence,
+            PermissionSet requiredPermissions,
+            PermissionSet optionalPermissions,
+            PermissionSet refusedPermissions,
+            ref StackCrawlMark stackMark,
+            IEnumerable<CustomAttributeBuilder> assemblyAttributes,
+            SecurityContextSource securityContextSource)
+        {
+            return AssemblyBuilder.InternalDefineDynamicAssembly(name,
+                                                                 access,
+                                                                 dir,
+                                                                 evidence,
+                                                                 requiredPermissions,
+                                                                 optionalPermissions,
+                                                                 refusedPermissions,
+                                                                 ref stackMark,
+                                                                 assemblyAttributes,
+                                                                 securityContextSource);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern String nApplyPolicy(AssemblyName an);
+       
+        // Return the assembly name that results from applying policy.
+        [ComVisible(false)]
+        public String ApplyPolicy(String assemblyName)
+        {
+            AssemblyName asmName = new AssemblyName(assemblyName);  
+
+            byte[] pk = asmName.GetPublicKeyToken();
+            if (pk == null)
+                pk = asmName.GetPublicKey();
+
+            // Simply-named assemblies cannot have policy, so for those,
+            // we simply return the passed-in assembly name.
+            if ((pk == null) || (pk.Length == 0))
+                return assemblyName;
+            else
+                return nApplyPolicy(asmName);
+        }
+
+
+        public ObjectHandle CreateInstance(String assemblyName,
+                                           String typeName)
+                                         
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+
+            if (assemblyName == null)
+                throw new ArgumentNullException("assemblyName");
+            Contract.EndContractBlock();
+
+            return Activator.CreateInstance(assemblyName,
+                                            typeName);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal ObjectHandle InternalCreateInstanceWithNoSecurity (string assemblyName, string typeName) {
+            PermissionSet.s_fullTrust.Assert();
+            return CreateInstance(assemblyName, typeName);
+        }
+
+        public ObjectHandle CreateInstanceFrom(String assemblyFile,
+                                               String typeName)
+                                         
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+            Contract.EndContractBlock();
+
+            return Activator.CreateInstanceFrom(assemblyFile,
+                                                typeName);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal ObjectHandle InternalCreateInstanceFromWithNoSecurity (string assemblyName, string typeName) {
+            PermissionSet.s_fullTrust.Assert();
+            return CreateInstanceFrom(assemblyName, typeName);
+        }
+
+#if FEATURE_COMINTEROP
+        // The first parameter should be named assemblyFile, but it was incorrectly named in a previous 
+        //  release, and the compatibility police won't let us change the name now.
+        public ObjectHandle CreateComInstanceFrom(String assemblyName,
+                                                  String typeName)
+                                         
+        {
+            if (this == null)
+                throw new NullReferenceException();
+            Contract.EndContractBlock();
+
+            return Activator.CreateComInstanceFrom(assemblyName,
+                                                   typeName);
+        }
+
+        public ObjectHandle CreateComInstanceFrom(String assemblyFile,
+                                                  String typeName,
+                                                  byte[] hashValue, 
+                                                  AssemblyHashAlgorithm hashAlgorithm)
+                                         
+        {
+            if (this == null)
+                throw new NullReferenceException();
+            Contract.EndContractBlock();
+
+            return Activator.CreateComInstanceFrom(assemblyFile,
+                                                   typeName,
+                                                   hashValue, 
+                                                   hashAlgorithm);
+        }
+
+#endif // FEATURE_COMINTEROP
+
+        public ObjectHandle CreateInstance(String assemblyName,
+                                           String typeName,
+                                           Object[] activationAttributes)
+                                         
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+
+            if (assemblyName == null)
+                throw new ArgumentNullException("assemblyName");
+            Contract.EndContractBlock();
+
+            return Activator.CreateInstance(assemblyName,
+                                            typeName,
+                                            activationAttributes);
+        }
+                                  
+        public ObjectHandle CreateInstanceFrom(String assemblyFile,
+                                               String typeName,
+                                               Object[] activationAttributes)
+                                               
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+            Contract.EndContractBlock();
+
+            return Activator.CreateInstanceFrom(assemblyFile,
+                                                typeName,
+                                                activationAttributes);
+        }
+                                         
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstance which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public ObjectHandle CreateInstance(String assemblyName, 
+                                           String typeName, 
+                                           bool ignoreCase,
+                                           BindingFlags bindingAttr, 
+                                           Binder binder,
+                                           Object[] args,
+                                           CultureInfo culture,
+                                           Object[] activationAttributes,
+                                           Evidence securityAttributes)
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+            
+            if (assemblyName == null)
+                throw new ArgumentNullException("assemblyName");
+            Contract.EndContractBlock();
+
+#if FEATURE_CAS_POLICY
+            if (securityAttributes != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));   
+            }
+#endif // FEATURE_CAS_POLICY
+
+#pragma warning disable 618
+            return Activator.CreateInstance(assemblyName,
+                                            typeName,
+                                            ignoreCase,
+                                            bindingAttr,
+                                            binder,
+                                            args,
+                                            culture,
+                                            activationAttributes,
+                                            securityAttributes);
+#pragma warning restore 618
+        }
+
+        public ObjectHandle CreateInstance(string assemblyName,
+                                           string typeName,
+                                           bool ignoreCase,
+                                           BindingFlags bindingAttr,
+                                           Binder binder,
+                                           object[] args,
+                                           CultureInfo culture,
+                                           object[] activationAttributes)
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+
+            if (assemblyName == null)
+                throw new ArgumentNullException("assemblyName");
+            Contract.EndContractBlock();
+
+            return Activator.CreateInstance(assemblyName,
+                                            typeName,
+                                            ignoreCase,
+                                            bindingAttr,
+                                            binder,
+                                            args,
+                                            culture,
+                                            activationAttributes);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal ObjectHandle InternalCreateInstanceWithNoSecurity (string assemblyName, 
+                                                                    string typeName,
+                                                                    bool ignoreCase,
+                                                                    BindingFlags bindingAttr,
+                                                                    Binder binder,
+                                                                    Object[] args,
+                                                                    CultureInfo culture,
+                                                                    Object[] activationAttributes,
+                                                                    Evidence securityAttributes)
+        {
+#if FEATURE_CAS_POLICY
+            Contract.Assert(IsLegacyCasPolicyEnabled || securityAttributes == null);
+#endif // FEATURE_CAS_POLICY
+
+            PermissionSet.s_fullTrust.Assert();
+#pragma warning disable 618
+            return CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
+#pragma warning restore 618
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFrom which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public ObjectHandle CreateInstanceFrom(String assemblyFile,
+                                               String typeName, 
+                                               bool ignoreCase,
+                                               BindingFlags bindingAttr, 
+                                               Binder binder,
+                                               Object[] args,
+                                               CultureInfo culture,
+                                               Object[] activationAttributes,
+                                               Evidence securityAttributes)
+
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+            Contract.EndContractBlock();
+
+#if FEATURE_CAS_POLICY
+            if (securityAttributes != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            return Activator.CreateInstanceFrom(assemblyFile,
+                                                typeName,
+                                                ignoreCase,
+                                                bindingAttr,
+                                                binder,
+                                                args,
+                                                culture,
+                                                activationAttributes,
+                                                securityAttributes);
+        }
+
+        public ObjectHandle CreateInstanceFrom(string assemblyFile,
+                                               string typeName,
+                                               bool ignoreCase,
+                                               BindingFlags bindingAttr,
+                                               Binder binder,
+                                               object[] args,
+                                               CultureInfo culture,
+                                               object[] activationAttributes)
+        {
+            // jit does not check for that, so we should do it ...
+            if (this == null)
+                throw new NullReferenceException();
+            Contract.EndContractBlock();
+
+            return Activator.CreateInstanceFrom(assemblyFile,
+                                                typeName,
+                                                ignoreCase,
+                                                bindingAttr,
+                                                binder,
+                                                args,
+                                                culture,
+                                                activationAttributes);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal ObjectHandle InternalCreateInstanceFromWithNoSecurity (string assemblyName, 
+                                                                        string typeName,
+                                                                        bool ignoreCase,
+                                                                        BindingFlags bindingAttr,
+                                                                        Binder binder,
+                                                                        Object[] args,
+                                                                        CultureInfo culture,
+                                                                        Object[] activationAttributes,
+                                                                        Evidence securityAttributes)
+        {
+#if FEATURE_CAS_POLICY
+            Contract.Assert(IsLegacyCasPolicyEnabled || securityAttributes == null);
+#endif // FEATURE_CAS_POLICY
+
+            PermissionSet.s_fullTrust.Assert();
+#pragma warning disable 618
+            return CreateInstanceFrom(assemblyName, typeName, ignoreCase, bindingAttr, binder, args, culture, activationAttributes, securityAttributes);
+#pragma warning restore 618
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public Assembly Load(AssemblyName assemblyRef)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, null, null, ref stackMark, true /*thrownOnFileNotFound*/, false, false);
+        }
+        
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public Assembly Load(String assemblyString)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.InternalLoad(assemblyString, null, ref stackMark, false);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public Assembly Load(byte[] rawAssembly)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.nLoadImage(rawAssembly,
+                                       null, // symbol store
+                                       null, // evidence
+                                       ref stackMark,
+                                       false,
+                                       SecurityContextSource.CurrentAssembly);
+
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        public Assembly Load(byte[] rawAssembly,
+                             byte[] rawSymbolStore)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.nLoadImage(rawAssembly,
+                                       rawSymbolStore,
+                                       null, // evidence
+                                       ref stackMark,
+                                       false, // fIntrospection
+                                       SecurityContextSource.CurrentAssembly);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+#pragma warning disable 618
+        [SecurityPermissionAttribute(SecurityAction.Demand, ControlEvidence = true)]
+#pragma warning restore 618
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkId=155570 for more information.")]
+        public Assembly Load(byte[] rawAssembly,
+                             byte[] rawSymbolStore,
+                             Evidence securityEvidence)
+        {
+#if FEATURE_CAS_POLICY
+            if (securityEvidence != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.nLoadImage(rawAssembly,
+                                       rawSymbolStore,
+                                       securityEvidence,
+                                       ref stackMark,
+                                       false, // fIntrospection
+                                       SecurityContextSource.CurrentAssembly);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public Assembly Load(AssemblyName assemblyRef,
+                             Evidence assemblySecurity)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.InternalLoadAssemblyName(assemblyRef, assemblySecurity, null, ref stackMark, true /*thrownOnFileNotFound*/, false, false);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of Load which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public Assembly Load(String assemblyString,
+                             Evidence assemblySecurity)
+        {
+            StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
+            return RuntimeAssembly.InternalLoad(assemblyString, assemblySecurity, ref stackMark, false);
+        }
+
+        public int ExecuteAssembly(String assemblyFile)
+        {
+            return ExecuteAssembly(assemblyFile, (string[])null);
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public int ExecuteAssembly(String assemblyFile,
+                                   Evidence assemblySecurity)
+        {
+            return ExecuteAssembly(assemblyFile, assemblySecurity, null);
+        }
+    
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public int ExecuteAssembly(String assemblyFile,
+                                   Evidence assemblySecurity,
+                                   String[] args)
+        {
+#if FEATURE_CAS_POLICY
+            if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile, assemblySecurity);
+    
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        public int ExecuteAssembly(string assemblyFile, string[] args)
+        {
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile);
+
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssembly which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public int ExecuteAssembly(String assemblyFile,
+                                   Evidence assemblySecurity,
+                                   String[] args,
+                                   byte[] hashValue, 
+                                   AssemblyHashAlgorithm hashAlgorithm)
+        {
+#if FEATURE_CAS_POLICY
+            if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile, 
+                                                                          assemblySecurity,
+                                                                          hashValue,
+                                                                          hashAlgorithm);
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        public int ExecuteAssembly(string assemblyFile,
+                                   string[] args,
+                                   byte[] hashValue,
+                                   AssemblyHashAlgorithm hashAlgorithm)
+        {
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.LoadFrom(assemblyFile,
+                                                                          hashValue,
+                                                                          hashAlgorithm);
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        #if FEATURE_CORECLR
+        [System.Security.SecurityCritical] // auto-generated
+        #endif
+        public int ExecuteAssemblyByName(String assemblyName)
+        {
+            return ExecuteAssemblyByName(assemblyName, (string[])null);
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssemblyByName which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public int ExecuteAssemblyByName(String assemblyName,
+                                         Evidence assemblySecurity)
+        {
+#pragma warning disable 618
+            return ExecuteAssemblyByName(assemblyName, assemblySecurity, null);
+#pragma warning restore 618
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssemblyByName which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public int ExecuteAssemblyByName(String assemblyName,
+                                         Evidence assemblySecurity,
+                                         params String[] args)
+        {
+#if FEATURE_CAS_POLICY
+            if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName, assemblySecurity);
+    
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        public int ExecuteAssemblyByName(string assemblyName, params string[] args)
+        {
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName);
+
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of ExecuteAssemblyByName which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public int ExecuteAssemblyByName(AssemblyName assemblyName,
+                                         Evidence assemblySecurity,
+                                         params String[] args)
+        {
+#if FEATURE_CAS_POLICY
+            if (assemblySecurity != null && !IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+            }
+#endif // FEATURE_CAS_POLICY
+
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName, assemblySecurity);
+    
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        public int ExecuteAssemblyByName(AssemblyName assemblyName, params string[] args)
+        {
+            RuntimeAssembly assembly = (RuntimeAssembly)Assembly.Load(assemblyName);
+
+            if (args == null)
+                args = new String[0];
+
+            return nExecuteAssembly(assembly, args);
+        }
+
+        public static AppDomain CurrentDomain
+        {
+            get {
+                Contract.Ensures(Contract.Result<AppDomain>() != null);
+                return Thread.GetDomain();
+            }
+        }
+
+#if FEATURE_CAS_POLICY
+        public Evidence Evidence
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated
+            [SecurityPermissionAttribute(SecurityAction.Demand, ControlEvidence = true)]
+            get {
+                return EvidenceNoDemand;
+            }
+        }
+
+        internal Evidence EvidenceNoDemand {
+            [SecurityCritical]
+            get {
+                if (_SecurityIdentity == null) {
+                    if (!IsDefaultAppDomain() && nIsDefaultAppDomainForEvidence()) {
+#if !FEATURE_CORECLR                         
+                        //
+                        // V1.x compatibility: If this is an AppDomain created 
+                        // by the default appdomain without an explicit evidence
+                        // then reuse the evidence of the default AppDomain.
+                        //
+                        return GetDefaultDomain().Evidence;
+#else
+                       Contract.Assert(false,"This code should not be called for core CLR");
+                        
+                        // This operation is not allowed
+                        throw new InvalidOperationException();
+#endif
+                    }
+                    else {
+                        // We can't cache this value, since the VM needs to differentiate between AppDomains
+                        // which have no user supplied evidence and those which do and it uses the presence
+                        // of Evidence on the domain to make that switch.
+                        return new Evidence(new AppDomainEvidenceFactory(this));
+                    }
+                }
+                else {
+                    return _SecurityIdentity.Clone();
+                }
+            }
+        }
+
+        internal Evidence InternalEvidence
+        {
+            get {
+                    return _SecurityIdentity;
+            }
+        }
+
+        internal EvidenceBase GetHostEvidence(Type type)
+        {
+            if (_SecurityIdentity != null)
+            {
+                return _SecurityIdentity.GetHostEvidence(type);
+            }
+            else
+            {
+                return new Evidence(new AppDomainEvidenceFactory(this)).GetHostEvidence(type);
+            }
+        }
+#endif // FEATURE_CAS_POLICY
+
+        public String FriendlyName
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated
+            get { return nGetFriendlyName(); }
+        } 
+
+        public String BaseDirectory
+        {
+#if FEATURE_CORECLR
+            [System.Security.SecurityCritical]
+#endif        
+            get {
+                return FusionStore.ApplicationBase;
+            }
+        }
+
+#if FEATURE_FUSION
+        public String RelativeSearchPath
+        {
+            get { return FusionStore.PrivateBinPath; }
+        }
+
+        public bool ShadowCopyFiles
+        {
+            get {
+                String s = FusionStore.ShadowCopyFiles;
+                if((s != null) && 
+                   (String.Compare(s, "true", StringComparison.OrdinalIgnoreCase) == 0))
+                    return true;
+                else
+                    return false;
+            }
+        }
+#endif
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public override String ToString()
+        {
+            StringBuilder sb = StringBuilderCache.Acquire();
+            
+            String fn = nGetFriendlyName();
+            if (fn != null) {
+                sb.Append(Environment.GetResourceString("Loader_Name") + fn);
+                sb.Append(Environment.NewLine);
+            }
+    
+            if(_Policies == null || _Policies.Length == 0) 
+                sb.Append(Environment.GetResourceString("Loader_NoContextPolicies")
+                          + Environment.NewLine);
+            else {
+                sb.Append(Environment.GetResourceString("Loader_ContextPolicies")
+                          + Environment.NewLine);
+                for(int i = 0;i < _Policies.Length; i++) {
+                    sb.Append(_Policies[i]);
+                    sb.Append(Environment.NewLine);
+                }
+            }
+    
+            return StringBuilderCache.GetStringAndRelease(sb);
+        }
+        
+        public Assembly[] GetAssemblies()
+        {
+            return nGetAssemblies(false /* forIntrospection */);
+        }
+
+
+        public Assembly[] ReflectionOnlyGetAssemblies()
+        {
+            return nGetAssemblies(true /* forIntrospection */);
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern Assembly[] nGetAssemblies(bool forIntrospection);
+
+        // this is true when we've removed the handles etc so really can't do anything
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern bool IsUnloadingForcedFinalize();
+
+    // this is true when we've just started going through the finalizers and are forcing objects to finalize
+    // so must be aware that certain infrastructure may have gone away
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        public extern bool IsFinalizingForUnload();
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal static extern void PublishAnonymouslyHostedDynamicMethodsAssembly(RuntimeAssembly assemblyHandle);
+
+#if  FEATURE_FUSION
+        // Appends the following string to the private path. Valid paths
+        // are of the form "bin;util/i386" etc.
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.AppendPrivatePath has been deprecated. Please investigate the use of AppDomainSetup.PrivateBinPath instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void AppendPrivatePath(String path)
+        {
+            if(path == null || path.Length == 0)
+                return;
+
+            String current = FusionStore.Value[(int) AppDomainSetup.LoaderInformation.PrivateBinPathValue];
+            StringBuilder appendPath = StringBuilderCache.Acquire();
+
+            if(current != null && current.Length > 0) {
+                // See if the last character is a separator
+                appendPath.Append(current);
+                if((current[current.Length-1] != Path.PathSeparator) &&
+                   (path[0] != Path.PathSeparator))
+                    appendPath.Append(Path.PathSeparator);
+            }
+            appendPath.Append(path);
+
+            String result = StringBuilderCache.GetStringAndRelease(appendPath);
+            InternalSetPrivateBinPath(result);
+        }
+
+        
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.ClearPrivatePath has been deprecated. Please investigate the use of AppDomainSetup.PrivateBinPath instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void ClearPrivatePath()
+        {
+            InternalSetPrivateBinPath(String.Empty);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.ClearShadowCopyPath has been deprecated. Please investigate the use of AppDomainSetup.ShadowCopyDirectories instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void ClearShadowCopyPath()
+        {
+            InternalSetShadowCopyPath(String.Empty);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.SetCachePath has been deprecated. Please investigate the use of AppDomainSetup.CachePath instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void SetCachePath(String path)
+        {
+            InternalSetCachePath(path);
+        }
+#endif // FEATURE_FUSION
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public void SetData (string name, object data) {
+#if FEATURE_CORECLR        
+            if (!name.Equals("LOCATION_URI"))
+            {
+                // Only LOCATION_URI can be set using AppDomain.SetData
+                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyLocationURI", name));
+            }
+#endif // FEATURE_CORECLR            
+            SetDataHelper(name, data, null);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public void SetData (string name, object data, IPermission permission) {
+#if FEATURE_CORECLR        
+            if (!name.Equals("LOCATION_URI"))
+            {
+                // Only LOCATION_URI can be set using AppDomain.SetData
+                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyLocationURI", name));
+            }
+#endif // FEATURE_CORECLR                    
+            SetDataHelper(name, data, permission);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetDataHelper (string name, object data, IPermission permission) {
+            if (name == null)
+                throw new ArgumentNullException("name");
+            Contract.EndContractBlock();
+
+            //
+            // Synopsis:
+            //   IgnoreSystemPolicy is provided as a legacy flag to allow callers to
+            //   skip enterprise, machine and user policy levels. When this flag is set,
+            //   any demands triggered in this AppDomain will be evaluated against the
+            //   AppDomain CAS policy level that is set on the AppDomain.
+            // Security Requirements:
+            //   The caller needs to be fully trusted in order to be able to set
+            //   this legacy mode.
+            // Remarks:
+            //   There needs to be an AppDomain policy level set before this compat
+            //   switch can be set on the AppDomain.
+            //
+#if FEATURE_FUSION
+            if (name.Equals(TargetFrameworkNameAppCompatSetting)) {
+                _FusionStore.TargetFrameworkName = (String) data;
+                return;
+            }
+#if FEATURE_CAS_POLICY
+            if (name.Equals("IgnoreSystemPolicy")) {
+                lock (this) {
+                    if (!_HasSetPolicy)
+                        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData"));
+                }
+                new PermissionSet(PermissionState.Unrestricted).Demand();
+            }
+#endif
+            int key = AppDomainSetup.Locate(name);
+
+            if(key == -1) {
+                lock (((ICollection)LocalStore).SyncRoot) {
+                    LocalStore[name] = new object[] {data, permission};
+                }
+            }
+            else {
+                if (permission != null)
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData"));
+                // Be sure to call these properties, not Value, since
+                // these do more than call Value.
+                switch(key) {
+                case (int) AppDomainSetup.LoaderInformation.DynamicBaseValue:
+                    FusionStore.DynamicBase = (string) data;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.DevPathValue:
+                    FusionStore.DeveloperPath = (string) data;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.ShadowCopyDirectoriesValue:
+                    FusionStore.ShadowCopyDirectories = (string) data;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.DisallowPublisherPolicyValue:
+                    if(data != null)
+                        FusionStore.DisallowPublisherPolicy = true;
+                    else
+                        FusionStore.DisallowPublisherPolicy = false;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.DisallowCodeDownloadValue:
+                    if (data != null)
+                         FusionStore.DisallowCodeDownload = true;
+                    else
+                        FusionStore.DisallowCodeDownload = false;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.DisallowBindingRedirectsValue:
+                    if(data != null)
+                        FusionStore.DisallowBindingRedirects = true;
+                    else
+                        FusionStore.DisallowBindingRedirects = false;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.DisallowAppBaseProbingValue:
+                    if(data != null)
+                        FusionStore.DisallowApplicationBaseProbing = true;
+                    else
+                        FusionStore.DisallowApplicationBaseProbing = false;
+                    break;
+                case (int) AppDomainSetup.LoaderInformation.ConfigurationBytesValue:
+                    FusionStore.SetConfigurationBytes((byte[]) data);
+                    break;
+                default:
+                    FusionStore.Value[key] = (string) data;
+                    break;
+                }
+            }
+#else // FEATURE_FUSION
+#if FEATURE_CORECLR
+            // SetData should only be used to set values that don't already exist.
+            {
+                object[] currentVal;
+                lock (((ICollection)LocalStore).SyncRoot) {
+                    LocalStore.TryGetValue(name, out currentVal);
+                }
+                if (currentVal != null && currentVal[0] != null)
+                {
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SetData_OnlyOnce"));
+                }
+            }
+
+#endif // FEATURE_CORECLR
+            lock (((ICollection)LocalStore).SyncRoot) {
+                LocalStore[name] = new object[] {data, permission};
+            }
+#endif // FEATURE_FUSION
+        }
+
+        [Pure]
+        #if FEATURE_CORECLR
+        [System.Security.SecurityCritical] // auto-generated
+        #else
+        [System.Security.SecuritySafeCritical]
+        #endif
+        public Object GetData(string name)
+        {
+            if(name == null)
+                throw new ArgumentNullException("name");
+            Contract.EndContractBlock();
+
+            int key = AppDomainSetup.Locate(name);
+            if(key == -1) 
+            {
+#if FEATURE_LOADER_OPTIMIZATION
+                if(name.Equals(AppDomainSetup.LoaderOptimizationKey))
+                    return FusionStore.LoaderOptimization;
+                else 
+#endif // FEATURE_LOADER_OPTIMIZATION                    
+                {
+                    object[] data;
+                    lock (((ICollection)LocalStore).SyncRoot) {
+                        LocalStore.TryGetValue(name, out data);
+                    }
+                    if (data == null)
+                        return null;
+                    if (data[1] != null) {
+                        IPermission permission = (IPermission) data[1];
+                        permission.Demand();
+                    }
+                    return data[0];
+                }
+            }
+           else {
+                // Be sure to call these properties, not Value, so
+                // that the appropriate permission demand will be done
+                switch(key) {
+                case (int) AppDomainSetup.LoaderInformation.ApplicationBaseValue:
+                    return FusionStore.ApplicationBase;
+                case (int) AppDomainSetup.LoaderInformation.ApplicationNameValue:
+                    return FusionStore.ApplicationName;
+#if FEATURE_FUSION
+                case (int) AppDomainSetup.LoaderInformation.ConfigurationFileValue:
+                    return FusionStore.ConfigurationFile;
+                case (int) AppDomainSetup.LoaderInformation.DynamicBaseValue:
+                    return FusionStore.DynamicBase;
+                case (int) AppDomainSetup.LoaderInformation.DevPathValue:
+                    return FusionStore.DeveloperPath;
+                case (int) AppDomainSetup.LoaderInformation.PrivateBinPathValue:
+                    return FusionStore.PrivateBinPath;
+                case (int) AppDomainSetup.LoaderInformation.PrivateBinPathProbeValue:
+                    return FusionStore.PrivateBinPathProbe;
+                case (int) AppDomainSetup.LoaderInformation.ShadowCopyDirectoriesValue:
+                    return FusionStore.ShadowCopyDirectories;
+                case (int) AppDomainSetup.LoaderInformation.ShadowCopyFilesValue:
+                    return FusionStore.ShadowCopyFiles;
+                case (int) AppDomainSetup.LoaderInformation.CachePathValue:
+                    return FusionStore.CachePath;
+                case (int) AppDomainSetup.LoaderInformation.LicenseFileValue:
+                    return FusionStore.LicenseFile;
+                case (int) AppDomainSetup.LoaderInformation.DisallowPublisherPolicyValue:
+                    return FusionStore.DisallowPublisherPolicy;
+                case (int) AppDomainSetup.LoaderInformation.DisallowCodeDownloadValue:
+                    return FusionStore.DisallowCodeDownload;
+                case (int) AppDomainSetup.LoaderInformation.DisallowBindingRedirectsValue:
+                    return FusionStore.DisallowBindingRedirects;
+                case (int) AppDomainSetup.LoaderInformation.DisallowAppBaseProbingValue:
+                    return FusionStore.DisallowApplicationBaseProbing;
+                case (int) AppDomainSetup.LoaderInformation.ConfigurationBytesValue:
+                    return FusionStore.GetConfigurationBytes();
+#endif //FEATURE_FUSION
+                    
+                default:
+                    Contract.Assert(false, "Need to handle new LoaderInformation value in AppDomain.GetData()");
+                    return null;
+                }
+            }
+                   
+        }
+
+        // The compat flags are set at domain creation time to indicate that the given breaking
+        // change should not be used in this domain.
+        //
+        // After the domain has been created, this Nullable boolean returned by this method should
+        // always have a value.  Code in the runtime uses this to know if it is safe to cache values
+        // that might change if the compatibility switches have not been set yet.    
+        public Nullable<bool> IsCompatibilitySwitchSet(String value)
+        {
+            Nullable<bool> fReturn;
+
+            if (_compatFlagsInitialized == false) 
+            {
+                fReturn = new Nullable<bool>();
+            } 
+            else
+            {
+                fReturn  = new Nullable<bool>(_compatFlags != null && _compatFlags.ContainsKey(value));
+            }
+
+            return fReturn;
+        }
+        
+        [Obsolete("AppDomain.GetCurrentThreadId has been deprecated because it does not provide a stable Id when managed threads are running on fibers (aka lightweight threads). To get a stable identifier for a managed thread, use the ManagedThreadId property on Thread.  http://go.microsoft.com/fwlink/?linkid=14202", false)]
+        [DllImport(Microsoft.Win32.Win32Native.KERNEL32)]
+        public static extern int GetCurrentThreadId();
+
+#if FEATURE_REMOTING
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [SecurityPermissionAttribute( SecurityAction.Demand, ControlAppDomain = true ),
+         ReliabilityContract(Consistency.MayCorruptAppDomain, Cer.MayFail)]            
+        public static void Unload(AppDomain domain)
+        {
+            if (domain == null)
+                throw new ArgumentNullException("domain");
+            Contract.EndContractBlock();
+
+            try {
+                Int32 domainID = AppDomain.GetIdForUnload(domain);
+                if (domainID==0)
+                    throw new CannotUnloadAppDomainException();
+                AppDomain.nUnload(domainID);
+            }
+            catch(Exception e) {
+                throw e;    // throw it again to reset stack trace
+            }
+        }
+#endif
+
+        // Explicitly set policy for a domain (providing policy hasn't been set
+        // previously). Making this call will guarantee that previously loaded
+        // assemblies will be granted permissions based on the default machine
+        // policy that was in place prior to this call.
+#if FEATURE_CAS_POLICY        
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain policy levels are obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public void SetAppDomainPolicy(PolicyLevel domainPolicy)
+        {
+            if (domainPolicy == null)
+                throw new ArgumentNullException("domainPolicy");
+            Contract.EndContractBlock();
+
+            if (!IsLegacyCasPolicyEnabled)
+            {
+                throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyExplicit"));
+            }
+
+            // Check that policy has not been set previously.
+            lock (this) {
+                if (_HasSetPolicy)
+                    throw new PolicyException(Environment.GetResourceString("Policy_PolicyAlreadySet"));
+                _HasSetPolicy = true;
+
+                // Make sure that the loader allows us to change security policy
+                // at this time (this will throw if not.)
+                nChangeSecurityPolicy();
+            }
+
+            // Add the new policy level.
+            SecurityManager.PolicyManager.AddLevel(domainPolicy);
+        }
+#endif //#if !FEATURE_CAS_POLICY
+#if FEATURE_CLICKONCE
+        public ActivationContext ActivationContext {
+            [System.Security.SecurityCritical]  // auto-generated_required
+            get {
+                return _activationContext;
+            }
+        }
+
+        public ApplicationIdentity ApplicationIdentity {
+            [System.Security.SecurityCritical]  // auto-generated_required
+            get {
+                return _applicationIdentity;
+            }
+        }
+#endif // FEATURE_CLICKONCE
+
+
+#if FEATURE_CLICKONCE
+        public ApplicationTrust ApplicationTrust {
+            [System.Security.SecurityCritical]  // auto-generated_required
+#else // FEATURE_CLICKONCE
+        internal ApplicationTrust ApplicationTrust {
+#endif // FEATURE_CLICKONCE
+            get {
+                if (_applicationTrust == null && _IsFastFullTrustDomain) {
+                    _applicationTrust = new ApplicationTrust(new PermissionSet(PermissionState.Unrestricted));
+                }
+
+                return _applicationTrust;
+            }
+        }
+
+#if FEATURE_IMPERSONATION
+        // Set the default principal object to be attached to threads if they
+        // attempt to bind to a principal while executing in this appdomain. The
+        // default can only be set once.
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlPrincipal)]
+        public void SetThreadPrincipal(IPrincipal principal)
+        {
+            if (principal == null)
+                throw new ArgumentNullException("principal");
+            Contract.EndContractBlock();
+
+            lock (this) {
+                // Check that principal has not been set previously.
+                if (_DefaultPrincipal != null)
+                    throw new PolicyException(Environment.GetResourceString("Policy_PrincipalTwice"));
+
+                _DefaultPrincipal = principal;
+            }
+        }
+#endif // FEATURE_IMPERSONATION
+
+#if FEATURE_CAS_POLICY
+        // Similar to the above, but sets the class of principal to be created
+        // instead.
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [SecurityPermissionAttribute(SecurityAction.Demand, Flags=SecurityPermissionFlag.ControlPrincipal)]
+        public void SetPrincipalPolicy(PrincipalPolicy policy)
+        {
+            _PrincipalPolicy = policy;
+        }
+#endif
+
+
+#if FEATURE_REMOTING        
+        // This method gives AppDomain an infinite life time by preventing a lease from being
+        // created
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public override Object InitializeLifetimeService()
+        {
+            return null;
+        }
+        // This is useful for requesting execution of some code
+        // in another appDomain ... the delegate may be defined 
+        // on a marshal-by-value object or a marshal-by-ref or 
+        // contextBound object.
+        public void DoCallBack(CrossAppDomainDelegate callBackDelegate)
+        {
+            if (callBackDelegate == null)
+                throw new ArgumentNullException("callBackDelegate");
+            Contract.EndContractBlock();
+
+            callBackDelegate();        
+        }
+#endif
+
+
+        public String DynamicDirectory
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated
+            get {
+                String dyndir = GetDynamicDir();
+                if (dyndir != null)
+                    new FileIOPermission( FileIOPermissionAccess.PathDiscovery, dyndir ).Demand();
+
+                return dyndir;
+            }
+        }
+
+#if FEATURE_CAS_POLICY
+        public static AppDomain CreateDomain(String friendlyName,
+                                             Evidence securityInfo) // Optional
+        {
+            return CreateDomain(friendlyName,
+                                securityInfo,
+                                null);
+        }
+    
+        public static AppDomain CreateDomain(String friendlyName,
+                                             Evidence securityInfo, // Optional
+                                             String appBasePath,
+                                             String appRelativeSearchPath,
+                                             bool shadowCopyFiles)
+        {            
+            AppDomainSetup info = new AppDomainSetup();
+            info.ApplicationBase = appBasePath;
+            info.PrivateBinPath = appRelativeSearchPath;
+            if(shadowCopyFiles)
+                info.ShadowCopyFiles = "true";
+
+            return CreateDomain(friendlyName,
+                                securityInfo,
+                                info);
+        }
+#endif // #if FEATURE_CAS_POLICY    (not exposed in core)
+
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        extern private String GetDynamicDir();
+
+        // Private helpers called from unmanaged code.
+
+#if FEATURE_REMOTING        
+
+        public static AppDomain CreateDomain(String friendlyName)
+        {
+            return CreateDomain(friendlyName, null, null);
+        }
+
+
+        // Marshal a single object into a serialized blob.
+        [System.Security.SecurityCritical]  // auto-generated
+        private static byte[] MarshalObject(Object o)
+        {
+            CodeAccessPermission.Assert(true);
+
+            return Serialize(o);
+        }
+
+        // Marshal two objects into serialized blobs.
+        [System.Security.SecurityCritical]  // auto-generated
+        private static byte[] MarshalObjects(Object o1, Object o2, out byte[] blob2)
+        {
+            CodeAccessPermission.Assert(true);
+
+            byte[] blob1 = Serialize(o1);
+            blob2 = Serialize(o2);
+            return blob1;
+        }
+
+        // Unmarshal a single object from a serialized blob.
+        [System.Security.SecurityCritical]  // auto-generated
+        private static Object UnmarshalObject(byte[] blob)
+        {
+            CodeAccessPermission.Assert(true);
+
+            return Deserialize(blob);
+        }
+
+        // Unmarshal two objects from serialized blobs.
+        [System.Security.SecurityCritical]  // auto-generated
+        private static Object UnmarshalObjects(byte[] blob1, byte[] blob2, out Object o2)
+        {
+            CodeAccessPermission.Assert(true);
+
+            Object o1 = Deserialize(blob1);
+            o2 = Deserialize(blob2);
+            return o1;
+        }
+
+        // Helper routines.
+        [System.Security.SecurityCritical]  // auto-generated
+        private static byte[] Serialize(Object o)
+        {
+            if (o == null)
+            {
+                return null;
+            }
+            else if (o is ISecurityEncodable)
+            {
+                SecurityElement element = ((ISecurityEncodable)o).ToXml();
+                MemoryStream ms = new MemoryStream( 4096 );
+                ms.WriteByte( 0 );
+                StreamWriter writer = new StreamWriter( ms, Encoding.UTF8 );
+                element.ToWriter( writer );
+                writer.Flush();
+                return ms.ToArray();
+            }
+            else
+            {
+                MemoryStream ms = new MemoryStream();
+                ms.WriteByte( 1 );
+                CrossAppDomainSerializer.SerializeObject(o, ms);
+                return ms.ToArray();
+            }
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private static Object Deserialize(byte[] blob)
+        {
+            if (blob == null)
+                return null;
+
+            if (blob[0] == 0)
+            {
+                Parser parser = new Parser( blob, Tokenizer.ByteTokenEncoding.UTF8Tokens, 1 );
+                SecurityElement root = parser.GetTopElement();
+                if (root.Tag.Equals( "IPermission" ) || root.Tag.Equals( "Permission" ))
+                {
+                    IPermission ip = System.Security.Util.XMLUtil.CreatePermission( root, PermissionState.None, false );
+
+                    if (ip == null)
+                    {
+                        return null;
+                    }
+
+                    ip.FromXml( root );
+
+                    return ip;
+                }
+                else if (root.Tag.Equals( "PermissionSet" ))
+                {
+                    PermissionSet permissionSet = new PermissionSet();
+
+                    permissionSet.FromXml( root, false, false );
+
+                    return permissionSet;
+                }
+                else if (root.Tag.Equals( "PermissionToken" ))
+                {
+                    PermissionToken pToken = new PermissionToken();
+
+                    pToken.FromXml( root );
+
+                    return pToken;
+                }
+                else
+                {
+                    return null;
+                }
+
+            }
+            else
+            {
+                Object obj = null;
+                using(MemoryStream stream = new MemoryStream( blob, 1, blob.Length - 1 )) {
+                    obj = CrossAppDomainSerializer.DeserializeObject(stream);
+                }
+
+                Contract.Assert( !(obj is IPermission), "IPermission should be xml deserialized" );
+                Contract.Assert( !(obj is PermissionSet), "PermissionSet should be xml deserialized" );
+
+                return obj;
+            }
+        }
+
+#endif // FEATURE_REMOTING        
+
+#if !FEATURE_CORECLR
+        //
+        // Called by the VM if ICLRExecutionManager::Pause is called with the PAUSE_APP_DOMAINS flag.
+        // This mimics the behavior of the CoreCLR FAS (fast application switching) model, to ensure
+        // that code that depends on things happening in a particular order will work.
+        //
+        [System.Security.SecurityCritical]
+        internal static void Pause()
+        {
+            AppDomainPauseManager.Instance.Pausing();
+            AppDomainPauseManager.Instance.Paused();
+        }
+
+        //
+        // Called by the VM if ICLRExecutionManager::Resume is called after ICLRExecutionManager::Pause 
+        // was called with the PAUSE_APP_DOMAINS flag.
+        // This mimics the behavior of the CoreCLR FAS (fast application switching) model, to ensure
+        // that code that depends on things happening in a particular order will work.
+        //
+        [System.Security.SecurityCritical]
+        internal static void Resume()
+        {
+            if (AppDomainPauseManager.IsPaused)
+            {
+                AppDomainPauseManager.Instance.Resuming();
+                AppDomainPauseManager.Instance.Resumed();
+            }
+        }
+#endif
+
+        private AppDomain() {
+            throw new NotSupportedException(Environment.GetResourceString(ResId.NotSupported_Constructor));
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern int _nExecuteAssembly(RuntimeAssembly assembly, String[] args);
+        internal int nExecuteAssembly(RuntimeAssembly assembly, String[] args)
+        {
+            return _nExecuteAssembly(assembly, args);
+        }
+
+#if FEATURE_VERSIONING
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern void nCreateContext();
+
+        [System.Security.SecurityCritical]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SuppressUnmanagedCodeSecurity]
+        private static extern void nSetupBindingPaths(String trustedPlatformAssemblies, String platformResourceRoots, String appPath, String appNiPaths, String appLocalWinMD);
+
+        #if FEATURE_CORECLR
+        [System.Security.SecurityCritical] // auto-generated
+        #endif
+        internal void SetupBindingPaths(String trustedPlatformAssemblies, String platformResourceRoots, String appPath, String appNiPaths, String appLocalWinMD)
+        {
+            nSetupBindingPaths(trustedPlatformAssemblies, platformResourceRoots, appPath, appNiPaths, appLocalWinMD);
+        }
+#endif // FEATURE_VERSIONING
+
+#if FEATURE_REMOTING
+        internal void CreateRemotingData()
+        {
+                    lock(this) {
+                        if (_RemotingData == null)
+                            _RemotingData = new DomainSpecificRemotingData();
+                    }
+        }
+        
+        internal DomainSpecificRemotingData RemotingData
+        {
+            get 
+            { 
+                if (_RemotingData == null) 
+                    CreateRemotingData();
+
+                return _RemotingData;
+            }
+        }
+#endif // FEATURE_REMOTING
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern String nGetFriendlyName();
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern bool nIsDefaultAppDomainForEvidence();
+
+        // support reliability for certain event handlers, if the target
+        // methods also participate in this discipline.  If caller passes
+        // an existing MulticastDelegate, then we could use a MDA to indicate
+        // that reliability is not guaranteed.  But if it is a single cast
+        // scenario, we can make it work.
+
+        public event EventHandler ProcessExit
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated_required
+            add
+            {
+                if (value != null)
+                {
+                    RuntimeHelpers.PrepareContractedDelegate(value);
+                    lock(this)
+                        _processExit += value;
+                }
+            }
+            remove
+            {
+                lock(this)
+                    _processExit -= value;
+            }
+        }
+
+
+        public event EventHandler DomainUnload
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated_required
+            add
+            {
+                if (value != null)
+                {
+                    RuntimeHelpers.PrepareContractedDelegate(value);
+                    lock(this)
+                        _domainUnload += value;
+                }
+            }
+#if FEATURE_CORECLR
+            [System.Security.SecuritySafeCritical] 
+#endif
+            remove
+            {
+                lock(this)
+                    _domainUnload -= value;
+            }
+        }
+
+
+        public event UnhandledExceptionEventHandler UnhandledException
+        {
+            [System.Security.SecurityCritical]  // auto-generated_required
+            add
+            {
+                if (value != null)
+                {
+                    RuntimeHelpers.PrepareContractedDelegate(value);
+                    lock(this)
+                        _unhandledException += value;
+                }
+            }
+            [System.Security.SecurityCritical]  // auto-generated_required
+            remove
+            {
+                lock(this)
+                    _unhandledException -= value;
+            }
+        }
+
+#if FEATURE_EXCEPTION_NOTIFICATIONS
+        // This is the event managed code can wireup against to be notified
+        // about first chance exceptions. 
+        //
+        // To register/unregister the callback, the code must be SecurityCritical.
+        public event EventHandler<FirstChanceExceptionEventArgs> FirstChanceException
+        {
+            [System.Security.SecurityCritical]  // auto-generated_required
+            add
+            {
+                if (value != null)
+                {
+                    RuntimeHelpers.PrepareContractedDelegate(value);
+                    lock(this)
+                        _firstChanceException += value;
+                }
+            }
+            [System.Security.SecurityCritical]  // auto-generated_required
+            remove
+            {
+                lock(this)
+                    _firstChanceException -= value;
+            }
+        }
+#endif // FEATURE_EXCEPTION_NOTIFICATIONS
+
+        private void OnAssemblyLoadEvent(RuntimeAssembly LoadedAssembly)
+        {
+            AssemblyLoadEventHandler eventHandler = AssemblyLoad;
+            if (eventHandler != null) {
+                AssemblyLoadEventArgs ea = new AssemblyLoadEventArgs(LoadedAssembly);
+                eventHandler(this, ea);
+            }
+        }
+    
+        // This method is called by the VM.
+        [System.Security.SecurityCritical]
+        private RuntimeAssembly OnResourceResolveEvent(RuntimeAssembly assembly, String resourceName)
+        {
+            ResolveEventHandler eventHandler = _ResourceResolve;
+            if ( eventHandler == null)
+                return null;
+
+            Delegate[] ds = eventHandler.GetInvocationList();
+            int len = ds.Length;
+            for (int i = 0; i < len; i++) {
+                Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(resourceName, assembly));
+                RuntimeAssembly ret = GetRuntimeAssembly(asm);
+                if (ret != null)
+                    return ret;
+            }
+
+            return null;
+        }
+        
+        // This method is called by the VM
+        [System.Security.SecurityCritical]
+        private RuntimeAssembly OnTypeResolveEvent(RuntimeAssembly assembly, String typeName)
+        {
+            ResolveEventHandler eventHandler = _TypeResolve;
+            if (eventHandler == null)
+                return null;
+
+            Delegate[] ds = eventHandler.GetInvocationList();
+            int len = ds.Length;
+            for (int i = 0; i < len; i++) {
+                Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(typeName, assembly));
+                RuntimeAssembly ret = GetRuntimeAssembly(asm);
+                if (ret != null)
+                    return ret;
+            }
+
+            return null;
+        }
+
+        // This method is called by the VM.
+        [System.Security.SecurityCritical]
+        private RuntimeAssembly OnAssemblyResolveEvent(RuntimeAssembly assembly, String assemblyFullName)
+        {
+            ResolveEventHandler eventHandler = _AssemblyResolve;
+
+            if (eventHandler == null)
+            {
+                return null;
+            }
+
+            Delegate[] ds = eventHandler.GetInvocationList();
+            int len = ds.Length;
+            for (int i = 0; i < len; i++) {
+                Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(assemblyFullName, assembly));
+                RuntimeAssembly ret = GetRuntimeAssembly(asm);
+                if (ret != null)
+                    return ret;
+            }
+            
+            return null;
+        }
+
+#if FEATURE_REFLECTION_ONLY_LOAD
+        
+        private RuntimeAssembly OnReflectionOnlyAssemblyResolveEvent(RuntimeAssembly  assembly, String assemblyFullName)
+        {
+            ResolveEventHandler eventHandler = ReflectionOnlyAssemblyResolve;
+            if (eventHandler != null) {
+
+                Delegate[] ds = eventHandler.GetInvocationList();
+                int len = ds.Length;
+                for (int i = 0; i < len; i++) {
+                    Assembly asm = ((ResolveEventHandler)ds[i])(this, new ResolveEventArgs(assemblyFullName, assembly));
+                    RuntimeAssembly ret = GetRuntimeAssembly(asm);
+                    if (ret != null)
+                        return ret;
+                }
+            }
+
+            return null;
+        }
+        
+#if FEATURE_COMINTEROP
+        // Called by VM - code:CLRPrivTypeCacheReflectionOnlyWinRT::RaiseNamespaceResolveEvent
+        private RuntimeAssembly[] OnReflectionOnlyNamespaceResolveEvent(RuntimeAssembly assembly, string namespaceName)
+        {
+            return System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.OnReflectionOnlyNamespaceResolveEvent(this, assembly, namespaceName);
+        }
+#endif // FEATURE_COMINTEROP
+
+#endif // FEATURE_REFLECTION_ONLY_LOAD
+
+#if FEATURE_COMINTEROP
+        // Called by VM - code:CLRPrivTypeCacheWinRT::RaiseDesignerNamespaceResolveEvent
+        private string[] OnDesignerNamespaceResolveEvent(string namespaceName)
+        {
+            return System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMetadata.OnDesignerNamespaceResolveEvent(this, namespaceName);
+        }
+#endif // FEATURE_COMINTEROP
+
+        internal AppDomainSetup FusionStore
+        {
+            get {
+                Contract.Assert(_FusionStore != null, 
+                                "Fusion store has not been correctly setup in this domain");
+                return _FusionStore;
+            }
+        }
+
+        internal static RuntimeAssembly GetRuntimeAssembly(Assembly asm)
+        {
+            if (asm == null)
+                return null;
+
+            RuntimeAssembly rtAssembly = asm as RuntimeAssembly;
+            if (rtAssembly != null)
+                return rtAssembly;
+
+            AssemblyBuilder ab = asm as AssemblyBuilder;
+            if (ab != null)
+                return ab.InternalAssembly;
+
+            return null;
+        }
+
+        private Dictionary<String, Object[]> LocalStore
+        {
+            get { 
+                if (_LocalStore != null)
+                    return _LocalStore;
+                else {
+                    _LocalStore = new Dictionary<String, Object[]>();
+                    return _LocalStore;
+                }
+            }
+        }
+
+#if FEATURE_FUSION
+        private void TurnOnBindingRedirects()
+        {
+            _FusionStore.DisallowBindingRedirects = false;
+        }
+#endif
+
+        // This will throw a CannotUnloadAppDomainException if the appdomain is
+        // in another process.
+#if FEATURE_REMOTING        
+        [System.Security.SecurityCritical]  // auto-generated
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]  
+        internal static Int32 GetIdForUnload(AppDomain domain)
+        {
+            if (RemotingServices.IsTransparentProxy(domain))
+            {
+                return RemotingServices.GetServerDomainIdForProxy(domain);
+            }
+            else
+                return domain.Id;
+        }
+#endif
+
+        // Used to determine if server object context is valid in
+        // x-domain remoting scenarios.
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
+        internal static extern bool IsDomainIdValid(Int32 id);
+        
+#if FEATURE_REMOTING        
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        static internal extern AppDomain GetDefaultDomain();
+#endif
+
+#if FEATURE_IMPERSONATION
+        // Internal routine to retrieve the default principal object. If this is
+        // called before the principal has been explicitly set, it will
+        // automatically allocate a default principal based on the policy set by
+        // SetPrincipalPolicy.
+        internal IPrincipal GetThreadPrincipal()
+        {
+            IPrincipal principal = null;
+            if (_DefaultPrincipal == null) {
+#if FEATURE_CAS_POLICY                    
+                switch (_PrincipalPolicy) {
+                case PrincipalPolicy.NoPrincipal:
+                    principal = null;
+                    break;
+                case PrincipalPolicy.UnauthenticatedPrincipal:
+                    principal = new GenericPrincipal(new GenericIdentity("", ""),
+                                                     new String[] {""});
+                    break;
+                case PrincipalPolicy.WindowsPrincipal:
+                    principal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
+                    break;
+                default:
+                    principal = null;
+                    break;
+                    }
+#else
+                principal = new GenericPrincipal(new GenericIdentity("", ""),
+                                                 new String[] {""});
+
+#endif
+            }
+            else
+                principal = _DefaultPrincipal;
+
+            return principal;
+        }
+#endif // FEATURE_IMPERSONATION
+
+#if FEATURE_REMOTING        
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal void CreateDefaultContext()
+        {
+                lock(this) {
+                    // if it has not been created we ask the Context class to 
+                    // create a new default context for this appdomain.
+                    if (_DefaultContext == null)
+                        _DefaultContext = Context.CreateDefaultContext();
+                }            
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal Context GetDefaultContext()
+        {
+            if (_DefaultContext == null)
+                CreateDefaultContext();
+            return _DefaultContext;
+        }
+
+        // Ensure that evidence provided when creating an AppDomain would not have been used to create a
+        // sandbox in legacy CAS mode.  If it could have been used to create a sandbox, and we're not in CAS
+        // mode, then we throw an exception to prevent acciental creation of unsandboxed domains where a
+        // sandbox would have been expected.
+        [SecuritySafeCritical]
+        internal static void CheckDomainCreationEvidence(AppDomainSetup creationDomainSetup,
+                                                         Evidence creationEvidence)
+        {
+            if (creationEvidence != null && !CurrentDomain.IsLegacyCasPolicyEnabled)
+            {
+                if (creationDomainSetup == null || creationDomainSetup.ApplicationTrust == null)
+                {
+                    // We allow non-null evidence in CAS mode to support the common pattern of passing in
+                    // AppDomain.CurrentDomain.Evidence.  Since the zone evidence must have been changed
+                    // if the user has any expectation of sandboxing the domain under legacy CAS policy,
+                    // we use a zone comparison to check for this pattern.  A strict comparison will not
+                    // work, since MSDN samples for creating a domain show using a modified version of the
+                    // current domain's evidence and we would capturce people who copied and pasted these
+                    // samples without intending to sandbox.
+                    Zone creatorsZone = CurrentDomain.EvidenceNoDemand.GetHostEvidence<Zone>();
+                    SecurityZone creatorsSecurityZone = creatorsZone != null ?
+                        creatorsZone.SecurityZone :
+                        SecurityZone.MyComputer;
+
+                    Zone suppliedZone = creationEvidence.GetHostEvidence<Zone>();
+                    if (suppliedZone != null)
+                    {
+                        if (suppliedZone.SecurityZone != creatorsSecurityZone &&
+                            suppliedZone.SecurityZone != SecurityZone.MyComputer)
+                        {
+                            throw new NotSupportedException(Environment.GetResourceString("NotSupported_RequiresCasPolicyImplicit"));
+                        }
+                    }
+                }
+            }
+        }
+
+#if FEATURE_CAS_POLICY
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [SecurityPermissionAttribute( SecurityAction.Demand, ControlAppDomain = true )]
+        public static AppDomain CreateDomain(String friendlyName,
+                                      Evidence securityInfo,
+                                      AppDomainSetup info)
+        {
+            return InternalCreateDomain(friendlyName, securityInfo, info);
+        }
+#else
+        internal static AppDomain CreateDomain(String friendlyName,
+                                      Evidence securityInfo,
+                                      AppDomainSetup info)
+        {
+            return InternalCreateDomain(friendlyName, securityInfo, info);
+        }
+#endif
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal static AppDomain InternalCreateDomain(String friendlyName,
+                                      Evidence securityInfo,
+                                      AppDomainSetup info)
+        {
+            if (friendlyName == null)
+                throw new ArgumentNullException("friendlyName", Environment.GetResourceString("ArgumentNull_String"));
+
+            Contract.EndContractBlock();
+
+            AppDomain.CheckCreateDomainSupported();
+
+            if (info == null)
+                info = new AppDomainSetup();
+            if (info.TargetFrameworkName == null)
+                info.TargetFrameworkName = AppDomain.CurrentDomain.GetTargetFrameworkName();
+
+            AppDomainManager domainManager = AppDomain.CurrentDomain.DomainManager;
+            if (domainManager != null)
+                return domainManager.CreateDomain(friendlyName, securityInfo, info);
+
+            // No AppDomainManager is set up for this domain
+
+            // If evidence is provided, we check to make sure that is allowed.    
+            if (securityInfo != null)
+            {
+                new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
+
+                // If we're potentially trying to sandbox without using a homogenous domain, we need to reject
+                // the domain creation.
+                CheckDomainCreationEvidence(info, securityInfo);
+            }
+
+            return nCreateDomain(friendlyName,
+                                 info,
+                                 securityInfo,
+                                 securityInfo == null ? AppDomain.CurrentDomain.InternalEvidence : null,
+                                 AppDomain.CurrentDomain.GetSecurityDescriptor());
+        }
+#endif // FEATURE_REMOTING
+
+#if FEATURE_CAS_POLICY   
+
+        public static AppDomain CreateDomain (string friendlyName,
+                                              Evidence securityInfo,
+                                              AppDomainSetup info,
+                                              PermissionSet grantSet,
+                                              params StrongName[] fullTrustAssemblies)
+        {
+            if (info == null)
+                throw new ArgumentNullException("info");
+            if (info.ApplicationBase == null)
+                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_AppDomainSandboxAPINeedsExplicitAppBase"));
+            Contract.EndContractBlock();
+
+            if (fullTrustAssemblies == null)
+            {
+                fullTrustAssemblies = new StrongName[0];
+            }
+
+            info.ApplicationTrust = new ApplicationTrust(grantSet, fullTrustAssemblies);
+            return CreateDomain(friendlyName, securityInfo, info);
+        }
+
+        public static AppDomain CreateDomain(String friendlyName,
+                                             Evidence securityInfo, // Optional
+                                             String appBasePath,
+                                             String appRelativeSearchPath,
+                                             bool shadowCopyFiles,
+                                             AppDomainInitializer adInit, 
+                                             string[] adInitArgs) 
+        {
+            AppDomainSetup info = new AppDomainSetup();
+            info.ApplicationBase = appBasePath;
+            info.PrivateBinPath = appRelativeSearchPath;
+            info.AppDomainInitializer=adInit;
+            info.AppDomainInitializerArguments=adInitArgs;
+            if(shadowCopyFiles)
+                info.ShadowCopyFiles = "true";
+
+            return CreateDomain(friendlyName,
+                                securityInfo,
+                                info);
+        }
+#endif // FEATURE_CAS_POLICY
+
+#if FEATURE_CORECLR
+        [System.Security.SecurityCritical]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SuppressUnmanagedCodeSecurity]
+        private static extern void nSetNativeDllSearchDirectories(string paths);
+#endif
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetupFusionStore(AppDomainSetup info, AppDomainSetup oldInfo)
+        {
+            Contract.Requires(info != null);
+
+#if FEATURE_FUSION
+            if (oldInfo == null) {
+                        
+       // Create the application base and configuration file from the imagelocation
+            // passed in or use the Win32 Image name.
+            if(info.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue] == null ||
+               info.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue] == null ) 
+#else        
+            if (info.ApplicationBase == null)
+#endif                
+
+            {
+#if FEATURE_FUSION
+                AppDomain defaultDomain = GetDefaultDomain();
+                if (this == defaultDomain) {
+                    // The default domain gets its defaults from the main process.
+                    info.SetupDefaults(RuntimeEnvironment.GetModuleFileName(), imageLocationAlreadyNormalized : true);
+                }
+                else {
+                    // Other domains get their defaults from the default domain. This way, a host process
+                    // can use AppDomainManager to set up the defaults for every domain created in the process.
+                    if (info.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue] == null)
+                        info.ConfigurationFile = defaultDomain.FusionStore.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue];
+                    if (info.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue] == null)
+                        info.ApplicationBase = defaultDomain.FusionStore.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue];
+                    if (info.Value[(int) AppDomainSetup.LoaderInformation.ApplicationNameValue] == null)
+                        info.ApplicationName = defaultDomain.FusionStore.Value[(int) AppDomainSetup.LoaderInformation.ApplicationNameValue];
+                }
+#else
+                info.SetupDefaults(RuntimeEnvironment.GetModuleFileName(), imageLocationAlreadyNormalized : true);
+#endif
+                
+            }
+
+#if FEATURE_FUSION
+            // If there is no relative path then check the
+            // environment
+            if(info.Value[(int) AppDomainSetup.LoaderInformation.PrivateBinPathValue] == null)
+                info.PrivateBinPath = Environment.nativeGetEnvironmentVariable(AppDomainSetup.PrivateBinPathEnvironmentVariable);
+
+            // Add the developer path if it exists on this
+            // machine.
+            if(info.DeveloperPath == null)
+                info.DeveloperPath = RuntimeEnvironment.GetDeveloperPath();
+
+            }
+                        
+            // Set up the fusion context
+            IntPtr fusionContext = GetFusionContext();
+            info.SetupFusionContext(fusionContext, oldInfo);
+
+            // Set loader optimization policy
+#else
+#if FEATURE_VERSIONING
+            nCreateContext();
+#endif // FEATURE_VERSIONING
+#endif // FEATURE_FUSION
+
+#if FEATURE_LOADER_OPTIMIZATION
+            if (info.LoaderOptimization != LoaderOptimization.NotSpecified || (oldInfo != null && info.LoaderOptimization != oldInfo.LoaderOptimization))
+                UpdateLoaderOptimization(info.LoaderOptimization);
+#endif                        
+
+
+
+            // This must be the last action taken
+            _FusionStore = info;
+        }
+
+        // used to package up evidence, so it can be serialized
+        //   for the call to InternalRemotelySetupRemoteDomain
+        [Serializable]
+        private class EvidenceCollection
+        {
+            public Evidence ProvidedSecurityInfo;
+            public Evidence CreatorsSecurityInfo;
+        }
+
+        private static void RunInitializer(AppDomainSetup setup)
+        {
+            if (setup.AppDomainInitializer!=null)
+            {
+                string[] args=null;
+                if (setup.AppDomainInitializerArguments!=null)
+                    args=(string[])setup.AppDomainInitializerArguments.Clone();
+                setup.AppDomainInitializer(args);
+            }
+        }
+
+        // Used to switch into other AppDomain and call SetupRemoteDomain.
+        //   We cannot simply call through the proxy, because if there
+        //   are any remoting sinks registered, they can add non-mscorlib
+        //   objects to the message (causing an assembly load exception when
+        //   we try to deserialize it on the other side)
+        [System.Security.SecurityCritical]  // auto-generated
+        private static object PrepareDataForSetup(String friendlyName,
+                                                        AppDomainSetup setup,
+                                                        Evidence providedSecurityInfo,
+                                                        Evidence creatorsSecurityInfo,
+                                                        IntPtr parentSecurityDescriptor,
+                                                        string sandboxName,
+                                                        string[] propertyNames,
+                                                        string[] propertyValues)
+        {
+            byte[] serializedEvidence = null;
+            bool generateDefaultEvidence = false;
+
+#if FEATURE_CAS_POLICY
+            // serialize evidence
+            EvidenceCollection evidenceCollection = null;
+
+            if (providedSecurityInfo != null || creatorsSecurityInfo != null)
+            {
+                // If we're just passing through AppDomain.CurrentDomain.Evidence, and that evidence is just
+                // using the standard runtime AppDomainEvidenceFactory, don't waste time serializing it and
+                // deserializing it back -- instead, we can recreate a new AppDomainEvidenceFactory in the new
+                // domain.  We only want to do this if there is no HostSecurityManager, otherwise the
+                // HostSecurityManager could have added additional evidence on top of our standard factory.
+                HostSecurityManager hsm = CurrentDomain.DomainManager != null ? CurrentDomain.DomainManager.HostSecurityManager : null;
+                bool hostMayContributeEvidence = hsm != null &&
+                                                 hsm.GetType() != typeof(HostSecurityManager) &&
+                                                 (hsm.Flags & HostSecurityManagerOptions.HostAppDomainEvidence) == HostSecurityManagerOptions.HostAppDomainEvidence;
+                if (!hostMayContributeEvidence)
+                {
+                    if (providedSecurityInfo != null &&
+                        providedSecurityInfo.IsUnmodified &&
+                        providedSecurityInfo.Target != null &&
+                        providedSecurityInfo.Target is AppDomainEvidenceFactory)
+                    {
+                        providedSecurityInfo = null;
+                        generateDefaultEvidence = true;
+                    }
+                    if (creatorsSecurityInfo != null &&
+                        creatorsSecurityInfo.IsUnmodified &&
+                        creatorsSecurityInfo.Target != null &&
+                        creatorsSecurityInfo.Target is AppDomainEvidenceFactory)
+                    {
+                        creatorsSecurityInfo = null;
+                        generateDefaultEvidence = true;
+                    }
+                }
+            }
+            if ((providedSecurityInfo != null) ||
+                (creatorsSecurityInfo != null)) {
+                evidenceCollection = new EvidenceCollection();
+                evidenceCollection.ProvidedSecurityInfo = providedSecurityInfo;
+                evidenceCollection.CreatorsSecurityInfo = creatorsSecurityInfo;
+            }
+
+            if (evidenceCollection != null) {
+                serializedEvidence =
+                    CrossAppDomainSerializer.SerializeObject(evidenceCollection).GetBuffer();                
+            }
+#endif // FEATURE_CAS_POLICY
+
+            AppDomainInitializerInfo initializerInfo = null;
+            if (setup!=null && setup.AppDomainInitializer!=null)
+                initializerInfo=new AppDomainInitializerInfo(setup.AppDomainInitializer);
+
+            // will travel x-Ad, drop non-agile data 
+            AppDomainSetup newSetup = new AppDomainSetup(setup, false);
+
+#if FEATURE_CORECLR
+            // Remove the special AppDomainCompatSwitch entries from the set of name value pairs
+            // And add them to the AppDomainSetup
+            //
+            // This is only supported on CoreCLR through ICLRRuntimeHost2.CreateAppDomainWithManager
+            // Desktop code should use System.AppDomain.CreateDomain() or 
+            // System.AppDomainManager.CreateDomain() and add the flags to the AppDomainSetup
+            List<String> compatList = new List<String>();
+                        
+            if(propertyNames!=null && propertyValues != null)
+            {
+                for (int i=0; i<propertyNames.Length; i++)
+                {
+                    if(String.Compare(propertyNames[i], "AppDomainCompatSwitch", StringComparison.OrdinalIgnoreCase) == 0) 
+                    {
+                        compatList.Add(propertyValues[i]);
+                        propertyNames[i] = null;                        
+                        propertyValues[i] = null;
+                    }
+
+                }
+                
+                if (compatList.Count > 0)
+                {
+                    newSetup.SetCompatibilitySwitches(compatList);
+                }            
+            }
+#endif // FEATURE_CORECLR
+
+
+            return new Object[] 
+            {
+                friendlyName, 
+                newSetup, 
+                parentSecurityDescriptor, 
+                generateDefaultEvidence,
+                serializedEvidence,
+                initializerInfo,
+                sandboxName,
+                propertyNames,
+                propertyValues
+            };  
+        } // PrepareDataForSetup
+
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.NoInlining)]
+        private static Object Setup(Object arg)
+        {
+            Contract.Requires(arg != null && arg is Object[]);
+            Contract.Requires(((Object[])arg).Length >= 8);
+
+            Object[] args=(Object[])arg;
+            String           friendlyName               = (String)args[0];
+            AppDomainSetup   setup                      = (AppDomainSetup)args[1];
+            IntPtr           parentSecurityDescriptor   = (IntPtr)args[2];
+            bool             generateDefaultEvidence    = (bool)args[3];
+            byte[]           serializedEvidence         = (byte[])args[4];
+            AppDomainInitializerInfo initializerInfo    = (AppDomainInitializerInfo)args[5];
+            string           sandboxName                = (string)args[6];
+            string[]         propertyNames              = (string[])args[7]; // can contain null elements
+            string[]         propertyValues             = (string[])args[8]; // can contain null elements           
+            // extract evidence
+            Evidence providedSecurityInfo = null;
+            Evidence creatorsSecurityInfo = null;
+
+
+            AppDomain ad = AppDomain.CurrentDomain;
+            AppDomainSetup newSetup=new AppDomainSetup(setup,false);
+
+            if(propertyNames!=null && propertyValues != null)
+            {
+#if FEATURE_CORECLR
+                StringBuilder normalisedAppPathList = null;
+#endif // FEATURE_CORECLR
+                for (int i=0; i<propertyNames.Length; i++)
+                {
+                    if(propertyNames[i]=="APPBASE") // make sure in sync with Fusion
+                    {
+                        if(propertyValues[i]==null)
+                            throw new ArgumentNullException("APPBASE");
+                            
+                        if (Path.IsRelative(propertyValues[i]))
+                            throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
+
+                        newSetup.ApplicationBase = NormalizePath(propertyValues[i], fullCheck: true);
+
+                    }
+#if FEATURE_CAS_POLICY
+                    else if(propertyNames[i]=="LOCATION_URI" && providedSecurityInfo==null)
+                    {
+                        providedSecurityInfo=new Evidence();
+                        providedSecurityInfo.AddHostEvidence(new Url(propertyValues[i]));
+                        ad.SetDataHelper(propertyNames[i],propertyValues[i],null);
+                    }
+#endif // FEATURE_CAS_POLICY
+#if FEATURE_LOADER_OPTIMIZATION
+                    else
+                    if(propertyNames[i]=="LOADER_OPTIMIZATION")
+                    {
+                        if(propertyValues[i]==null)
+                            throw new ArgumentNullException("LOADER_OPTIMIZATION");
+
+                        switch(propertyValues[i])
+                        {
+                            case "SingleDomain": newSetup.LoaderOptimization=LoaderOptimization.SingleDomain;break;
+                            case "MultiDomain": newSetup.LoaderOptimization=LoaderOptimization.MultiDomain;break;
+                            case "MultiDomainHost": newSetup.LoaderOptimization=LoaderOptimization.MultiDomainHost;break;
+                            case "NotSpecified": newSetup.LoaderOptimization=LoaderOptimization.NotSpecified;break;
+                            default: throw new ArgumentException(Environment.GetResourceString("Argument_UnrecognizedLoaderOptimization"), "LOADER_OPTIMIZATION");
+                        }
+                    }
+#endif // FEATURE_LOADER_OPTIMIZATION
+#if FEATURE_CORECLR
+                    else
+                    if(propertyNames[i]=="NATIVE_DLL_SEARCH_DIRECTORIES")
+                    {
+                        if(propertyValues[i]==null)
+                            throw new ArgumentNullException("NATIVE_DLL_SEARCH_DIRECTORIES");
+                        ad.SetDataHelper(propertyNames[i],propertyValues[i],null);
+                        string paths = (string)propertyValues[i];
+                        if( paths.Length==0 )
+                            continue;
+                        nSetNativeDllSearchDirectories(paths);
+                    }
+                    else
+                    if(propertyNames[i]=="TRUSTED_PLATFORM_ASSEMBLIES" ||
+                       propertyNames[i]=="PLATFORM_RESOURCE_ROOTS" ||
+                       propertyNames[i]=="APP_PATHS" ||
+                       propertyNames[i]=="APP_NI_PATHS")
+                    {
+                        string values = propertyValues[i];
+                        if(values==null)
+                            throw new ArgumentNullException(propertyNames[i]);
+
+                        int estimatedLength = values.Length + 1; // +1 for extra separator temporarily added at end
+                        if (normalisedAppPathList == null) {
+                            normalisedAppPathList = new StringBuilder(estimatedLength);
+                        }
+                        else {
+                            normalisedAppPathList.Clear();
+                            if (normalisedAppPathList.Capacity < estimatedLength)
+                                normalisedAppPathList.Capacity = estimatedLength;
+                        }
+
+                        for (int pos = 0; pos < values.Length; pos++)
+                        {
+                            string path;
+
+                            int nextPos = values.IndexOf(Path.PathSeparator, pos);
+                            if (nextPos == -1)
+                            {
+                                path = values.Substring(pos);
+                                pos = values.Length - 1;
+                            }
+                            else
+                            {
+                                path = values.Substring(pos, nextPos - pos);
+                                pos = nextPos;
+                            }
+
+                            if( path.Length==0 )                  // skip empty dirs
+                                continue;
+
+                            if (Path.IsRelative(path))
+                                throw new ArgumentException( Environment.GetResourceString( "Argument_AbsolutePathRequired" ) );
+
+                            string appPath = NormalizePath(path, fullCheck: true);
+                            normalisedAppPathList.Append(appPath);
+                            normalisedAppPathList.Append(Path.PathSeparator);
+                        }
+                        // Strip the last separator
+                        if (normalisedAppPathList.Length > 0)
+                        {
+                            normalisedAppPathList.Remove(normalisedAppPathList.Length - 1, 1);
+                        }
+                        ad.SetDataHelper(propertyNames[i],normalisedAppPathList.ToString(),null);        // not supported by fusion, so set explicitly
+                    }
+                    else
+                    if(propertyNames[i]!= null)
+                    {
+                        ad.SetDataHelper(propertyNames[i],propertyValues[i],null);     // just propagate
+                    }
+#endif
+
+                }
+            }
+
+#if !FEATURE_CORECLR
+            AppDomainSortingSetupInfo sortingSetup = newSetup._AppDomainSortingSetupInfo;
+
+            if(sortingSetup != null)
+            {          
+                if(sortingSetup._pfnIsNLSDefinedString == IntPtr.Zero || sortingSetup._pfnCompareStringEx == IntPtr.Zero || sortingSetup._pfnLCMapStringEx == IntPtr.Zero || sortingSetup._pfnFindNLSStringEx == IntPtr.Zero
+                    || sortingSetup._pfnCompareStringOrdinal == IntPtr.Zero || sortingSetup._pfnGetNLSVersionEx == IntPtr.Zero) 
+                {
+             
+                    if(!(sortingSetup._pfnIsNLSDefinedString == IntPtr.Zero && sortingSetup._pfnCompareStringEx == IntPtr.Zero && sortingSetup._pfnLCMapStringEx == IntPtr.Zero && sortingSetup._pfnFindNLSStringEx == IntPtr.Zero
+                        && sortingSetup._pfnCompareStringOrdinal == IntPtr.Zero && sortingSetup._pfnGetNLSVersionEx == IntPtr.Zero)) 
+                    {
+                        // Some functions defined but not all of them.
+                        throw new ArgumentException(Environment.GetResourceString("ArgumentException_NotAllCustomSortingFuncsDefined"));
+                    }
+
+                }
+            }
+#endif
+
+            ad.SetupFusionStore(newSetup, null); // makes FusionStore a ref to newSetup
+            
+            // technically, we don't need this, newSetup refers to the same object as FusionStore 
+            // but it's confusing since it isn't immediately obvious whether we have a ref or a copy
+            AppDomainSetup adSetup = ad.FusionStore; 
+
+#if FEATURE_CORECLR
+            adSetup.InternalSetApplicationTrust(sandboxName);
+#endif // FEATURE_CORECLR
+
+#if !FEATURE_CORECLR  // not used by coreclr
+            if (serializedEvidence != null) {
+                EvidenceCollection evidenceCollection = (EvidenceCollection)
+                    CrossAppDomainSerializer.DeserializeObject(new MemoryStream(serializedEvidence));
+                providedSecurityInfo  = evidenceCollection.ProvidedSecurityInfo;
+                creatorsSecurityInfo  = evidenceCollection.CreatorsSecurityInfo;
+            }
+#endif
+            // set up the friendly name
+            ad.nSetupFriendlyName(friendlyName);
+
+#if FEATURE_COMINTEROP
+            if (setup != null && setup.SandboxInterop)
+            {
+                ad.nSetDisableInterfaceCache();
+            }
+#endif // FEATURE_COMINTEROP
+
+            // set up the AppDomainManager for this domain and initialize security.
+            if (adSetup.AppDomainManagerAssembly != null && adSetup.AppDomainManagerType != null)
+            {
+                ad.SetAppDomainManagerType(adSetup.AppDomainManagerAssembly, adSetup.AppDomainManagerType);
+            }
+
+#if FEATURE_APTCA
+            // set any conditial-aptca visible assemblies
+            ad.PartialTrustVisibleAssemblies = adSetup.PartialTrustVisibleAssemblies;
+#endif // FEATURE_APTCA
+
+            ad.CreateAppDomainManager(); // could modify FusionStore's object
+            ad.InitializeDomainSecurity(providedSecurityInfo,
+                                        creatorsSecurityInfo,
+                                        generateDefaultEvidence,
+                                        parentSecurityDescriptor,
+                                        true);
+            
+            // can load user code now
+            if(initializerInfo!=null)
+                adSetup.AppDomainInitializer=initializerInfo.Unwrap();
+            RunInitializer(adSetup);
+
+            // Activate the application if needed.
+#if FEATURE_CLICKONCE 
+            ObjectHandle oh = null;
+            if (adSetup.ActivationArguments != null && adSetup.ActivationArguments.ActivateInstance)
+                oh = Activator.CreateInstance(ad.ActivationContext);
+            return RemotingServices.MarshalInternal(oh, null, null);
+#else
+            return null;
+#endif // FEATURE_CLICKONCE
+        }
+
+        [SecuritySafeCritical]
+        internal static string NormalizePath(string path, bool fullCheck)
+        {
+#if FEATURE_PATHCOMPAT
+            // Appcontext switches can't currently be safely hit during AppDomain bringup
+            return Path.LegacyNormalizePath(
+                path: path,
+                fullCheck: fullCheck,
+                maxPathLength: PathInternal.MaxShortPath,
+                expandShortPaths: true);
+#else
+            return Path.NormalizePath(
+                path: path,
+                fullCheck: fullCheck,
+                expandShortPaths: true);
+#endif
+        }
+
+#if FEATURE_APTCA
+        // Called from DomainAssembly in Conditional APTCA cases
+        [PermissionSet(SecurityAction.Assert, Unrestricted = true)]
+        [SecuritySafeCritical]
+        private bool IsAssemblyOnAptcaVisibleList(RuntimeAssembly assembly)
+        {
+            if (_aptcaVisibleAssemblies == null)
+                return false;
+
+            AssemblyName assemblyName = assembly.GetName();
+            String name = assemblyName.GetNameWithPublicKey();
+
+            name = name.ToUpperInvariant();
+
+            int index = Array.BinarySearch<string>(_aptcaVisibleAssemblies, name,
+                                                   StringComparer.OrdinalIgnoreCase);
+            return (index >=0);
+
+        }
+
+        //Used to binary search the list of C-APTCA strings for an AssemblyName.  It compares assembly name
+        //and public key token.
+        private class CAPTCASearcher : IComparer
+        {
+            int IComparer.Compare(object /*string*/lhs, object /*AssemblyName*/rhs)
+            {
+                AssemblyName captcaEntry = new AssemblyName((string)lhs);
+                AssemblyName comparand = (AssemblyName)rhs;
+                int nameComp = string.Compare(captcaEntry.Name,
+                                              comparand.Name,
+                                              StringComparison.OrdinalIgnoreCase);
+                if (nameComp != 0)
+                {
+                    return nameComp;
+                }
+
+                //simple names match.  Compare public key tokens.
+                byte[] lhsKey = captcaEntry.GetPublicKeyToken();
+                byte[] rhsKey = comparand.GetPublicKeyToken();
+
+                // We require both sides have a public key token
+                if (lhsKey == null)
+                {
+                    return -1;
+                }
+                if (rhsKey == null)
+                {
+                    return 1;
+                }
+                if (lhsKey.Length < rhsKey.Length)
+                {
+                    return -1;
+                }
+                if (lhsKey.Length > rhsKey.Length)
+                {
+                    return 1;
+                }
+
+                // Tokens seem valid - make sure the compare correctly
+                for (int i = 0; i < lhsKey.Length; ++i)
+                {
+                    byte lhsByte = lhsKey[i];
+                    byte rhsByte = rhsKey[i];
+
+                    if (lhsByte < rhsByte)
+                    {
+                        return -1;
+                    }
+                    if (lhsByte > rhsByte)
+                    {
+                        return 1;
+                    }
+                }
+
+                //They match.
+                return 0;
+            }
+        }
+
+        [System.Security.SecurityCritical]
+        private unsafe bool IsAssemblyOnAptcaVisibleListRaw(char * namePtr, int nameLen, byte * keyTokenPtr,
+                                                            int keyTokenLen)
+        {
+            //This version is used for checking ngen dependencies against the C-APTCA list.  It lets us
+            //reject ngen images that depend on an assembly that has been disabled in the current domain.
+            //Since we only have the public key token in the ngen image, we'll check against that.  The
+            //rationale is that if you have a public key token collision in your process you have many
+            //problems.  Since the source of this public key token is an ngen image for a full trust
+            //assembly, there is essentially no risk to the reduced check.
+            if (_aptcaVisibleAssemblies == null)
+                return false;
+
+            string name = new string(namePtr, 0, nameLen);
+            byte[] keyToken = new byte[keyTokenLen];
+            for( int i = 0; i < keyToken.Length; ++i )
+                keyToken[i] = keyTokenPtr[i];
+
+            AssemblyName asmName = new AssemblyName();
+            asmName.Name = name;
+            asmName.SetPublicKeyToken(keyToken);
+            try
+            {
+                int index = Array.BinarySearch(_aptcaVisibleAssemblies, asmName, new CAPTCASearcher());
+                return (index >= 0);
+            }
+            catch (InvalidOperationException) { /* Can happen for poorly formed assembly names */ return false; }
+        }
+
+#endif
+
+        // This routine is called from unmanaged code to
+        // set the default fusion context.
+        [System.Security.SecurityCritical]  // auto-generated
+        private void SetupDomain(bool allowRedirects, String path, String configFile, String[] propertyNames, String[] propertyValues)
+        {
+            // It is possible that we could have multiple threads initializing
+            // the default domain. We will just take the winner of these two.
+            // (eg. one thread doing a com call and another doing attach for IJW)
+            lock (this) {
+                if(_FusionStore == null) {
+                    AppDomainSetup setup = new AppDomainSetup();
+#if FEATURE_CORECLR
+                    // always use internet permission set
+                    setup.InternalSetApplicationTrust("Internet");
+#endif // FEATURE_CORECLR
+#if FEATURE_FUSION
+                    setup.SetupDefaults(RuntimeEnvironment.GetModuleFileName(), imageLocationAlreadyNormalized : true);
+                    if(path != null)
+                        setup.Value[(int) AppDomainSetup.LoaderInformation.ApplicationBaseValue] = path;
+                    if(configFile != null)
+                        setup.Value[(int) AppDomainSetup.LoaderInformation.ConfigurationFileValue] = configFile;
+
+                    // Default fusion context starts with binding redirects turned off.
+                    if (!allowRedirects)
+                        setup.DisallowBindingRedirects = true;
+#endif
+
+#if !FEATURE_CORECLR
+                    if (propertyNames != null) {
+                        BCLDebug.Assert(propertyValues != null, "propertyValues != null");
+                        BCLDebug.Assert(propertyNames.Length == propertyValues.Length, "propertyNames.Length == propertyValues.Length");
+
+                        for (int i = 0; i < propertyNames.Length; ++i) {
+                            if (String.Equals(propertyNames[i], "PARTIAL_TRUST_VISIBLE_ASSEMBLIES", StringComparison.Ordinal)) {
+                                // The value of the PARTIAL_TRUST_VISIBLE_ASSEMBLIES property is a semicolon
+                                // delimited list of assembly names to add to the
+                                // PartialTrustVisibleAssemblies setting of the domain setup
+                                if (propertyValues[i] != null) {
+                                    if (propertyValues[i].Length > 0) {
+                                        setup.PartialTrustVisibleAssemblies = propertyValues[i].Split(';');
+                                    }
+                                    else {
+                                        setup.PartialTrustVisibleAssemblies = new string[0];
+                                    }
+                                }
+                            }
+                            else {
+                                // In v4 we disallow anything but PARTIAL_TRUST_VISIBLE_ASSEMBLIES to come
+                                // in via the default domain properties.  That restriction could be lifted
+                                // in a future release, at which point this assert should be removed.
+                                // 
+                                // This should be kept in sync with the real externally facing filter code
+                                // in CorHost2::SetPropertiesForDefaultAppDomain
+                                BCLDebug.Assert(false, "Unexpected default domain property");
+                            }
+                        }
+                    }
+#endif // !FEATURE_CORECLR
+
+#if FEATURE_APTCA
+                    // Propigate the set of conditional APTCA assemblies that will be used in the default
+                    // domain onto the domain itself and also into the VM
+                    PartialTrustVisibleAssemblies = setup.PartialTrustVisibleAssemblies;
+#endif // FEATURE_APTCA
+
+                    SetupFusionStore(setup, null);
+                }
+            }
+        }
+
+#if FEATURE_LOADER_OPTIMIZATION
+       [System.Security.SecurityCritical]  // auto-generated
+       private void SetupLoaderOptimization(LoaderOptimization policy)
+        {
+            if(policy != LoaderOptimization.NotSpecified) {
+                Contract.Assert(FusionStore.LoaderOptimization == LoaderOptimization.NotSpecified,
+                                "It is illegal to change the Loader optimization on a domain");
+
+                FusionStore.LoaderOptimization = policy;
+                UpdateLoaderOptimization(FusionStore.LoaderOptimization);
+            }
+        }
+#endif
+           
+#if FEATURE_FUSION
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern IntPtr GetFusionContext();
+#endif // FEATURE_FUSION
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern IntPtr GetSecurityDescriptor();
+
+#if FEATURE_REMOTING        
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal static extern AppDomain nCreateDomain(String friendlyName,
+                                                      AppDomainSetup setup,
+                                                      Evidence providedSecurityInfo,
+                                                      Evidence creatorsSecurityInfo,
+                                                      IntPtr parentSecurityDescriptor);
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal static extern ObjRef nCreateInstance(String friendlyName,
+                                                      AppDomainSetup setup,
+                                                      Evidence providedSecurityInfo,
+                                                      Evidence creatorsSecurityInfo,
+                                                      IntPtr parentSecurityDescriptor);
+#endif
+
+        [SecurityCritical]
+        private void SetupDomainSecurity(Evidence appDomainEvidence,
+                                         IntPtr creatorsSecurityDescriptor,
+                                         bool publishAppDomain)
+        {
+            Evidence stackEvidence = appDomainEvidence;
+            SetupDomainSecurity(GetNativeHandle(),
+                                JitHelpers.GetObjectHandleOnStack(ref stackEvidence),
+                                creatorsSecurityDescriptor,
+                                publishAppDomain);
+
+        }
+
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void SetupDomainSecurity(AppDomainHandle appDomain,
+                                                       ObjectHandleOnStack appDomainEvidence,
+                                                       IntPtr creatorsSecurityDescriptor,
+                                                       [MarshalAs(UnmanagedType.Bool)] bool publishAppDomain);
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern void nSetupFriendlyName(string friendlyName);
+
+#if FEATURE_COMINTEROP
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern void nSetDisableInterfaceCache();
+#endif // FEATURE_COMINTEROP
+
+#if FEATURE_LOADER_OPTIMIZATION
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern void UpdateLoaderOptimization(LoaderOptimization optimization);
+#endif
+
+#if FEATURE_FUSION       
+        //
+        // This is just designed to prevent compiler warnings.
+        // This field is used from native, but we need to prevent the compiler warnings.
+        //
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.SetShadowCopyPath has been deprecated. Please investigate the use of AppDomainSetup.ShadowCopyDirectories instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void SetShadowCopyPath(String path)
+        {
+            InternalSetShadowCopyPath(path);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.SetShadowCopyFiles has been deprecated. Please investigate the use of AppDomainSetup.ShadowCopyFiles instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void SetShadowCopyFiles()
+        {
+            InternalSetShadowCopyFiles();
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [Obsolete("AppDomain.SetDynamicBase has been deprecated. Please investigate the use of AppDomainSetup.DynamicBase instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        public void SetDynamicBase(String path)
+        {
+            InternalSetDynamicBase(path);
+        }
+#endif // FEATURE_FUSION
+
+        public AppDomainSetup SetupInformation
+        {
+            get {
+                return new AppDomainSetup(FusionStore,true);
+            }
+        }
+
+#if FEATURE_FUSION
+        [System.Security.SecurityCritical]  // auto-generated
+        internal void InternalSetShadowCopyPath(String path)
+        {
+            if (path != null)
+            {
+                IntPtr fusionContext = GetFusionContext();
+                AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.ShadowCopyDirectoriesKey, path);
+            }
+            FusionStore.ShadowCopyDirectories = path;
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal void InternalSetShadowCopyFiles()
+        {
+            IntPtr fusionContext = GetFusionContext();
+            AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.ShadowCopyFilesKey, "true");
+            FusionStore.ShadowCopyFiles = "true";
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal void InternalSetCachePath(String path)
+        {
+            FusionStore.CachePath = path;
+            if (FusionStore.Value[(int) AppDomainSetup.LoaderInformation.CachePathValue] != null)
+            {
+                IntPtr fusionContext = GetFusionContext();
+                AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.CachePathKey,
+                                                     FusionStore.Value[(int) AppDomainSetup.LoaderInformation.CachePathValue]);
+            }
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal void InternalSetPrivateBinPath(String path)
+        {
+            IntPtr fusionContext = GetFusionContext();
+            AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.PrivateBinPathKey, path);
+            FusionStore.PrivateBinPath = path;
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        internal void InternalSetDynamicBase(String path)
+        {
+            FusionStore.DynamicBase = path;
+            if (FusionStore.Value[(int) AppDomainSetup.LoaderInformation.DynamicBaseValue] != null)
+            {
+                IntPtr fusionContext = GetFusionContext();
+                AppDomainSetup.UpdateContextProperty(fusionContext, AppDomainSetup.DynamicBaseKey,
+                                                     FusionStore.Value[(int) AppDomainSetup.LoaderInformation.DynamicBaseValue]);
+            }
+        }
+#endif // FEATURE_FUSION
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern String IsStringInterned(String str);
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        internal extern String GetOrInternString(String str);
+        
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void GetGrantSet(AppDomainHandle domain, ObjectHandleOnStack retGrantSet);
+
+#if FEATURE_CAS_POLICY
+        [SecurityCritical]
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SuppressUnmanagedCodeSecurity]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool GetIsLegacyCasPolicyEnabled(AppDomainHandle domain);
+#endif // FEATURE_CAS_POLICY
+
+        public PermissionSet PermissionSet
+        {
+            // SecurityCritical because permissions can contain sensitive information such as paths
+            [SecurityCritical]
+            get
+            {
+                PermissionSet grantSet = null;
+                GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref grantSet));
+
+                if (grantSet != null)
+                {
+                    return grantSet.Copy();
+                }
+                else
+                {
+                    return new PermissionSet(PermissionState.Unrestricted);
+                }
+            }
+        }
+
+        public bool IsFullyTrusted
+        {
+            [SecuritySafeCritical]
+            get
+            {
+                PermissionSet grantSet = null;
+                GetGrantSet(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref grantSet));
+
+                return grantSet == null || grantSet.IsUnrestricted();
+            }
+        }
+
+        public bool IsHomogenous
+        {
+            get
+            {
+                // Homogenous AppDomains always have an ApplicationTrust associated with them
+                return _IsFastFullTrustDomain || _applicationTrust != null;
+            }
+        }
+
+#if FEATURE_CAS_POLICY
+        internal bool IsLegacyCasPolicyEnabled
+        {
+            [SecuritySafeCritical]
+            get
+            {
+                return GetIsLegacyCasPolicyEnabled(GetNativeHandle());
+            }
+        }
+
+        // Determine what this homogenous domain thinks the grant set should be for a specific set of evidence
+        [SecuritySafeCritical]
+        internal PermissionSet GetHomogenousGrantSet(Evidence evidence)
+        {
+            Contract.Assert(evidence != null);
+            Contract.Assert(IsHomogenous);
+            Contract.Assert(evidence.GetHostEvidence<GacInstalled>() == null);
+
+            if (_IsFastFullTrustDomain)
+            {
+                return new PermissionSet(PermissionState.Unrestricted);
+            }
+
+            // If the ApplicationTrust's full trust list calls out the assembly, then it is fully trusted
+            if (evidence.GetDelayEvaluatedHostEvidence<StrongName>() != null)
+            {
+                foreach (StrongName fullTrustAssembly in ApplicationTrust.FullTrustAssemblies)
+                {
+                    StrongNameMembershipCondition sn = new StrongNameMembershipCondition(fullTrustAssembly.PublicKey,
+                                                                                         fullTrustAssembly.Name,
+                                                                                         fullTrustAssembly.Version);
+
+                    object usedEvidence = null;
+                    if ((sn as IReportMatchMembershipCondition).Check(evidence, out usedEvidence))
+                    {
+                        IDelayEvaluatedEvidence delayEvidence = usedEvidence as IDelayEvaluatedEvidence;
+                        if (usedEvidence != null)
+                        {
+                            delayEvidence.MarkUsed();
+                        }
+
+                        return new PermissionSet(PermissionState.Unrestricted);
+                    }
+                }
+            }
+
+            // Otherwise, the grant set is just the default grant set
+            return ApplicationTrust.DefaultGrantSet.PermissionSet.Copy();
+        }
+#endif // FEATURE_CAS_POLICY
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern void nChangeSecurityPolicy();
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [ReliabilityContract(Consistency.MayCorruptAppDomain, Cer.MayFail)]
+        internal static extern void nUnload(Int32 domainInternal);
+           
+        public Object CreateInstanceAndUnwrap(String assemblyName,
+                                              String typeName)
+        {
+            ObjectHandle oh = CreateInstance(assemblyName, typeName);
+            if (oh == null)
+                return null;
+
+            return oh.Unwrap();
+        } // CreateInstanceAndUnwrap
+
+
+        public Object CreateInstanceAndUnwrap(String assemblyName, 
+                                              String typeName,
+                                              Object[] activationAttributes)
+        {
+            ObjectHandle oh = CreateInstance(assemblyName, typeName, activationAttributes);
+            if (oh == null)
+                return null; 
+
+            return oh.Unwrap();
+        } // CreateInstanceAndUnwrap
+
+
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public Object CreateInstanceAndUnwrap(String assemblyName, 
+                                              String typeName, 
+                                              bool ignoreCase,
+                                              BindingFlags bindingAttr, 
+                                              Binder binder,
+                                              Object[] args,
+                                              CultureInfo culture,
+                                              Object[] activationAttributes,
+                                              Evidence securityAttributes)
+        {
+#pragma warning disable 618
+            ObjectHandle oh = CreateInstance(assemblyName, typeName, ignoreCase, bindingAttr,
+                binder, args, culture, activationAttributes, securityAttributes);
+#pragma warning restore 618
+
+            if (oh == null)
+                return null; 
+            
+            return oh.Unwrap();
+        } // CreateInstanceAndUnwrap
+
+        public object CreateInstanceAndUnwrap(string assemblyName,
+                                              string typeName,
+                                              bool ignoreCase,
+                                              BindingFlags bindingAttr,
+                                              Binder binder,
+                                              object[] args,
+                                              CultureInfo culture,
+                                              object[] activationAttributes)
+        {
+            ObjectHandle oh = CreateInstance(assemblyName,
+                                             typeName,
+                                             ignoreCase,
+                                             bindingAttr,
+                                             binder,
+                                             args,
+                                             culture,
+                                             activationAttributes);
+
+            if (oh == null)
+            {
+                return null;
+            }
+
+            return oh.Unwrap();
+        }
+
+        // The first parameter should be named assemblyFile, but it was incorrectly named in a previous 
+        //  release, and the compatibility police won't let us change the name now.
+        public Object CreateInstanceFromAndUnwrap(String assemblyName,
+                                                  String typeName)
+        {
+            ObjectHandle oh = CreateInstanceFrom(assemblyName, typeName);
+            if (oh == null)
+                return null;  
+
+            return oh.Unwrap();                
+        } // CreateInstanceAndUnwrap
+
+
+        // The first parameter should be named assemblyFile, but it was incorrectly named in a previous 
+        //  release, and the compatibility police won't let us change the name now.
+        public Object CreateInstanceFromAndUnwrap(String assemblyName,
+                                                  String typeName,
+                                                  Object[] activationAttributes)
+        {
+            ObjectHandle oh = CreateInstanceFrom(assemblyName, typeName, activationAttributes);
+            if (oh == null)
+                return null; 
+
+            return oh.Unwrap();
+        } // CreateInstanceAndUnwrap
+
+
+        // The first parameter should be named assemblyFile, but it was incorrectly named in a previous 
+        //  release, and the compatibility police won't let us change the name now.
+        [Obsolete("Methods which use evidence to sandbox are obsolete and will be removed in a future release of the .NET Framework. Please use an overload of CreateInstanceFromAndUnwrap which does not take an Evidence parameter. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
+        public Object CreateInstanceFromAndUnwrap(String assemblyName, 
+                                                  String typeName, 
+                                                  bool ignoreCase,
+                                                  BindingFlags bindingAttr, 
+                                                  Binder binder,
+                                                  Object[] args,
+                                                  CultureInfo culture,
+                                                  Object[] activationAttributes,
+                                                  Evidence securityAttributes)
+        {
+#pragma warning disable 618
+            ObjectHandle oh = CreateInstanceFrom(assemblyName, typeName, ignoreCase, bindingAttr,
+                binder, args, culture, activationAttributes, securityAttributes);
+#pragma warning restore 618
+
+            if (oh == null)
+                return null; 
+
+            return oh.Unwrap();
+        } // CreateInstanceAndUnwrap
+
+        public object CreateInstanceFromAndUnwrap(string assemblyFile,
+                                                  string typeName,
+                                                  bool ignoreCase,
+                                                  BindingFlags bindingAttr,
+                                                  Binder binder,
+                                                  object[] args,
+                                                  CultureInfo culture,
+                                                  object[] activationAttributes)
+        {
+            ObjectHandle oh = CreateInstanceFrom(assemblyFile,
+                                                 typeName,
+                                                 ignoreCase,
+                                                 bindingAttr,
+                                                 binder,
+                                                 args,
+                                                 culture,
+                                                 activationAttributes);
+            if (oh == null)
+            {
+                return null;
+            }
+            
+            return oh.Unwrap();
+        }
+
+        public Int32 Id
+        {
+            [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]  
+            get {
+                return GetId();
+            }
+        }
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]              
+        internal extern Int32 GetId();
+        
+        internal const Int32 DefaultADID = 1;
+        
+        public bool IsDefaultAppDomain()
+        {
+            if (GetId()==DefaultADID)
+                return true;
+            return false;
+        }
+
+#if FEATURE_FUSION
+        private static AppDomainSetup InternalCreateDomainSetup(String imageLocation)
+        {
+            int i = imageLocation.LastIndexOf('\\');
+ 
+            Contract.Assert(i != -1, "invalid image location");
+
+            AppDomainSetup info = new AppDomainSetup();
+            info.ApplicationBase = imageLocation.Substring(0, i+1);
+
+            StringBuilder config = new StringBuilder(imageLocation.Substring(i+1));
+            config.Append(AppDomainSetup.ConfigurationExtension);
+            info.ConfigurationFile = config.ToString();
+
+            return info;
+        }
+
+        // Used by the validator for testing but not executing an assembly
+        private static AppDomain InternalCreateDomain(String imageLocation)
+        {
+            AppDomainSetup info = InternalCreateDomainSetup(imageLocation);
+            return CreateDomain("Validator",
+                                null,
+                                info);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void InternalSetDomainContext(String imageLocation)
+        {
+            SetupFusionStore(InternalCreateDomainSetup(imageLocation), null);
+        }
+#endif
+
+#if FEATURE_APPDOMAIN_RESOURCE_MONITORING
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern void nEnableMonitoring();
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern bool nMonitoringIsEnabled();
+
+        // return -1 if ARM is not supported.
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern Int64 nGetTotalProcessorTime();
+
+        // return -1 if ARM is not supported.
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern Int64 nGetTotalAllocatedMemorySize();
+
+        // return -1 if ARM is not supported.
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private extern Int64 nGetLastSurvivedMemorySize();
+
+        // return -1 if ARM is not supported.
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern Int64 nGetLastSurvivedProcessMemorySize();
+
+        public static bool MonitoringIsEnabled
+        {
+            [System.Security.SecurityCritical]
+            get {
+                return nMonitoringIsEnabled();
+            }
+            
+            [System.Security.SecurityCritical]
+            set {
+                if (value == false)
+                {
+                    throw new ArgumentException(Environment.GetResourceString("Arg_MustBeTrue"));
+                }
+                else
+                {
+                    nEnableMonitoring();
+                }
+            }
+        }
+
+        // Gets the total processor time for this AppDomain.
+        // Throws NotSupportedException if ARM is not enabled.
+        public TimeSpan MonitoringTotalProcessorTime 
+        {
+            [System.Security.SecurityCritical]
+            get {
+                Int64 i64ProcessorTime = nGetTotalProcessorTime();
+                if (i64ProcessorTime == -1)
+                {
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
+                }
+                return new TimeSpan(i64ProcessorTime);
+            }
+        }
+
+        // Gets the number of bytes allocated in this AppDomain since
+        // the AppDomain was created.
+        // Throws NotSupportedException if ARM is not enabled.
+        public Int64 MonitoringTotalAllocatedMemorySize 
+        {
+            [System.Security.SecurityCritical]
+            get {
+                Int64 i64AllocatedMemory = nGetTotalAllocatedMemorySize();
+                if (i64AllocatedMemory == -1)
+                {
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
+                }
+                return i64AllocatedMemory;
+            }
+        }
+
+        // Gets the number of bytes survived after the last collection
+        // that are known to be held by this AppDomain. After a full 
+        // collection this number is accurate and complete. After an 
+        // ephemeral collection this number is potentially incomplete.
+        // Throws NotSupportedException if ARM is not enabled.
+        public Int64 MonitoringSurvivedMemorySize
+        {
+            [System.Security.SecurityCritical]
+            get {
+                Int64 i64LastSurvivedMemory = nGetLastSurvivedMemorySize();
+                if (i64LastSurvivedMemory == -1)
+                {
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
+                }
+                return i64LastSurvivedMemory;
+            }
+        }
+
+        // Gets the total bytes survived from the last collection. After 
+        // a full collection this number represents the number of the bytes 
+        // being held live in managed heaps. (This number should be close 
+        // to the number obtained from GC.GetTotalMemory for a full collection.)
+        // After an ephemeral collection this number represents the number 
+        // of bytes being held live in ephemeral generations.
+        // Throws NotSupportedException if ARM is not enabled.
+        public static Int64 MonitoringSurvivedProcessMemorySize
+        {
+            [System.Security.SecurityCritical]
+            get {
+                Int64 i64LastSurvivedProcessMemory = nGetLastSurvivedProcessMemorySize();
+                if (i64LastSurvivedProcessMemory == -1)
+                {
+                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_WithoutARM"));
+                }
+                return i64LastSurvivedProcessMemory;
+            }
+        }
+#endif
+
+#if !FEATURE_CORECLR
+        // this method is required so Object.GetType is not made virtual by the compiler
+        // _AppDomain.GetType()
+        public new Type GetType()
+        {
+            return base.GetType();
+        }
+
+        void _AppDomain.GetTypeInfoCount(out uint pcTInfo)
+        {
+            throw new NotImplementedException();
+        }
+
+        void _AppDomain.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
+        {
+            throw new NotImplementedException();
+        }
+
+        void _AppDomain.GetIDsOfNames([In] ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
+        {
+            throw new NotImplementedException();
+        }
+
+        // If you implement this method, make sure to include _AppDomain.Invoke in VM\DangerousAPIs.h and 
+        // include _AppDomain in SystemDomain::IsReflectionInvocationMethod in AppDomain.cpp.
+        void _AppDomain.Invoke(uint dispIdMember, [In] ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
+        {
+            throw new NotImplementedException();
+        }
+#endif
+    }
+
+    //  CallBacks provide a facility to request execution of some code
+    //  in another context/appDomain.
+    //  CrossAppDomainDelegate type is defined for appdomain call backs. 
+    //  The delegate used to request a callbak through the DoCallBack method
+    //  must be of CrossContextDelegate type.
+#if FEATURE_REMOTING    
+[System.Runtime.InteropServices.ComVisible(true)]
+    public delegate void CrossAppDomainDelegate();
+#endif
+
+    /// <summary>
+    ///     Handle used to marshal an AppDomain to the VM (eg QCall). When marshaled via a QCall, the target
+    ///     method in the VM will recieve a QCall::AppDomainHandle parameter.
+    /// </summary>
+    internal struct AppDomainHandle
+    {
+        private IntPtr m_appDomainHandle;
+
+        // Note: generall an AppDomainHandle should not be directly constructed, instead the
+        // code:System.AppDomain.GetNativeHandle method should be called to get the handle for a specific
+        // AppDomain.
+        internal AppDomainHandle(IntPtr domainHandle)
+        {
+            m_appDomainHandle = domainHandle;
+        }
+    }
+}
diff --git a/src/mscorlib/src/System/AppDomainAttributes.cs b/src/mscorlib/src/System/AppDomainAttributes.cs
new file mode 100644
index 0000000000..0980b5fe90
--- /dev/null
+++ b/src/mscorlib/src/System/AppDomainAttributes.cs
@@ -0,0 +1,48 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/*=============================================================================
+**
+** 
+**
+** Purpose: For AppDomain-related custom attributes.
+**
+**
+=============================================================================*/
+
+namespace System {
+
+    [Serializable]
+    [System.Runtime.InteropServices.ComVisible(true)]
+    public enum LoaderOptimization 
+    {
+        NotSpecified            = 0,
+        SingleDomain            = 1,
+        MultiDomain             = 2,
+        MultiDomainHost         = 3,
+        [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        DomainMask              = 3,
+        [Obsolete("This method has been deprecated. Please use Assembly.Load() instead. http://go.microsoft.com/fwlink/?linkid=14202")]
+        DisallowBindings        = 4         
+    }
+
+    [AttributeUsage (AttributeTargets.Method)]  
+    [System.Runtime.InteropServices.ComVisible(true)]
+    public sealed class LoaderOptimizationAttribute : Attribute
+    {
+        internal byte _val;
+
+        public LoaderOptimizationAttribute(byte value)
+        {
+            _val = value;
+        }
+        public LoaderOptimizationAttribute(LoaderOptimization value)
+        {
+            _val = (byte) value;
+        }
+        public LoaderOptimization Value 
+        {  get {return (LoaderOptimization) _val;} }
+    }
+}
+
diff --git a/src/mscorlib/src/System/AppDomainManager.cs b/src/mscorlib/src/System/AppDomainManager.cs
new file mode 100644
index 0000000000..291099e199
--- /dev/null
+++ b/src/mscorlib/src/System/AppDomainManager.cs
@@ -0,0 +1,220 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+
+//
+// An AppDomainManager gives a hosting application the chance to 
+// participate in the creation and control the settings of new AppDomains.
+//
+
+namespace System {
+    using System.Collections;
+    using System.Globalization;
+    using System.IO;
+    using System.Reflection;
+    using System.Runtime.CompilerServices;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Security.Policy;
+    using System.Threading;
+#if FEATURE_CLICKONCE
+    using System.Runtime.Hosting;
+#endif
+    using System.Runtime.Versioning;
+    using System.Runtime.InteropServices;
+    using System.Diagnostics.Contracts;
+
+#if FEATURE_APPDOMAINMANAGER_INITOPTIONS
+    [Flags]
+    [System.Runtime.InteropServices.ComVisible(true)]
+    public enum AppDomainManagerInitializationOptions {
+        None             = 0x0000,
+        RegisterWithHost = 0x0001
+    }
+#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
+
+    [System.Security.SecurityCritical]  // auto-generated_required
+    [System.Runtime.InteropServices.ComVisible(true)]
+#if !FEATURE_CORECLR
+    [SecurityPermissionAttribute(SecurityAction.InheritanceDemand, Flags = SecurityPermissionFlag.Infrastructure)]
+#endif
+#if FEATURE_REMOTING
+    public class AppDomainManager : MarshalByRefObject {
+#else // FEATURE_REMOTING
+    public class AppDomainManager {
+#endif // FEATURE_REMOTING
+        public AppDomainManager () {}
+#if FEATURE_REMOTING
+        [System.Security.SecurityCritical]  // auto-generated
+        public virtual AppDomain CreateDomain (string friendlyName,
+                                               Evidence securityInfo,
+                                               AppDomainSetup appDomainInfo) {
+            return CreateDomainHelper(friendlyName, securityInfo, appDomainInfo);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        [SecurityPermissionAttribute(SecurityAction.Demand, ControlAppDomain = true)]
+        protected static AppDomain CreateDomainHelper (string friendlyName,
+                                                       Evidence securityInfo,
+                                                       AppDomainSetup appDomainInfo) {
+            if (friendlyName == null)
+                throw new ArgumentNullException("friendlyName", Environment.GetResourceString("ArgumentNull_String"));
+
+            Contract.EndContractBlock();
+            // If evidence is provided, we check to make sure that is allowed.
+            if (securityInfo != null) {
+                new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
+
+                // Check the evidence to ensure that if it expects a sandboxed domain, it actually gets one.
+                AppDomain.CheckDomainCreationEvidence(appDomainInfo, securityInfo);
+            }
+
+            if (appDomainInfo == null) {
+                appDomainInfo = new AppDomainSetup();
+            }
+
+            // If there was no specified AppDomainManager for the new domain, default it to being the same
+            // as the current domain's AppDomainManager.
+            if (appDomainInfo.AppDomainManagerAssembly == null || appDomainInfo.AppDomainManagerType == null) {
+                string inheritedDomainManagerAssembly;
+                string inheritedDomainManagerType;
+
+                AppDomain.CurrentDomain.GetAppDomainManagerType(out inheritedDomainManagerAssembly,
+                                                                out inheritedDomainManagerType);
+
+                if (appDomainInfo.AppDomainManagerAssembly == null) {
+                    appDomainInfo.AppDomainManagerAssembly = inheritedDomainManagerAssembly;
+                }
+                if (appDomainInfo.AppDomainManagerType == null) {
+                    appDomainInfo.AppDomainManagerType = inheritedDomainManagerType;
+                }
+            }
+
+            // If there was no specified TargetFrameworkName for the new domain, default it to the current domain's.
+            if (appDomainInfo.TargetFrameworkName == null)
+                appDomainInfo.TargetFrameworkName = AppDomain.CurrentDomain.GetTargetFrameworkName();
+
+            return AppDomain.nCreateDomain(friendlyName,
+                                           appDomainInfo,
+                                           securityInfo,
+                                           securityInfo == null ? AppDomain.CurrentDomain.InternalEvidence : null,
+                                           AppDomain.CurrentDomain.GetSecurityDescriptor());
+        }
+#endif // FEATURE_REMOTING
+
+        [System.Security.SecurityCritical]
+        public virtual void InitializeNewDomain (AppDomainSetup appDomainInfo) {
+            // By default, InitializeNewDomain does nothing. AppDomain.CreateAppDomainManager relies on this fact.
+        }
+
+#if FEATURE_APPDOMAINMANAGER_INITOPTIONS
+
+        private AppDomainManagerInitializationOptions m_flags = AppDomainManagerInitializationOptions.None;
+        public AppDomainManagerInitializationOptions InitializationFlags {
+            get {
+                return m_flags;
+            }
+            set {
+                m_flags = value;
+            }
+        }
+#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
+
+#if FEATURE_CLICKONCE
+        private ApplicationActivator m_appActivator = null;
+        public virtual ApplicationActivator ApplicationActivator {
+            get {
+                if (m_appActivator == null)
+                    m_appActivator = new ApplicationActivator();
+                return m_appActivator;
+            }
+        }
+#endif //#if FEATURE_CLICKONCE
+
+#if FEATURE_CAS_POLICY
+        public virtual HostSecurityManager HostSecurityManager {
+            get {
+                return null;
+            }
+        }
+
+        public virtual HostExecutionContextManager HostExecutionContextManager {
+            get {
+                // By default, the AppDomainManager returns the HostExecutionContextManager.
+                return HostExecutionContextManager.GetInternalHostExecutionContextManager();
+            }
+        }
+#endif // FEATURE_CAS_POLICY
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode), SuppressUnmanagedCodeSecurity]
+        private static extern void GetEntryAssembly(ObjectHandleOnStack retAssembly);
+
+        private Assembly m_entryAssembly = null;
+        public virtual Assembly EntryAssembly {
+            [System.Security.SecurityCritical]  // auto-generated
+            get {
+                // The default AppDomainManager sets the EntryAssembly depending on whether the
+                // AppDomain is a manifest application domain or not. In the first case, we parse
+                // the application manifest to find out the entry point assembly and return that assembly.
+                // In the second case, we maintain the old behavior by calling GetEntryAssembly().
+                if (m_entryAssembly == null)
+                {
+
+#if FEATURE_CLICKONCE
+                    AppDomain domain = AppDomain.CurrentDomain;
+                    if (domain.IsDefaultAppDomain() && domain.ActivationContext != null) {
+                        ManifestRunner runner = new ManifestRunner(domain, domain.ActivationContext);
+                        m_entryAssembly = runner.EntryAssembly;
+                    } else
+#endif //#if FEATURE_CLICKONCE
+                    {
+                        RuntimeAssembly entryAssembly = null;
+                        GetEntryAssembly(JitHelpers.GetObjectHandleOnStack(ref entryAssembly));
+                        m_entryAssembly = entryAssembly;
+                    }
+                }
+                return m_entryAssembly;
+            }
+        }
+
+        internal static AppDomainManager CurrentAppDomainManager {
+            [System.Security.SecurityCritical]  // auto-generated
+            get {
+                return AppDomain.CurrentDomain.DomainManager;
+            }
+        }
+
+        public virtual bool CheckSecuritySettings (SecurityState state)
+        {
+            return false;
+        }
+
+#if FEATURE_APPDOMAINMANAGER_INITOPTIONS
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        private static extern bool HasHost();
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        [SecurityCritical]
+        [SuppressUnmanagedCodeSecurity]
+        private static extern void RegisterWithHost(IntPtr appDomainManager);
+
+        internal void RegisterWithHost() {
+            if (HasHost()) {
+                IntPtr punkAppDomainManager = IntPtr.Zero;
+
+                RuntimeHelpers.PrepareConstrainedRegions();
+                try {
+                    punkAppDomainManager = Marshal.GetIUnknownForObject(this);
+                    RegisterWithHost(punkAppDomainManager);
+                }
+                finally {
+                    if (!punkAppDomainManager.IsNull()) {
+                        Marshal.Release(punkAppDomainManager);
+                    }
+                }
+            }
+        }
+#endif // FEATURE_APPDOMAINMANAGER_INITOPTIONS
+    }
+}
diff --git a/src/mscorlib/src/System/AppDomainSetup.cs b/src/mscorlib/src/System/AppDomainSetup.cs
new file mode 100644
index 0000000000..f1057da082
--- /dev/null
+++ b/src/mscorlib/src/System/AppDomainSetup.cs
@@ -0,0 +1,1444 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/*=============================================================================
+**
+** Class: AppDomainSetup
+** 
+** Purpose: Defines the settings that the loader uses to find assemblies in an
+**          AppDomain
+**
+** Date: Dec 22, 2000
+**
+=============================================================================*/
+
+namespace System {
+    using System;
+#if FEATURE_CLICKONCE        
+    using System.Deployment.Internal.Isolation;
+    using System.Deployment.Internal.Isolation.Manifest;
+    using System.Runtime.Hosting;    
+#endif
+    using System.Runtime.CompilerServices;
+    using System.Runtime;
+    using System.Text;
+    using System.Threading;
+    using System.Runtime.InteropServices;
+    using System.Runtime.Serialization;
+    using System.Reflection;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Security.Policy;
+    using System.Globalization;
+    using Path = System.IO.Path;
+    using System.Runtime.Versioning;
+    using System.Diagnostics.Contracts;
+    using System.Collections;
+    using System.Collections.Generic;
+
+    [Serializable]
+    [ClassInterface(ClassInterfaceType.None)]
+    [System.Runtime.InteropServices.ComVisible(true)]
+    public sealed class AppDomainSetup :
+        IAppDomainSetup
+    {
+        [Serializable]
+        internal enum LoaderInformation
+        {
+            // If you add a new value, add the corresponding property
+            // to AppDomain.GetData() and SetData()'s switch statements,
+            // as well as fusionsetup.h.
+            ApplicationBaseValue          = 0,  // LOADER_APPLICATION_BASE
+            ConfigurationFileValue        = 1,  // LOADER_CONFIGURATION_BASE
+            DynamicBaseValue              = 2,  // LOADER_DYNAMIC_BASE
+            DevPathValue                  = 3,  // LOADER_DEVPATH
+            ApplicationNameValue          = 4,  // LOADER_APPLICATION_NAME
+            PrivateBinPathValue           = 5,  // LOADER_PRIVATE_PATH
+            PrivateBinPathProbeValue      = 6,  // LOADER_PRIVATE_BIN_PATH_PROBE
+            ShadowCopyDirectoriesValue    = 7,  // LOADER_SHADOW_COPY_DIRECTORIES
+            ShadowCopyFilesValue          = 8,  // LOADER_SHADOW_COPY_FILES
+            CachePathValue                = 9,  // LOADER_CACHE_PATH
+            LicenseFileValue              = 10, // LOADER_LICENSE_FILE
+            DisallowPublisherPolicyValue  = 11, // LOADER_DISALLOW_PUBLISHER_POLICY
+            DisallowCodeDownloadValue     = 12, // LOADER_DISALLOW_CODE_DOWNLOAD
+            DisallowBindingRedirectsValue = 13, // LOADER_DISALLOW_BINDING_REDIRECTS
+            DisallowAppBaseProbingValue   = 14, // LOADER_DISALLOW_APPBASE_PROBING
+            ConfigurationBytesValue       = 15, // LOADER_CONFIGURATION_BYTES
+            LoaderMaximum                 = 18  // LOADER_MAXIMUM
+        }
+
+        // Constants from fusionsetup.h.
+        private const string LOADER_OPTIMIZATION = "LOADER_OPTIMIZATION";
+        private const string CONFIGURATION_EXTENSION = ".config";
+        private const string APPENV_RELATIVEPATH = "RELPATH";
+        private const string MACHINE_CONFIGURATION_FILE = "config\\machine.config";
+        private const string ACTAG_HOST_CONFIG_FILE = "HOST_CONFIG";
+
+#if FEATURE_FUSION
+        private const string LICENSE_FILE = "LICENSE_FILE";
+#endif
+
+        // Constants from fusionpriv.h
+        private const string ACTAG_APP_CONFIG_FILE = "APP_CONFIG_FILE";
+        private const string ACTAG_MACHINE_CONFIG = "MACHINE_CONFIG";
+        private const string ACTAG_APP_BASE_URL = "APPBASE";
+        private const string ACTAG_APP_NAME = "APP_NAME";
+        private const string ACTAG_BINPATH_PROBE_ONLY = "BINPATH_PROBE_ONLY";
+        private const string ACTAG_APP_CACHE_BASE = "CACHE_BASE";
+        private const string ACTAG_DEV_PATH = "DEV_PATH";
+        private const string ACTAG_APP_DYNAMIC_BASE = "DYNAMIC_BASE";
+        private const string ACTAG_FORCE_CACHE_INSTALL = "FORCE_CACHE_INSTALL";
+        private const string ACTAG_APP_PRIVATE_BINPATH = "PRIVATE_BINPATH";
+        private const string ACTAG_APP_SHADOW_COPY_DIRS = "SHADOW_COPY_DIRS";
+        private const string ACTAG_DISALLOW_APPLYPUBLISHERPOLICY = "DISALLOW_APP";
+        private const string ACTAG_CODE_DOWNLOAD_DISABLED = "CODE_DOWNLOAD_DISABLED";
+        private const string ACTAG_DISALLOW_APP_BINDING_REDIRECTS = "DISALLOW_APP_REDIRECTS";
+        private const string ACTAG_DISALLOW_APP_BASE_PROBING = "DISALLOW_APP_BASE_PROBING";
+        private const string ACTAG_APP_CONFIG_BLOB = "APP_CONFIG_BLOB";
+
+        // This class has an unmanaged representation so be aware you will need to make edits in vm\object.h if you change the order
+        // of these fields or add new ones.
+
+        private string[] _Entries;
+        private LoaderOptimization _LoaderOptimization;
+#pragma warning disable 169
+        private String _AppBase; // for compat with v1.1
+#pragma warning restore 169
+        [OptionalField(VersionAdded = 2)]
+        private AppDomainInitializer  _AppDomainInitializer;
+        [OptionalField(VersionAdded = 2)]
+        private string[] _AppDomainInitializerArguments;
+#if FEATURE_CLICKONCE
+        [OptionalField(VersionAdded = 2)]
+        private ActivationArguments _ActivationArguments;
+#endif
+#if FEATURE_CORECLR
+        // On the CoreCLR, this contains just the name of the permission set that we install in the new appdomain.
+        // Not the ToXml().ToString() of an ApplicationTrust object.
+#endif
+        [OptionalField(VersionAdded = 2)]
+        private string _ApplicationTrust;
+        [OptionalField(VersionAdded = 2)]
+        private byte[] _ConfigurationBytes;
+#if FEATURE_COMINTEROP
+        [OptionalField(VersionAdded = 3)]
+        private bool _DisableInterfaceCache = false;
+#endif // FEATURE_COMINTEROP
+        [OptionalField(VersionAdded = 4)]
+        private string _AppDomainManagerAssembly;
+        [OptionalField(VersionAdded = 4)]
+        private string _AppDomainManagerType;
+
+#if FEATURE_APTCA
+        [OptionalField(VersionAdded = 4)]
+        private string[] _AptcaVisibleAssemblies;
+#endif
+
+        // A collection of strings used to indicate which breaking changes shouldn't be applied
+        // to an AppDomain. We only use the keys, the values are ignored.
+        [OptionalField(VersionAdded = 4)]
+        private Dictionary<string, object> _CompatFlags;
+
+        [OptionalField(VersionAdded = 5)] // This was added in .NET FX v4.5
+        private String _TargetFrameworkName;
+
+#if !FEATURE_CORECLR
+        [NonSerialized]
+        internal AppDomainSortingSetupInfo _AppDomainSortingSetupInfo;
+#endif
+
+        [OptionalField(VersionAdded = 5)] // This was added in .NET FX v4.5
+        private bool _CheckedForTargetFrameworkName;
+
+#if FEATURE_RANDOMIZED_STRING_HASHING
+        [OptionalField(VersionAdded = 5)] // This was added in .NET FX v4.5
+        private bool _UseRandomizedStringHashing;
+#endif
+
+        [SecuritySafeCritical]
+        internal AppDomainSetup(AppDomainSetup copy, bool copyDomainBoundData)
+        {
+            string[] mine = Value;
+            if(copy != null) {
+                string[] other = copy.Value;
+                int mineSize = _Entries.Length;
+                int otherSize = other.Length;
+                int size = (otherSize < mineSize) ? otherSize : mineSize;
+
+                for (int i = 0; i < size; i++)
+                    mine[i] = other[i];
+
+                if (size < mineSize)
+                {
+                    // This case can happen when the copy is a deserialized version of
+                    // an AppDomainSetup object serialized by Everett.
+                    for (int i = size; i < mineSize; i++)
+                        mine[i] = null;
+                }
+
+                _LoaderOptimization = copy._LoaderOptimization;
+
+                _AppDomainInitializerArguments = copy.AppDomainInitializerArguments;
+#if FEATURE_CLICKONCE
+                _ActivationArguments = copy.ActivationArguments;
+#endif
+                _ApplicationTrust = copy._ApplicationTrust;
+                if (copyDomainBoundData)
+                    _AppDomainInitializer = copy.AppDomainInitializer;
+                else
+                    _AppDomainInitializer = null;
+
+                _ConfigurationBytes = copy.GetConfigurationBytes();
+#if FEATURE_COMINTEROP
+                _DisableInterfaceCache = copy._DisableInterfaceCache;
+#endif // FEATURE_COMINTEROP
+                _AppDomainManagerAssembly = copy.AppDomainManagerAssembly;
+                _AppDomainManagerType = copy.AppDomainManagerType;
+#if FEATURE_APTCA
+                _AptcaVisibleAssemblies = copy.PartialTrustVisibleAssemblies;
+#endif
+
+                if (copy._CompatFlags != null)
+                {
+                    SetCompatibilitySwitches(copy._CompatFlags.Keys);
+                }
+
+#if !FEATURE_CORECLR
+                if(copy._AppDomainSortingSetupInfo != null)
+                {
+                    _AppDomainSortingSetupInfo = new AppDomainSortingSetupInfo(copy._AppDomainSortingSetupInfo);
+                }
+#endif
+                _TargetFrameworkName = copy._TargetFrameworkName;
+
+#if FEATURE_RANDOMIZED_STRING_HASHING
+                _UseRandomizedStringHashing = copy._UseRandomizedStringHashing;
+#endif
+
+            }
+            else 
+                _LoaderOptimization = LoaderOptimization.NotSpecified;
+        }
+
+        public AppDomainSetup()
+        {
+            _LoaderOptimization = LoaderOptimization.NotSpecified;
+        }
+
+#if FEATURE_CLICKONCE
+        // Creates an AppDomainSetup object from an application identity.
+        public AppDomainSetup (ActivationContext activationContext) : this (new ActivationArguments(activationContext)) {}
+
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        public AppDomainSetup (ActivationArguments activationArguments) {
+            if (activationArguments == null)
+                throw new ArgumentNullException("activationArguments");
+            Contract.EndContractBlock();
+
+            _LoaderOptimization = LoaderOptimization.NotSpecified;
+            ActivationArguments = activationArguments;
+
+            Contract.Assert(activationArguments.ActivationContext != null, "Cannot set base directory without activation context");
+            string entryPointPath = CmsUtils.GetEntryPointFullPath(activationArguments);
+            if (!String.IsNullOrEmpty(entryPointPath))
+                SetupDefaults(entryPointPath);
+            else
+                ApplicationBase = activationArguments.ActivationContext.ApplicationDirectory;
+
+        }
+#endif // !FEATURE_CLICKONCE
+
+        #if FEATURE_CORECLR
+        [System.Security.SecurityCritical] // auto-generated
+        #endif
+        internal void SetupDefaults(string imageLocation, bool imageLocationAlreadyNormalized = false) {
+            char[] sep = {'\\', '/'};
+            int i = imageLocation.LastIndexOfAny(sep);
+
+            if (i == -1) {
+                ApplicationName = imageLocation;
+            }
+            else {
+                ApplicationName = imageLocation.Substring(i+1);
+                string appBase = imageLocation.Substring(0, i+1);
+
+                if (imageLocationAlreadyNormalized)
+                    Value[(int) LoaderInformation.ApplicationBaseValue] = appBase;
+                else 
+                    ApplicationBase = appBase;
+            }
+            ConfigurationFile = ApplicationName + AppDomainSetup.ConfigurationExtension;
+        }
+
+        internal string[] Value
+        {
+            get {
+                if( _Entries == null)
+                    _Entries = new String[(int)LoaderInformation.LoaderMaximum];
+                return _Entries;
+            }
+        }
+
+        internal String GetUnsecureApplicationBase()
+        {
+            return Value[(int) LoaderInformation.ApplicationBaseValue];
+        }
+
+        public string AppDomainManagerAssembly
+        {
+            get { return _AppDomainManagerAssembly; }
+            set { _AppDomainManagerAssembly = value; }
+        }
+
+        public string AppDomainManagerType
+        {
+            get { return _AppDomainManagerType; }
+            set { _AppDomainManagerType = value; }
+        }
+
+#if FEATURE_APTCA
+        public string[] PartialTrustVisibleAssemblies
+        {
+            get { return _AptcaVisibleAssemblies; }
+            set { 
+                if (value != null) {
+                    _AptcaVisibleAssemblies = (string[])value.Clone(); 
+                    Array.Sort<string>(_AptcaVisibleAssemblies, StringComparer.OrdinalIgnoreCase);
+                }
+                else {
+                    _AptcaVisibleAssemblies = null;
+                }
+            }
+        }
+#endif
+
+        public String ApplicationBase
+        {
+            #if FEATURE_CORECLR
+            [System.Security.SecurityCritical] // auto-generated
+            #else
+            [System.Security.SecuritySafeCritical]
+            #endif
+            [Pure]
+            get {
+                return VerifyDir(GetUnsecureApplicationBase(), false);
+            }
+
+            #if FEATURE_CORECLR
+            [System.Security.SecurityCritical] // auto-generated
+            #endif
+            set {
+                Value[(int) LoaderInformation.ApplicationBaseValue] = NormalizePath(value, false);
+            }
+        }
+
+        private String NormalizePath(String path, bool useAppBase)
+        {
+            if(path == null)
+                return null;
+
+            // If we add very long file name support ("\\?\") to the Path class then this is unnecesary,
+            // but we do not plan on doing this for now.
+
+            // Long path checks can be quirked, and as loading default quirks too early in the setup of an AppDomain is risky
+            // we'll avoid checking path lengths- we'll still fail at MAX_PATH later if we're !useAppBase when we call Path's
+            // NormalizePath.
+            if (!useAppBase)
+                path = Security.Util.URLString.PreProcessForExtendedPathRemoval(
+                    checkPathLength: false,
+                    url: path,
+                    isFileUrl: false);
+
+
+            int len = path.Length;
+            if (len == 0)
+                return null;
+
+#if !PLATFORM_UNIX
+            bool UNCpath = false;
+#endif // !PLATFORM_UNIX
+
+            if ((len > 7) &&
+                (String.Compare( path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0)) {
+                int trim;
+                
+                if (path[6] == '\\') {
+                    if ((path[7] == '\\') || (path[7] == '/')) {
+
+                        // Don't allow "file:\\\\", because we can't tell the difference
+                        // with it for "file:\\" + "\\server" and "file:\\\" + "\localpath"
+                        if ( (len > 8) && 
+                             ((path[8] == '\\') || (path[8] == '/')) )
+                            throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPathChars"));
+                        
+                        // file:\\\ means local path
+                        else
+#if !PLATFORM_UNIX
+                            trim = 8;
+#else
+                            // For Unix platform, trim the first 7 charcaters only.
+                            // Trimming the first 8 characters will cause
+                            // the root path separator to be trimmed away,
+                            // and the absolute local path becomes a relative local path.
+                            trim = 7;
+#endif // !PLATFORM_UNIX
+                    }
+
+                    // file:\\ means remote server
+                    else {
+                        trim = 5;
+#if !PLATFORM_UNIX
+                        UNCpath = true;
+#endif // !PLATFORM_UNIX
+                    }
+                }
+
+                // local path
+                else if (path[7] == '/')
+#if !PLATFORM_UNIX
+                    trim = 8;
+#else
+                    // For Unix platform, trim the first 7 characters only.
+                    // Trimming the first 8 characters will cause
+                    // the root path separator to be trimmed away,
+                    // and the absolute local path becomes a relative local path.
+                    trim = 7;
+#endif // !PLATFORM_UNIX
+
+                // remote
+                else {
+                    // file://\\remote
+                    if ( (len > 8) && (path[7] == '\\') && (path[8] == '\\') )
+                        trim = 7;
+                    else { // file://remote
+                        trim = 5;
+#if !PLATFORM_UNIX
+                        // Create valid UNC path by changing
+                        // all occurences of '/' to '\\' in path
+                        System.Text.StringBuilder winPathBuilder =
+                            new System.Text.StringBuilder(len);
+                        for (int i = 0; i < len; i++) {
+                            char c = path[i];
+                            if (c == '/')
+                                winPathBuilder.Append('\\');
+                            else
+                                winPathBuilder.Append(c);
+                        }
+                        path = winPathBuilder.ToString();
+#endif // !PLATFORM_UNIX
+                    }
+#if !PLATFORM_UNIX
+                    UNCpath = true;
+#endif // !PLATFORM_UNIX
+                }
+
+                path = path.Substring(trim);
+                len -= trim;
+            }
+
+#if !PLATFORM_UNIX
+            bool localPath;
+
+            // UNC
+            if (UNCpath ||
+                ( (len > 1) &&
+                  ( (path[0] == '/') || (path[0] == '\\') ) &&
+                  ( (path[1] == '/') || (path[1] == '\\') ) ))
+                localPath = false;
+
+            else {
+                int colon = path.IndexOf(':') + 1;
+
+                // protocol other than file:
+                if ((colon != 0) &&
+                    (len > colon+1) &&
+                    ( (path[colon] == '/') || (path[colon] == '\\') ) &&
+                    ( (path[colon+1] == '/') || (path[colon+1] == '\\') ))
+                    localPath = false;
+
+                else
+                    localPath = true;
+            }
+
+            if (localPath) 
+#else
+            if ( (len == 1) ||
+                 ( (path[0] != '/') && (path[0] != '\\') ) ) 
+#endif // !PLATFORM_UNIX
+            {
+
+                if (useAppBase &&
+                    ( (len == 1) || (path[1] != ':') )) {
+                    String appBase = Value[(int) LoaderInformation.ApplicationBaseValue];
+
+                    if ((appBase == null) || (appBase.Length == 0))
+                        throw new MemberAccessException(Environment.GetResourceString("AppDomain_AppBaseNotSet"));
+
+                    StringBuilder result = StringBuilderCache.Acquire();
+
+                    bool slash = false;
+                    if ((path[0] == '/') || (path[0] == '\\')) {
+                        string pathRoot = AppDomain.NormalizePath(appBase, fullCheck: false);
+                        pathRoot = pathRoot.Substring(0, IO.PathInternal.GetRootLength(pathRoot));
+
+                        if (pathRoot.Length == 0) { // URL
+                            int index = appBase.IndexOf(":/", StringComparison.Ordinal);
+                            if (index == -1)
+                                index = appBase.IndexOf(":\\", StringComparison.Ordinal);
+
+                            // Get past last slashes of "url:http://"
+                            int urlLen = appBase.Length;
+                            for (index += 1;
+                                 (index < urlLen) && ((appBase[index] == '/') || (appBase[index] == '\\'));
+                                 index++);
+
+                            // Now find the next slash to get domain name
+                            for(; (index < urlLen) && (appBase[index] != '/') && (appBase[index] != '\\');
+                                index++);
+
+                            pathRoot = appBase.Substring(0, index);
+                        }
+
+                        result.Append(pathRoot);
+                        slash = true;
+                    }
+                    else
+                        result.Append(appBase);
+
+                    // Make sure there's a slash separator (and only one)
+                    int aLen = result.Length - 1;
+                    if ((result[aLen] != '/') &&
+                        (result[aLen] != '\\')) {
+                        if (!slash) {
+#if !PLATFORM_UNIX
+                            if (appBase.IndexOf(":/", StringComparison.Ordinal) == -1)
+                                result.Append('\\');
+                            else
+#endif // !PLATFORM_UNIX
+                                result.Append('/');
+                        }
+                    }
+                    else if (slash)
+                        result.Remove(aLen, 1);
+
+                    result.Append(path);
+                    path = StringBuilderCache.GetStringAndRelease(result);
+                }
+                else
+                    path = AppDomain.NormalizePath(path, fullCheck: true);
+            }
+
+            return path;
+        }
+
+        private bool IsFilePath(String path)
+        {
+#if !PLATFORM_UNIX
+            return (path[1] == ':') || ( (path[0] == '\\') && (path[1] == '\\') );
+#else
+            return (path[0] == '/');
+#endif // !PLATFORM_UNIX
+        }
+
+        internal static String ApplicationBaseKey
+        {
+            get {
+                return ACTAG_APP_BASE_URL;
+            }
+        }
+
+        public String ConfigurationFile
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated
+            get {
+                return VerifyDir(Value[(int) LoaderInformation.ConfigurationFileValue], true);
+            }
+
+            set {
+                Value[(int) LoaderInformation.ConfigurationFileValue] = value;
+            }
+        }
+
+        // Used by the ResourceManager internally.  This must not do any 
+        // security checks to avoid infinite loops.
+        internal String ConfigurationFileInternal
+        {
+            get {
+                return NormalizePath(Value[(int) LoaderInformation.ConfigurationFileValue], true);
+            }
+        }
+
+        internal static String ConfigurationFileKey
+        {
+            get {
+                return ACTAG_APP_CONFIG_FILE;
+            }
+        }
+
+        public byte[] GetConfigurationBytes()
+        {
+            if (_ConfigurationBytes == null)
+                return null;
+
+            return (byte[]) _ConfigurationBytes.Clone();
+        }
+
+        public void SetConfigurationBytes(byte[] value)
+        {
+            _ConfigurationBytes = value;
+        }
+
+        private static String ConfigurationBytesKey
+        {
+            get {
+                return ACTAG_APP_CONFIG_BLOB;
+            }
+        }
+
+        // only needed by AppDomain.Setup(). Not really needed by users. 
+        internal Dictionary<string, object> GetCompatibilityFlags()
+        {
+            return _CompatFlags;
+        }
+
+        public void SetCompatibilitySwitches(IEnumerable<String> switches)
+        {
+
+#if !FEATURE_CORECLR
+            if(_AppDomainSortingSetupInfo != null)
+            {
+                _AppDomainSortingSetupInfo._useV2LegacySorting = false;
+                _AppDomainSortingSetupInfo._useV4LegacySorting = false;
+            }
+#endif
+
+#if FEATURE_RANDOMIZED_STRING_HASHING
+            _UseRandomizedStringHashing = false;
+#endif
+            if (switches != null)
+            {
+                _CompatFlags = new Dictionary<string, object>();
+                foreach (String str in switches) 
+                {
+#if !FEATURE_CORECLR
+                    if(StringComparer.OrdinalIgnoreCase.Equals("NetFx40_Legacy20SortingBehavior", str)) {
+                        if(_AppDomainSortingSetupInfo == null)
+                        {
+                            _AppDomainSortingSetupInfo = new AppDomainSortingSetupInfo();
+                        }
+                        _AppDomainSortingSetupInfo._useV2LegacySorting = true;
+                    }
+
+                    if(StringComparer.OrdinalIgnoreCase.Equals("NetFx45_Legacy40SortingBehavior", str)) {
+                        if(_AppDomainSortingSetupInfo == null)
+                        {
+                            _AppDomainSortingSetupInfo = new AppDomainSortingSetupInfo();
+                        }
+                        _AppDomainSortingSetupInfo._useV4LegacySorting = true;
+                    }
+#endif
+
+#if FEATURE_RANDOMIZED_STRING_HASHING
+                    if(StringComparer.OrdinalIgnoreCase.Equals("UseRandomizedStringHashAlgorithm", str)) {
+                        _UseRandomizedStringHashing = true;
+                    }
+#endif
+
+                    _CompatFlags.Add(str, null);
+                }
+            }
+            else
+            {
+                _CompatFlags = null;
+            }
+
+        }
+
+        // A target Framework moniker, in a format parsible by the FrameworkName class.
+        public String TargetFrameworkName {
+            get {
+                return _TargetFrameworkName;
+            }
+            set {
+                _TargetFrameworkName = value;
+            }
+        }
+
+        internal bool CheckedForTargetFrameworkName
+        {
+            get { return _CheckedForTargetFrameworkName; }
+            set { _CheckedForTargetFrameworkName = value; }
+        }
+
+#if !FEATURE_CORECLR
+        [SecurityCritical]
+        public void SetNativeFunction(string functionName, int functionVersion, IntPtr functionPointer) 
+        {
+            if(functionName == null) 
+            {
+                throw new ArgumentNullException("functionName");
+            }
+
+            if(functionPointer == IntPtr.Zero)
+            {
+                throw new ArgumentNullException("functionPointer");
+            }
+
+            if(String.IsNullOrWhiteSpace(functionName))
+            {
+                throw new ArgumentException(Environment.GetResourceString("Argument_NPMSInvalidName"), "functionName");
+            }
+
+            Contract.EndContractBlock();
+
+            if(functionVersion < 1)
+            {
+                throw new ArgumentException(Environment.GetResourceString("ArgumentException_MinSortingVersion", 1, functionName));
+            }
+
+            if(_AppDomainSortingSetupInfo == null)
+            {
+                _AppDomainSortingSetupInfo = new AppDomainSortingSetupInfo();
+            }
+
+            if(String.Equals(functionName, "IsNLSDefinedString", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnIsNLSDefinedString = functionPointer;
+            }
+
+            if (String.Equals(functionName, "CompareStringEx", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnCompareStringEx = functionPointer;
+            }
+
+            if (String.Equals(functionName, "LCMapStringEx", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnLCMapStringEx = functionPointer;
+            }
+
+            if (String.Equals(functionName, "FindNLSStringEx", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnFindNLSStringEx = functionPointer;
+            }
+
+            if (String.Equals(functionName, "CompareStringOrdinal", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnCompareStringOrdinal = functionPointer;
+            }
+
+            if (String.Equals(functionName, "GetNLSVersionEx", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnGetNLSVersionEx = functionPointer;
+            }
+
+            if (String.Equals(functionName, "FindStringOrdinal", StringComparison.OrdinalIgnoreCase))
+            {
+                _AppDomainSortingSetupInfo._pfnFindStringOrdinal = functionPointer;
+            }
+        }
+#endif
+
+        public String DynamicBase
+        {
+            [System.Security.SecuritySafeCritical]  // auto-generated
+            get {
+                return VerifyDir(Value[(int) LoaderInformation.DynamicBaseValue], true);
+            }
+
+            [System.Security.SecuritySafeCritical]  // auto-generated
+            set {
+                if (value == null)
+                    Value[(int) LoaderInformation.DynamicBaseValue] = null;
+                else {
+                    if(ApplicationName == null)
+                        throw new MemberAccessException(Environment.GetResourceString("AppDomain_RequireApplicationName"));
+                    
+                    StringBuilder s = new StringBuilder( NormalizePath(value, false) );
+                    s.Append('\\');
+                    string h = ParseNumbers.IntToString(ApplicationName.GetLegacyNonRandomizedHashCode(),
+                                                        16, 8, '0', ParseNumbers.PrintAsI4);
+                    s.Append(h);
+                    
+                    Value[(int) LoaderInformation.DynamicBaseValue] = s.ToString();
+                }
+            }
+        }
+
+        internal static String DynamicBaseKey
+        {
+            get {
+                return ACTAG_APP_DYNAMIC_BASE;
+            }
+        }
+
+
+        public bool DisallowPublisherPolicy
+        {
+            get 
+            {
+                return (Value[(int) LoaderInformation.DisallowPublisherPolicyValue] != null);
+            }
+            set
+            {
+                if (value)
+                    Value[(int) LoaderInformation.DisallowPublisherPolicyValue]="true";
+                else
+                    Value[(int) LoaderInformation.DisallowPublisherPolicyValue]=null;
+            }
+        }
+
+
+        public bool DisallowBindingRedirects
+        {
+            get 
+            {
+                return (Value[(int) LoaderInformation.DisallowBindingRedirectsValue] != null);
+            }
+            set
+            {
+                if (value)
+                    Value[(int) LoaderInformation.DisallowBindingRedirectsValue] = "true";
+                else
+                    Value[(int) LoaderInformation.DisallowBindingRedirectsValue] = null;
+            }
+        }
+
+        public bool DisallowCodeDownload
+        {
+            get 
+            {
+                return (Value[(int) LoaderInformation.DisallowCodeDownloadValue] != null);
+            }
+            set
+            {
+                if (value)
+                    Value[(int) LoaderInformation.DisallowCodeDownloadValue] = "true";
+                else
+                    Value[(int) LoaderInformation.DisallowCodeDownloadValue] = null;
+            }
+        }
+
+
+        public bool DisallowApplicationBaseProbing
+        {
+            get 
+            {
+                return (Value[(int) LoaderInformation.DisallowAppBaseProbingValue] != null);
+            }
+            set
+            {
+                if (value)
+                    Value[(int) LoaderInformation.DisallowAppBaseProbingValue] = "true";
+                else
+                    Value[(int) LoaderInformation.DisallowAppBaseProbingValue] = null;
+            }
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private String VerifyDir(String dir, bool normalize)
+        {
+            if (dir != null) {
+                if (dir.Length == 0)
+                    dir = null;
+                else {
+                    if (normalize)
+                        dir = NormalizePath(dir, true);
+
+                // The only way AppDomainSetup is exposed in coreclr is through the AppDomainManager 
+                // and the AppDomainManager is a SecurityCritical type. Also, all callers of callstacks 
+                // leading from VerifyDir are SecurityCritical. So we can remove the Demand because 
+                // we have validated that all callers are SecurityCritical
+#if !FEATURE_CORECLR
+                    if (IsFilePath(dir))
+                        new FileIOPermission( FileIOPermissionAccess.PathDiscovery, dir ).Demand();
+#endif // !FEATURE_CORECLR
+                }
+            }
+
+            return dir;
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        private void VerifyDirList(String dirs)
+        {
+            if (dirs != null) {
+                String[] dirArray = dirs.Split(';');
+                int len = dirArray.Length;
+                
+                for (int i = 0; i < len; i++)
+                    VerifyDir(dirArray[i], true);
+            }
+        }
+
+        internal String DeveloperPath
+        {
+            [System.Security.SecurityCritical]  // auto-generated
+            get {
+                String dirs = Value[(int) LoaderInformation.DevPathValue];
+                VerifyDirList(dirs);
+                return dirs;
+            }
+
+            set {
+                if(value == nul