CodeAccessPermission.Intersect(IPermission) Metodo

Definizione

Spazio dei nomi:

System.Security

Assembly:

System.Security.Permissions.dll

Assembly:

mscorlib.dll

Quando è implementato da una classe derivata, crea e restituisce un'autorizzazione costituita dall'intersezione dell'autorizzazione corrente e dell'autorizzazione specificata.

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

Parametri

target

IPermission

Autorizzazione da intersecare con quella corrente. Deve essere dello stesso tipo dell'autorizzazione corrente.

Restituisce

IPermission

Nuova autorizzazione che rappresenta l'intersezione dell'autorizzazione corrente e di quella specificata. La nuova autorizzazione è null se l'intersezione è vuota.

Implementazioni

Intersect(IPermission)

Eccezioni

ArgumentException

Il parametro target non è null e non è un'istanza della stessa classe dell'autorizzazione corrente.

Esempio

Nell'esempio Intersect di codice seguente viene illustrato un override del metodo. Questo esempio di codice fa parte di un esempio più grande fornito per 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

Commenti

L'intersezione di due autorizzazioni è un'autorizzazione che descrive il set di operazioni descritte in comune. Solo una richiesta che supera entrambe le autorizzazioni originali passerà l'intersezione.

Note per gli implementatori

È necessario eseguire l'override di questo metodo in una classe derivata.