Partager via


CodeAccessPermission.Intersect(IPermission) Méthode

Définition

Lors de l'implémentation par une classe dérivée, crée et retourne une autorisation qui est l'intersection de l'autorisation en cours et de l'autorisation spécifiée.

public:
 abstract System::Security::IPermission ^ Intersect(System::Security::IPermission ^ target);
public abstract System.Security.IPermission Intersect (System.Security.IPermission target);
abstract member Intersect : System.Security.IPermission -> System.Security.IPermission
Public MustOverride Function Intersect (target As IPermission) As IPermission

Paramètres

target
IPermission

Autorisation à croiser avec l’autorisation actuelle. Elle doit être du même type que l’autorisation actuelle.

Retours

Nouvelle autorisation qui représente l’intersection entre l’autorisation actuelle et l’autorisation spécifiée. Cette nouvelle autorisation est null si l’intersection est vide.

Implémente

Exceptions

Le paramètre target n’a pas la valeur null et n’est pas une instance de la même classe que l’autorisation actuelle.

Exemples

L’exemple de code suivant montre un remplacement de la Intersect méthode . Cet exemple de code fait partie d’un exemple plus grand fourni pour la CodeAccessPermission classe .

public:
   virtual IPermission^ Intersect( IPermission^ target ) override
   {
      Console::WriteLine( "************* Entering Intersect *********************" );
      if ( target == nullptr )
      {
         return nullptr;
      }

#if ( debug ) 
      Console::WriteLine( "This is = {0}", ((NameIdPermission)this).Name );
      Console::WriteLine( "Target is {0}", ((NameIdPermission)target).m_Name );
#endif 

      if (  !VerifyType( target ) )
      {
         throw gcnew ArgumentException( String::Format( "Argument is wrong type.", this->GetType()->FullName ) );
      }

      NameIdPermission^ operand = dynamic_cast<NameIdPermission^>(target);

      if ( operand->IsSubsetOf( this ) )
      {
         return operand->Copy();
      }
      else if ( this->IsSubsetOf( operand ) )
      {
         return this->Copy();
      }
      else
      {
         return nullptr;
      }
   }
        public override IPermission Intersect(IPermission target)
        {
            Console.WriteLine ("************* Entering Intersect *********************");
            if (target == null)
            {
                return null;
            }
#if(debug)
            Console.WriteLine ("This is = " + (( NameIdPermission)this).Name);
            Console.WriteLine ("Target is " + (( NameIdPermission)target).m_Name);
#endif
            if (!VerifyType(target))
            {
                throw new ArgumentException (String.Format ("Argument is wrong type.", this.GetType ().FullName));
            }

             NameIdPermission operand = ( NameIdPermission)target;

            if (operand.IsSubsetOf (this)) return operand.Copy ();
            else if (this.IsSubsetOf (operand)) return this.Copy ();
            else
                return null;
        }
        Public Overrides Function Intersect(ByVal target As IPermission) As IPermission
            Console.WriteLine("************* Entering Intersect *********************")
            If target Is Nothing Then
                Return Nothing
            End If
#If (Debug) Then

            Console.WriteLine(("This is = " + CType(Me, NameIdPermission).Name))
            Console.WriteLine(("Target is " + CType(target, NameIdPermission).m_name))
#End If
            If Not VerifyType(target) Then
                Throw New ArgumentException(String.Format("Argument is wrong type.", Me.GetType().FullName))
            End If

            Dim operand As NameIdPermission = CType(target, NameIdPermission)

            If operand.IsSubsetOf(Me) Then
                Return operand.Copy()
            ElseIf Me.IsSubsetOf(operand) Then
                Return Me.Copy()
            Else
                Return Nothing
            End If
        End Function 'Intersect

Remarques

L’intersection de deux autorisations est une autorisation qui décrit l’ensemble des opérations qu’elles décrivent toutes deux en commun. Seule une demande qui passe les deux autorisations d’origine passe l’intersection.

Notes pour les responsables de l’implémentation

Vous devez remplacer cette méthode dans une classe dérivée.

S’applique à