CodeAccessPermission.IsSubsetOf(IPermission) Metodo

Definizione

Spazio dei nomi:

System.Security

Assembly:

System.Security.Permissions.dll

Origine:

CodeAccessPermission.cs

Quando implementata da una classe derivata, determina se l'autorizzazione corrente è un sottoinsieme dell'autorizzazione specificata.

public abstract bool IsSubsetOf(System.Security.IPermission target);

Parametri

target

IPermission

Autorizzazione da testare per la relazione del subset. Questa autorizzazione deve essere dello stesso tipo di quella corrente.

Restituisce

Boolean

true se l'autorizzazione corrente è un subset di quella specificata; in caso contrario, false.

Implementazioni

IsSubsetOf(IPermission)

Eccezioni

ArgumentException

Il parametro target non è null e non è dello stesso tipo dell'autorizzazione corrente.

Esempio

Nell'esempio di codice seguente viene illustrato un override del IsSubsetOf metodo . Questo esempio di codice fa parte di un esempio più ampio fornito per la CodeAccessPermission classe .

        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));
            }
        }

Commenti

L'autorizzazione corrente è un subset dell'autorizzazione specificata se l'autorizzazione corrente specifica un set di operazioni interamente contenute nell'autorizzazione specificata. Ad esempio, un'autorizzazione che rappresenta l'accesso a C:\example.txt è un subset di un'autorizzazione che rappresenta l'accesso a C:\. Se questo metodo restituisce true, l'autorizzazione corrente non rappresenta più l'accesso alla risorsa protetta rispetto all'autorizzazione specificata.

Per tutte le sostituzioni del IsSubsetOf metodo sono necessarie true le istruzioni seguenti. X, Y e Z rappresentano oggetti di autorizzazione di 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 un PermissionState oggetto .None

• X. IsSubsetOf(X) restituisce 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.

• Se X. IsSubsetOf(Y) e Y. IsSubsetOf(Z) restituiscono trueentrambi , X. IsSubsetOf(Z) restituisce true.

• X. IsSubsetOf(U) restituisce true.

• X. IsSubsetOf(N) restituisce false.

• N. IsSubsetOf(X) restituisce true.

Se X e Y rappresentano oggetti di autorizzazione di accesso al codice personalizzati che sono riferimenti Null, X. IsSubsetOf(Y) restituisce true. Se Z è anche Null, l'operazione di set composto X. Union(Y). IsSubsetOf(Z) restituisce true anche perché l'unione di due autorizzazioni Null è un'autorizzazione Null.

Note per gli implementatori

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