CodeAccessPermission.IsSubsetOf(IPermission) Metodo

Definizione

Quando implementato da una classe derivata, determina se l'autorizzazione corrente è un subset di quella specificata.When implemented by a derived class, determines whether the current permission is a subset of the specified permission.

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

Parametri

target
IPermission

Autorizzazione da testare per la relazione del subset.A permission that is to be tested for the subset relationship. Questa autorizzazione deve essere dello stesso tipo di quella corrente.This permission must be of the same type as the current permission.

Restituisce

true se l'autorizzazione corrente è un subset di quella specificata; in caso contrario, false.true if the current permission is a subset of the specified permission; otherwise, false.

Implementazioni

Eccezioni

Il parametro target non è null e non è dello stesso tipo dell'autorizzazione corrente.The target parameter is not null and is not of the same type as the current permission.

Esempi

Nell'esempio di codice riportato di seguito viene illustrato un override del metodo IsSubsetOf.The following code example shows an override of the IsSubsetOf method. Questo esempio di codice fa parte di un esempio più ampio fornito per la classe CodeAccessPermission.This code example is part of a larger example provided for the CodeAccessPermission class.

public:
   virtual bool IsSubsetOf( IPermission^ target ) override
   {
#if ( debug ) 
      Console::WriteLine( "************* Entering IsSubsetOf *********************" );
#endif

      if ( target == nullptr )
      {
         Console::WriteLine( "IsSubsetOf: target == null" );
         return false;
      }

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

      try
      {
         NameIdPermission^ operand = dynamic_cast<NameIdPermission^>(target);
         
         // The following check for unrestricted permission is only included as an example for
         // permissions that allow the unrestricted state. It is of no value for this permission.
         if ( true == operand->m_Unrestricted )
         {
            return true;
         }
         else if ( true == this->m_Unrestricted )
         {
            return false;
         }

         if ( this->m_Name != nullptr )
         {
            if ( operand->m_Name == nullptr )
            {
               return false;
            }
            if ( this->m_Name->Equals( "" ) )
            {
               return true;
            }
         }

         if ( this->m_Name->Equals( operand->m_Name ) )
         {
            return true;
         }
         else
         {
            // Check for wild card character '*'.
            int i = operand->m_Name->LastIndexOf( "*" );

            if ( i > 0 )
            {
               String^ prefix = operand->m_Name->Substring( 0, i );
               if ( this->m_Name->StartsWith( prefix ) )
               {
                  return true;
               }
            }
         }
         return false;
      }
      catch ( InvalidCastException^ ) 
      {
         throw gcnew ArgumentException( String::Format( "Argument_WrongType", this->GetType()->FullName ) );
      }
   }
        public override bool IsSubsetOf(IPermission target)
        {
#if(debug)
            Console.WriteLine ("************* Entering IsSubsetOf *********************");
#endif
            if (target == null)
            {
                Console.WriteLine ("IsSubsetOf: target == null");
                return false;
            }
#if(debug)

            Console.WriteLine ("This is = " + (( NameIdPermission)this).Name);
            Console.WriteLine ("Target is " + (( NameIdPermission)target).m_Name);
#endif
            try
            {
                 NameIdPermission operand = ( NameIdPermission)target;

                // The following check for unrestricted permission is only included as an example for
                // permissions that allow the unrestricted state. It is of no value for this permission.
                if (true == operand.m_Unrestricted)
                {
                    return true;
                }
                else if (true == this.m_Unrestricted)
                {
                    return false;
                }

                if (this.m_Name != null)
                {
                    if (operand.m_Name == null) return false;

                    if (this.m_Name == "") return true;
                }

                if (this.m_Name.Equals (operand.m_Name))
                {
                    return true;
                }
                else
                {
                    // Check for wild card character '*'.
                    int i = operand.m_Name.LastIndexOf ("*");

                    if (i > 0)
                    {
                        string prefix = operand.m_Name.Substring (0, i);

                        if (this.m_Name.StartsWith (prefix))
                        {
                            return true;
                        }
                    }
                }

                return false;
            }
            catch (InvalidCastException)
            {
                throw new ArgumentException (String.Format ("Argument_WrongType", this.GetType ().FullName));
            }
        }
        Public Overrides Function IsSubsetOf(ByVal target As IPermission) As Boolean

#If (Debug) Then

            Console.WriteLine("************* Entering IsSubsetOf *********************")
#End If
            If target Is Nothing Then
                Console.WriteLine("IsSubsetOf: target == null")
                Return False
            End If
#If (Debug) Then
            Console.WriteLine(("This is = " + CType(Me, NameIdPermission).Name))
            Console.WriteLine(("Target is " + CType(target, NameIdPermission).m_name))
#End If
            Try
                Dim operand As NameIdPermission = CType(target, NameIdPermission)

                ' The following check for unrestricted permission is only included as an example for
                ' permissions that allow the unrestricted state. It is of no value for this permission.
                If True = operand.m_Unrestricted Then
                    Return True
                ElseIf True = Me.m_Unrestricted Then
                    Return False
                End If

                If Not (Me.m_name Is Nothing) Then
                    If operand.m_name Is Nothing Then
                        Return False
                    End If
                    If Me.m_name = "" Then
                        Return True
                    End If
                End If
                If Me.m_name.Equals(operand.m_name) Then
                    Return True
                Else
                    ' Check for wild card character '*'.
                    Dim i As Integer = operand.m_name.LastIndexOf("*")

                    If i > 0 Then
                        Dim prefix As String = operand.m_name.Substring(0, i)

                        If Me.m_name.StartsWith(prefix) Then
                            Return True
                        End If
                    End If
                End If

                Return False
            Catch
                Throw New ArgumentException(String.Format("Argument_WrongType", Me.GetType().FullName))
            End Try
        End Function

Commenti

L'autorizzazione corrente è un subset dell'autorizzazione specificata se l'autorizzazione corrente specifica un set di operazioni interamente contenute nell'autorizzazione specificata.The current permission is a subset of the specified permission if the current permission specifies a set of operations that is wholly contained by the specified permission. Ad esempio, un'autorizzazione che rappresenta l'accesso a C:\EXAMPLE.txt è un subset di un'autorizzazione che rappresenta l'accesso a C:\.For example, a permission that represents access to C:\example.txt is a subset of a permission that represents access to C:\. Se questo metodo restituisce true, l'autorizzazione corrente non rappresenta più l'accesso alla risorsa protetta rispetto all'autorizzazione specificata.If this method returns true, the current permission represents no more access to the protected resource than does the specified permission.

È necessario true le istruzioni seguenti per tutte le sostituzioni del metodo IsSubsetOf.The following statements are required to be true for all overrides of the IsSubsetOf method. X, Ye Z rappresentano oggetti di autorizzazione per l'accesso al codice personalizzati che non sono riferimenti null, U rappresenta un'autorizzazione di accesso al codice senza restrizioni e N rappresenta un'autorizzazione vuota con PermissionState di None.X, Y, and Z represent custom code access permission objects that are not null references, U represents an unrestricted code access permission, and N represents an empty permission with a PermissionState of None.

  • X. IsSubsetOf (X) restituisce true.X.IsSubsetOf(X) returns true.

  • X. IsSubsetOf (y) restituisce lo stesso valore di Y. IsSubsetOf (X) se e solo se X e Y rappresentano lo stesso set di autorizzazioni.X.IsSubsetOf(Y) returns the same value as Y.IsSubsetOf(X) if and only if X and Y represent the same set of permissions.

  • Se X. IsSubsetOf (y) e Y. IsSubsetOf (Z) restituisce true, X. IsSubsetOf (Z) restituisce true.If X.IsSubsetOf(Y) and Y.IsSubsetOf(Z) both return true, X.IsSubsetOf(Z) returns true.

  • X. IsSubsetOf (U) restituisce true.X.IsSubsetOf(U) returns true.

  • X. IsSubsetOf (N) restituisce false.X.IsSubsetOf(N) returns false.

  • N. IsSubsetOf (X) restituisce true.N.IsSubsetOf(X) returns true.

Se x e Y rappresentano oggetti di autorizzazione per l'accesso al codice personalizzati che sono riferimenti null, x. IsSubsetOf (Y) restituisce true.If X and Y represent custom code access permission objects that are null references, X.IsSubsetOf(Y) returns true. Se Z è anche null, l'operazione di set composto X. Union (Y). IsSubsetOf (Z) restituisce anche true perché l'Unione di due autorizzazioni null è un'autorizzazione null.If Z is also null, the compound set operation X.Union(Y).IsSubsetOf(Z) also returns true because the union of two null permissions is a null permission.

Note per gli implementatori

È necessario eseguire l'override di questo metodo in una classe derivata.You must override this method in a derived class.

Si applica a