Export (0) Print
Expand All
Expand Minimize

Type.IsMarshalByRefImpl Method

Implements the IsMarshalByRef property and determines whether the Type is marshaled by reference.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

protected:
virtual bool IsMarshalByRefImpl ()
protected boolean IsMarshalByRefImpl ()
protected function IsMarshalByRefImpl () : boolean

Return Value

true if the Type is marshaled by reference; otherwise, false.

This method can be overridden by a derived class.

The following example determines whether the given type is marshaled by reference and displays the result.

using namespace System;
using namespace System::Reflection;
public ref class MyTypeDelegatorClass: public TypeDelegator
{
public:
   String^ myElementType;

private:
   Type^ myType;

public:
   MyTypeDelegatorClass( Type^ myType )
      : TypeDelegator( myType )
   {
      this->myType = myType;
   }

protected:

   // Override IsMarshalByRefImpl.
   virtual bool IsMarshalByRefImpl() override
   {
      // Determine whether the type is marshalled by reference.
      if ( myType->IsMarshalByRef )
      {
         myElementType = " marshalled by reference";
         return true;
      }

      return false;
   }
};

public ref class MyTypeDemoClass{};


// This class is used to demonstrate the IsMarshalByRefImpl method.
public ref class MyContextBoundClass: public ContextBoundObject
{
public:
   String^ myString;
};

int main()
{
   try
   {
      MyTypeDelegatorClass^ myType;
      Console::WriteLine( "Determine whether MyContextBoundClass is marshalled by reference." );
      
      // Determine whether MyContextBoundClass type is marshalled by reference.
      myType = gcnew MyTypeDelegatorClass( MyContextBoundClass::typeid );
      if ( myType->IsMarshalByRef )
      {
         Console::WriteLine( "{0} is marshalled by reference.", MyContextBoundClass::typeid );
      }
      else
      {
         Console::WriteLine( "{0} is not marshalled by reference.", MyContextBoundClass::typeid );
      }
      
      // Determine whether int type is marshalled by reference.
      myType = gcnew MyTypeDelegatorClass( int::typeid );
      Console::WriteLine( "\nDetermine whether int is marshalled by reference." );
      if ( myType->IsMarshalByRef )
      {
         Console::WriteLine( "{0} is marshalled by reference.", int::typeid );
      }
      else
      {
         Console::WriteLine( "{0} is not marshalled by reference.", int::typeid );
      }
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "Exception: {0}", e->Message );
   }
}

import System.*;
import System.Reflection.*;

public class MyTypeDelegatorClass extends TypeDelegator
{
    public String myElementType = null;
    private Type myType = null;

    public MyTypeDelegatorClass(Type myType)
    {
        super(myType);
        this.myType = myType;
    } //MyTypeDelegatorClass

    // Override IsMarshalByRefImpl.
    protected boolean IsMarshalByRefImpl()
    {
        // Determine whether the type is marshalled by reference.
        if (myType.get_IsMarshalByRef()) {
            myElementType = " marshalled by reference";
            return true;
        }
        return false;
    } //IsMarshalByRefImpl
} //MyTypeDelegatorClass

public class MyTypeDemoClass
{
    public static void main(String[] args)
    {
        try {
            MyTypeDelegatorClass myType;
            Console.WriteLine("Determine whether MyContextBoundClass is" 
                + " marshalled by reference.");
            // Determine whether MyContextBoundClass type is marshalled
            // by reference.
            myType = new MyTypeDelegatorClass(MyContextBoundClass.
                class.ToType());
            if (myType.get_IsMarshalByRef()) {
                Console.WriteLine(MyContextBoundClass.class.ToType() 
                    + " is marshalled by reference.");
            }
            else {
                Console.WriteLine(MyContextBoundClass.class.ToType() 
                    + " is not marshalled by reference.");
            }
            // Determine whether int type is marshalled by reference.
            myType = new MyTypeDelegatorClass(int.class.ToType());
            Console.WriteLine("\nDetermine whether int is marshalled by" 
                + " reference.");
            if (myType.get_IsMarshalByRef()) {
                Console.WriteLine(int.class.ToType() 
                    + " is marshalled by reference.");
            }
            else {
                Console.WriteLine(int.class.ToType() 
                    + " is not marshalled by reference.");
            }
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception: {0}", e.get_Message());
        }
    } //main
} //MyTypeDemoClass

// This class is used to demonstrate the IsMarshalByRefImpl method.
public class MyContextBoundClass extends ContextBoundObject
{
    public String myString = "This class is used to demonstrate members" 
        + " of the Type class.";
} //MyContextBoundClass

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0, 1.1, 1.0

Community Additions

ADD
Show:
© 2014 Microsoft