CodeAccessPermission.Intersect(IPermission) Methode

Definition

Bewirkt, dass bei der Implementierung durch eine abgeleitete Klasse eine Berechtigung, die die Schnittmenge der aktuellen Berechtigung und der angegebenen Berechtigung darstellt, erstellt und zurückgegeben wird.

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

Parameter

target
IPermission

Eine Berechtigung für die Überschneidung mit der aktuellen Berechtigung. Sie muss denselben Typ aufweisen wie die aktuelle Berechtigung.

Gibt zurück

Eine neue Berechtigung, die die Schnittmenge der aktuellen und der angegebenen Berechtigung darstellt. Diese neue Berechtigung ist null, wenn die Schnittmenge leer ist.

Implementiert

Ausnahmen

Der target-Parameter ist nicht null und keine Instanz derselben Klasse wie die aktuelle Berechtigung.

Beispiele

Das folgende Codebeispiel zeigt eine Überschreibung der Intersect -Methode. Dieses Codebeispiel ist Teil eines größeren Beispiels, das für die CodeAccessPermission-Klasse bereitgestellt wird.

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

Hinweise

Die Schnittmenge von zwei Berechtigungen ist eine Berechtigung, die den Satz von Vorgängen beschreibt, die beide gemeinsam beschreiben. Nur eine Anforderung, die beide ursprünglichen Berechtigungen übergibt, übergibt die Schnittmenge.

Hinweise für Ausführende

Sie müssen diese Methode in einer abgeleiteten Klasse überschreiben.

Gilt für: