Type.IsContextfulImpl Méthode

protected:
 virtual bool IsContextfulImpl();

protected virtual bool IsContextfulImpl ();

abstract member IsContextfulImpl : unit -> bool
override this.IsContextfulImpl : unit -> bool

Protected Overridable Function IsContextfulImpl () As Boolean

Retours

Boolean

true si Type peut être hébergé dans un contexte ; sinon, false.

Exemples

L’exemple suivant illustre une utilisation de la IsContextfulImpl méthode.

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 );
   }
}

using System;
using System.Reflection;
public class MyTypeDelegatorClass : TypeDelegator
{
    public string myElementType = null;
    private Type myType = null ;

    public MyTypeDelegatorClass(Type myType) : base(myType)
    {
        this.myType = myType;
    }
    // Override IsContextfulImpl.
    protected override bool IsContextfulImpl()
    {
        // Check whether the type is contextful.
        if(myType.IsContextful)
        {
            myElementType = " is contextful ";
            return true;
        }
        return false;
    }
}
public class MyTypeDemoClass
{
    public static void Main()
    {
        try
        {
            MyTypeDelegatorClass myType;
            Console.WriteLine ("Check whether MyContextBoundClass can be hosted in a context.");
            // Check whether MyContextBoundClass is contextful.
            myType = new MyTypeDelegatorClass(typeof(MyContextBoundClass));
            if( myType.IsContextful)
            {
                Console.WriteLine(typeof(MyContextBoundClass) + " can be hosted in a context.");
            }
            else
            {
                Console.WriteLine(typeof(MyContextBoundClass) + " cannot be hosted in a context.");
            }
            // Check whether the int type is contextful.
            myType = new MyTypeDelegatorClass(typeof(MyTypeDemoClass));
            Console.WriteLine ("\nCheck whether MyTypeDemoClass can be hosted in a context.");
            if( myType.IsContextful)
            {
                Console.WriteLine(typeof(MyTypeDemoClass) + " can be hosted in a context.");
            }
            else
            {
                Console.WriteLine(typeof(MyTypeDemoClass) + " cannot be hosted in a context.");
            }
        }
        catch( Exception e )
        {
            Console.WriteLine("Exception: {0}", e.Message);
        }
    }
}
// This class demonstrates IsContextfulImpl.
public class MyContextBoundClass : ContextBoundObject
{
    public string myString = "This class is used to demonstrate members of the Type class.";
}

Imports System.Reflection

Public Class MyTypeDelegatorClass
    Inherits TypeDelegator
    Public myElementType As String = Nothing
    Private myType As Type = Nothing
    Public Sub New(ByVal myType As Type)
        MyBase.New(myType)
        Me.myType = myType
    End Sub
    ' Override IsContextfulImpl.
    Protected Overrides Function IsContextfulImpl() As Boolean
        ' Check whether the type is contextful.
        If myType.IsContextful Then
            myElementType = " is contextful "
            Return True
        End If
        Return False
    End Function 'IsContextfulImpl
End Class
Public Class MyTypeDemoClass
    Public Shared Sub Main()
        Try
            Dim myType As MyTypeDelegatorClass
            Console.WriteLine("Check whether MyContextBoundClass can be hosted in a context.")
            ' Check whether MyContextBoundClass is contextful.
            myType = New MyTypeDelegatorClass(GetType(MyContextBoundClass))
            If myType.IsContextful Then
                Console.WriteLine(GetType(MyContextBoundClass).ToString() + " can be hosted in a context.")
            Else
                Console.WriteLine(GetType(MyContextBoundClass).ToString() + " cannot be hosted in a context.")
            End If
            ' Check whether the int type is contextful.
            myType = New MyTypeDelegatorClass(GetType(MyTypeDemoClass))
            Console.WriteLine(ControlChars.NewLine + "Check whether MyTypeDemoClass can be hosted in a context.")
            If myType.IsContextful Then
                Console.WriteLine(GetType(MyTypeDemoClass).ToString() + " can be hosted in a context.")
            Else
                Console.WriteLine(GetType(MyTypeDemoClass).ToString() + " cannot be hosted in a context.")
            End If
        Catch e As Exception
            Console.WriteLine("Exception: {0}", e.Message.ToString())
        End Try
    End Sub
End Class
' This class demonstrates the IsContextfulImpl method.
Public Class MyContextBoundClass
    Inherits ContextBoundObject
    Public myString As String = "This class is used to demonstrate members of the Type class."
End Class

Remarques

Cette méthode peut être substituée par une classe dérivée.

Un contexte intercepte les appels aux membres de la classe et applique les stratégies appliquées à la classe, telles que la synchronisation.

S’applique à

Voir aussi

• IsContextful