CodeAccessPermission.Intersect(IPermission) Metoda

Definicja

Przestrzeń nazw:

System.Security

Zestaw:

System.Security.Permissions.dll

Pakiet:

System.Security.Permissions v9.0.0-preview.3.24172.9

Źródło:

CodeAccessPermission.cs

Po zaimplementowaniu przez klasę pochodną tworzy i zwraca uprawnienie, które jest przecięciem bieżącego uprawnienia i określonym uprawnieniem.

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

Parametry

target

IPermission

Uprawnienie do przecinania z bieżącym uprawnieniem. Musi być tego samego typu co bieżące uprawnienie.

Zwraca

IPermission

Nowe uprawnienie, które reprezentuje przecięcie bieżącego uprawnienia i określonego uprawnienia. To nowe uprawnienie jest null takie, jeśli skrzyżowanie jest puste.

Implementuje

Intersect(IPermission)

Wyjątki

ArgumentException

Parametr target nie null jest i nie jest wystąpieniem tej samej klasy co bieżące uprawnienie.

Przykłady

Poniższy przykład kodu przedstawia przesłonięcia Intersect metody . Ten przykład kodu jest częścią większego przykładu podanego CodeAccessPermission dla klasy.

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

Uwagi

Przecięcie dwóch uprawnień to uprawnienie opisujące wspólny zestaw operacji opisanych w obu tych operacjach. Tylko żądanie, które przechodzi oba oryginalne uprawnienia, przejdzie skrzyżowanie.

Uwagi dotyczące implementowania

Tę metodę należy zastąpić w klasie pochodnej.