Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/mscorlib/system/marshalbyrefobject.cs

@@ -0,0 +1,265 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+/*============================================================
+**
+** File:    MarshalByRefObject.cs
+**
+**              
+**
+** Purpose: Defines the root type for all marshal by reference aka
+**          AppDomain bound types
+**          
+**
+**
+===========================================================*/
+namespace System {
+    
+    using System;
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Threading;
+    using System.Runtime.Remoting;
+#if FEATURE_REMOTING    
+    using System.Runtime.Remoting.Lifetime;
+    using System.Runtime.Remoting.Services;
+#endif
+    using System.Runtime.InteropServices;
+    using System.Reflection;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Versioning;
+    using System.Diagnostics.Contracts;
+    using CultureInfo = System.Globalization.CultureInfo;
+
+    [Serializable]
+[System.Runtime.InteropServices.ComVisible(true)]
+    public abstract class MarshalByRefObject 
+    {
+#if FEATURE_REMOTING    
+        private Object __identity;        
+
+        private Object Identity { get { return __identity; } set { __identity = value; } }        
+#if FEATURE_COMINTEROP
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        internal IntPtr GetComIUnknown(bool fIsBeingMarshalled)
+        {
+            IntPtr pUnk;
+            if(RemotingServices.IsTransparentProxy(this))
+            {
+                pUnk = RemotingServices.GetRealProxy(this).GetCOMIUnknown(fIsBeingMarshalled);
+            }
+            else
+            {
+                pUnk = Marshal.GetIUnknownForObject(this);
+            }
+            return pUnk;
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [ResourceExposure(ResourceScope.None)]
+        internal static extern IntPtr GetComIUnknown(MarshalByRefObject o);
+#endif // FEATURE_COMINTEROP
+
+        // (1) for remote COM objects IsInstance of can't be executed on
+        // the proxies, so we need this method to be executed on the 
+        // actual object.
+        // (2) for remote objects that do not have the complete type information
+        // we intercept calls to check the type and execute it on the actual
+        // object
+        internal bool IsInstanceOfType(Type T)
+        {
+            return T.IsInstanceOfType(this);
+        }
+
+        // for remote COM Objects the late binding methods can't be
+        // executed on proxies, so we need this method to execute on
+        // the real object
+        internal Object InvokeMember(String name,BindingFlags invokeAttr,Binder binder, 
+                            Object[] args,ParameterModifier[] modifiers,CultureInfo culture,String[] namedParameters)
+        {
+            Type t = GetType();
+            
+            // Sanity check
+            if(!t.IsCOMObject)
+                throw new InvalidOperationException(Environment.GetResourceString("Arg_InvokeMember"));
+
+            // Call into the runtime to invoke on the COM object.
+            return t.InvokeMember(name, invokeAttr, binder, this, args, modifiers, culture, namedParameters);
+        }
+
+        // Returns a new cloned MBR instance that is a memberwise copy of this 
+        // with the identity nulled out, so there are no identity conflicts
+        // when the cloned object is marshalled
+        protected MarshalByRefObject MemberwiseClone(bool cloneIdentity)
+        {
+            MarshalByRefObject mbr = (MarshalByRefObject)base.MemberwiseClone();
+            // set the identity on the cloned object to null
+            if (!cloneIdentity)
+                mbr.Identity = null;
+            return mbr;
+        }
+
+
+        
+        // A helper routine to extract the identity either from the marshalbyrefobject base
+        // class if it is not a proxy, otherwise from the real proxy.
+        // A flag is set to indicate whether the object passed in is a server or a proxy
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        internal static Identity GetIdentity(MarshalByRefObject obj, out bool fServer)
+        {
+            fServer = true;
+            Identity id = null;
+
+            if(null != obj)
+            {
+                if(!RemotingServices.IsTransparentProxy(obj))
+                {
+                    id = (Identity)obj.Identity;
+                }
+                else
+                {                    
+                    // Toggle flag to indicate that we have a proxy
+                    fServer = false;
+                    id = RemotingServices.GetRealProxy(obj).IdentityObject;
+                }
+            }
+
+            return id;
+        }
+
+        // Another helper that delegates to the helper above
+        internal static Identity GetIdentity(MarshalByRefObject obj)
+        {
+            Contract.Assert(!RemotingServices.IsTransparentProxy(obj), "Use this method for server objects only");
+
+            bool fServer;            
+            return GetIdentity(obj, out fServer);
+        }
+
+       
+        internal ServerIdentity __RaceSetServerIdentity(ServerIdentity id)
+        {
+            if (__identity == null)
+            {
+                // For strictly MBR types, the TP field in the identity
+                // holds the real server
+                if (!id.IsContextBound)
+                {
+                    id.RaceSetTransparentProxy(this);
+                }
+                Interlocked.CompareExchange(ref __identity, id, null);
+            }
+            return (ServerIdentity)__identity;
+        }
+
+
+        internal void __ResetServerIdentity()
+        {
+            __identity = null;
+        }
+        
+       // This method is used return a lifetime service object which
+       // is used to control the lifetime policy to the object.
+       // For the default Lifetime service this will be an object of typoe ILease.
+       // 
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public Object GetLifetimeService()
+        {
+            return LifetimeServices.GetLease(this); 
+        }
+
+       // This method is used return lifetime service object. This method
+       // can be overridden to return a LifetimeService object with properties unique to
+       // this object.
+       // For the default Lifetime service this will be an object of type ILease.
+       // 
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public virtual Object InitializeLifetimeService()
+        {
+            return LifetimeServices.GetLeaseInitial(this);
+        }
+
+        [System.Security.SecurityCritical]  // auto-generated_required
+        public virtual ObjRef CreateObjRef(Type requestedType)
+        {
+            if(__identity == null)
+            {
+                throw new RemotingException(Environment.GetResourceString(
+                    "Remoting_NoIdentityEntry"));
+            }            
+            return new ObjRef(this, requestedType);
+        }
+
+        // This is for casting interop ObjRefLite's.
+        // ObjRefLite's have been deprecated. These methods are not exposed 
+        // through any user APIs and would be removed in the future
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        internal bool CanCastToXmlType(String xmlTypeName, String xmlTypeNamespace)
+        {
+            Type castType = SoapServices.GetInteropTypeFromXmlType(xmlTypeName, xmlTypeNamespace);
+            if (castType == null)
+            {
+                String typeNamespace;
+                String assemblyName;
+                if (!SoapServices.DecodeXmlNamespaceForClrTypeNamespace(xmlTypeNamespace, 
+                        out typeNamespace, out assemblyName))
+                    return false;
+
+                String typeName;
+                if ((typeNamespace != null) && (typeNamespace.Length > 0))
+                    typeName = typeNamespace + "." + xmlTypeName;
+                else
+                    typeName = xmlTypeName;
+
+                try
+                {
+                    Assembly asm = Assembly.Load(assemblyName);
+                    castType = asm.GetType(typeName, false, false);
+                }
+                catch 
+                {
+                    return false;
+                }
+            }
+
+            if (castType != null)
+                return castType.IsAssignableFrom(this.GetType());
+
+            return false;
+        } // CanCastToXmlType
+
+        // helper method for calling CanCastToXmlType
+        // ObjRefLite's have been deprecated. These methods are not exposed 
+        // through any user APIs and would be removed in the future
+        [System.Security.SecuritySafeCritical]  // auto-generated
+        internal static bool CanCastToXmlTypeHelper(RuntimeType castType, MarshalByRefObject o)
+        {
+            if (castType == null)
+                throw new ArgumentNullException("castType");
+        
+            Contract.EndContractBlock();
+            // MarshalByRefObject's can only be casted to MarshalByRefObject's or interfaces.
+            if (!castType.IsInterface && !castType.IsMarshalByRef)
+                return false;
+
+            // figure out xml type name
+            String xmlTypeName = null;
+            String xmlTypeNamespace = null;
+            if (!SoapServices.GetXmlTypeForInteropType(castType, out xmlTypeName, out xmlTypeNamespace))
+            {
+                // There's no registered interop type name, so just use the default.
+                xmlTypeName = castType.Name;
+                xmlTypeNamespace =
+                    SoapServices.CodeXmlNamespaceForClrTypeNamespace(
+                        castType.Namespace, castType.GetRuntimeAssembly().GetSimpleName());
+            }
+
+            return o.CanCastToXmlType(xmlTypeName, xmlTypeNamespace);
+        } // CanCastToXmlType
+
+#endif // FEATURE_REMOTING
+    }            
+} // namespace