Type.IsContextfulImpl Method

Implements the IsContextful property and determines whether the Type can be hosted in a context.

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

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

Return Value

true if the Type can be hosted in a context; otherwise, false.

This method can be overridden by a derived class.

A context intercepts calls to the class members and enforce policies that are applied to the class, such as synchronization.

The following example demonstrates a use of the IsContextfulImpl method.

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 IsContextfulImpl.
   virtual bool IsContextfulImpl() override
   {
      
      // Check whether the type is contextful.
      if ( myType->IsContextful )
      {
         myElementType = " is contextful ";
         return true;
      }

      return false;
   }

};

public ref class MyTypeDemoClass{};


// This class demonstrates IsContextfulImpl.
public ref class MyContextBoundClass: public ContextBoundObject
{
public:
   String^ myString;
};

int main()
{
   try
   {
      MyTypeDelegatorClass^ myType;
      Console::WriteLine( "Check whether MyContextBoundClass can be hosted in a context." );
      
      // Check whether MyContextBoundClass is contextful.
      myType = gcnew MyTypeDelegatorClass( MyContextBoundClass::typeid );
      if ( myType->IsContextful )
      {
         Console::WriteLine( "{0} can be hosted in a context.", MyContextBoundClass::typeid );
      }
      else
      {
         Console::WriteLine( "{0} cannot be hosted in a context.", MyContextBoundClass::typeid );
      }
      myType = gcnew MyTypeDelegatorClass( MyTypeDemoClass::typeid );
      Console::WriteLine( "\nCheck whether MyTypeDemoClass can be hosted in a context." );
      if ( myType->IsContextful )
      {
         Console::WriteLine( "{0} can be hosted in a context.", MyTypeDemoClass::typeid );
      }
      else
      {
         Console::WriteLine( "{0} cannot be hosted in a context.", MyTypeDemoClass::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 IsContextfulImpl.
    protected boolean IsContextfulImpl()
    {
        // Check whether the type is contextful.
        if (myType.get_IsContextful()) {
            myElementType = " is contextful ";
            return true;
        }
        return false;
    } //IsContextfulImpl
} //MyTypeDelegatorClass

public class MyTypeDemoClass
{
    public static void main(String[] args)
    {
        try {
            MyTypeDelegatorClass myType;
            Console.WriteLine("Check whether MyContextBoundClass can be hosted"
                + " in a context.");
            // Check whether MyContextBoundClass is contextful.
            myType = new MyTypeDelegatorClass(MyContextBoundClass.class.ToType());
            if (myType.get_IsContextful()) {
                Console.WriteLine(MyContextBoundClass.class.ToType() 
                    + " can be hosted in a context.");
            }
            else {
                Console.WriteLine(MyContextBoundClass.class.ToType() 
                    + " cannot be hosted in a context.");
            }
            // Check whether the int type is contextful.
            myType = new MyTypeDelegatorClass(MyTypeDemoClass.class.ToType());
            Console.WriteLine("\nCheck whether MyTypeDemoClass can be hosted" 
                + " in a context.");
            if (myType.get_IsContextful()) {
                Console.WriteLine(MyTypeDemoClass.class.ToType() 
                    + " can be hosted in a context.");
            }
            else {
                Console.WriteLine(MyTypeDemoClass.class.ToType() 
                    + " cannot be hosted in a context.");
            }
        }
        catch (System.Exception e) {
            Console.WriteLine("Exception: {0}", e.get_Message());
        }
    } //main
} //MyTypeDemoClass

// This class demonstrates IsContextfulImpl.
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: