MarshalByRefObject.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / MarshalByRefObject.cs / 1305376 / MarshalByRefObject.cs

                            // ==++== 
//
//   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 
        [System.Security.SecuritySafeCritical]  // auto-generated 
        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 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK