Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Evidence classe

 

Date de publication : novembre 2016

Définit le jeu d’informations qui alimente les décisions de stratégie de sécurité. Cette classe ne peut pas être héritée.

Espace de noms:   System.Security.Policy
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Security.Policy.Evidence

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class Evidence : ICollection, IEnumerable

NomDescription
System_CAPS_pubmethodEvidence()

Initialise une nouvelle instance vide de la Evidence classe.

System_CAPS_pubmethodEvidence(Evidence)

Initialise une nouvelle instance de la Evidence classe à partir d’une copie superficielle d’un existant.

System_CAPS_pubmethodEvidence(EvidenceBase[], EvidenceBase[])

Initialise une nouvelle instance de la Evidence classe à partir de plusieurs ensembles de preuves d’hôte et d’assembly.

System_CAPS_pubmethodEvidence(Object[], Object[])

Obsolète. Initialise une nouvelle instance de la Evidence classe à partir de plusieurs ensembles de preuves d’hôte et d’assembly.

NomDescription
System_CAPS_pubpropertyCount

Obsolète. Obtient le nombre d’objets de preuve dans l’ensemble de preuves.

System_CAPS_pubpropertyIsReadOnly

Obtient une valeur indiquant si l’ensemble de preuves est en lecture seule.

System_CAPS_pubpropertyIsSynchronized

Obtient une valeur indiquant si l’ensemble de preuves est thread-safe.

System_CAPS_pubpropertyLocked

Obtient ou définit une valeur indiquant si la preuve est verrouillée.

System_CAPS_pubpropertySyncRoot

Obtient la racine de synchronisation.

NomDescription
System_CAPS_pubmethodAddAssembly(Object)

Obsolète. Ajoute la preuve de l’assembly spécifié à l’ensemble de preuves.

System_CAPS_pubmethodAddAssemblyEvidence<T>(T)

Ajoute un objet de preuve du type spécifié à la liste de la preuve fournie par l’assembly.

System_CAPS_pubmethodAddHost(Object)

Obsolète. Ajoute la preuve spécifiée fournie par l’hôte pour l’ensemble de preuves.

System_CAPS_pubmethodAddHostEvidence<T>(T)

Ajoute la preuve d’hôte du type spécifié à la collection de preuves d’hôte.

System_CAPS_pubmethodClear()

Supprime la preuve d’hôte et d’assembly de l’ensemble de preuves.

System_CAPS_pubmethodClone()

Retourne une copie de cet objet de preuve.

System_CAPS_pubmethodCopyTo(Array, Int32)

Obsolète. Copie des objets de preuve un Array.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodGetAssemblyEnumerator()

Énumère les preuves fournies par l’assembly.

System_CAPS_pubmethodGetAssemblyEvidence<T>()

Obtient la preuve de l’assembly du type spécifié à partir de la collection.

System_CAPS_pubmethodGetEnumerator()

Obsolète. Énumère toutes les preuves dans le jeu, à la fois fourni par l’hôte et fournies par l’assembly.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetHostEnumerator()

Énumère les preuves fournies par l’hôte.

System_CAPS_pubmethodGetHostEvidence<T>()

Obtient la preuve d’hôte du type spécifié à partir de la collection.

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodMerge(Evidence)

Fusionne la preuve spécifiée dans l’ensemble de preuves actuel.

System_CAPS_pubmethodRemoveType(Type)

Supprime la preuve d’un type donné dans les énumérations d’hôtes et d’assemblys.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

NomDescription
System_CAPS_pubmethodAsParallel()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable()

Surchargé. Convertit un IEnumerable à un IQueryable.(Défini par Queryable.)

System_CAPS_pubmethodCast<TResult>()

Convertit les éléments d’un IEnumerable au type spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodOfType<TResult>()

Filtre les éléments d’un IEnumerable basé sur un type spécifié.(Défini par Enumerable.)

Formes courantes de preuves incluent des signatures et l’emplacement d’origine du code, mais peuvent être potentiellement quoi que ce soit. Objets de tout type qui sont reconnus par la stratégie de sécurité représentent une preuve.

Stratégie de sécurité est composée des groupes de codes ; un assembly particulier (l’unité de base du code pour accorder des autorisations de sécurité) est un membre d’un groupe de codes s’il satisfait la condition d’appartenance du groupe de codes. La preuve est l’ensemble des entrées à la stratégie que les conditions d’appartenance utilisent pour déterminer à quels groupes de codes un assembly appartient.

La Evidence classe est une collection (voir ICollection) qui contient un ensemble d’objets qui représentent la preuve. Cette classe conserve deux ensembles qui correspondent à la source de la preuve : hôte et assembly.

Stratégie peut obtenir une preuve à partir de deux sources différentes lors de l’évaluation des autorisations accordées au code.

  • Host evidence est fourni par l’hôte et ne peut être fournie par les hôtes qui ont reçu la ControlEvidence autorisation. En règle générale, il s’agit de la preuve de l’origine du code et des signatures numériques sur l’assembly. Une preuve à l’origine inclut généralement Url, Site, et Zone preuve. Les signatures font référence à l’éditeur de logiciel (signature AuthentiCode X.509v3) et l’identité de nom fort. Les deux types d’identité basé sur une signature numérique sont intégrées dans l’assembly, mais doivent être validés et transmis à la stratégie de l’ordinateur hôte ; lors du chargement, le système de sécurité vérifie la signature. Le système crée la preuve appropriée, puis passe à la stratégie que si la signature correspondante est valide.

  • Assembly evidence fait partie de l’assembly lui-même. Les développeurs ou les administrateurs peuvent attacher une preuve personnalisée à l’assembly pour étendre l’ensemble de preuves pour une stratégie. Preuve d’assembly peut uniquement être ajoutée au moment de la génération de l’assembly, qui se produit avant que l’assembly est signé. La stratégie par défaut du système de sécurité ignore les preuves fournies par l’assembly, mais elle peut être étendue pour l’accepter.

L’exemple de code suivant montre comment créer un nouveau Evidence avec les deux classes d’hôte et une preuve d’assembly.


using System;
using System.Collections;
using System.Security;
using System.Security.Policy;
using System.Security.Permissions;
using System.Globalization;

public class Evidence_Example
{
    public bool CreateEvidence()
    {
        bool retVal = true;

        try
        {
            // Create empty evidence using the default contructor.
            Evidence ev1 = new Evidence();
            Console.WriteLine("Created empty evidence with the default constructor.");

            // Constructor used to create null host evidence.
            Evidence ev2a = new Evidence(null);
            Console.WriteLine("Created an Evidence object with null host evidence.");

            // Constructor used to create host evidence.
            Url url = new Url("http://www.treyresearch.com");
            Console.WriteLine("Adding host evidence " + url.ToString());
            ev2a.AddHost(url);
            Evidence ev2b = new Evidence(ev2a);
            Console.WriteLine("Copy evidence into new evidence");
            IEnumerator enum1 = ev2b.GetHostEnumerator();
            enum1.MoveNext();
            Console.WriteLine(enum1.Current.ToString());

            // Constructor used to create both host and assembly evidence.
            Object [] oa1 = {};
            Site site = new Site("www.wideworldimporters.com");
            Object [] oa2 = { url, site };
            Evidence ev3a = new Evidence(oa1, oa2);
            enum1 = ev3a.GetHostEnumerator();
            IEnumerator enum2 = ev3a.GetAssemblyEnumerator();
            enum2.MoveNext();
            Object obj1 = enum2.Current;
            enum2.MoveNext();
            Console.WriteLine("URL = " + obj1.ToString() + "  Site = " + enum2.Current.ToString());

            // Constructor used to create null host and null assembly evidence.
            Evidence ev3b = new Evidence(null, null);
            Console.WriteLine("Create new evidence with null host and assembly evidence");

        }
        catch (Exception e)
        {
            Console.WriteLine("Fatal error: {0}", e.ToString());
            return false;
        }

        return retVal;
    }
    public Evidence DemonstrateEvidenceMembers()
    {
        Evidence myEvidence = new Evidence();
        string sPubKeyBlob =	"00240000048000009400000006020000" + 
            "00240000525341310004000001000100" + 
            "19390E945A40FB5730204A25FA5DC4DA" + 
            "B18688B412CB0EDB87A6EFC50E2796C9" + 
            "B41AD3040A7E46E4A02516C598678636" + 
            "44A0F74C39B7AB9C38C01F10AF4A5752" + 
            "BFBCDF7E6DD826676AD031E7BCE63393" + 
            "495BAD2CA4BE03B529A73C95E5B06BE7" + 
            "35CA0F622C63E8F54171BD73E4C8F193" + 
            "CB2664163719CA41F8159B8AC88F8CD3";
        Byte[] pubkey = HexsToArray(sPubKeyBlob);

        // Create a strong name.
        StrongName mSN = new StrongName(new StrongNamePublicKeyBlob(pubkey), "SN01", new Version("0.0.0.0"));

        // Create assembly and host evidence.
        Console.WriteLine("Adding assembly evidence.");
        myEvidence.AddAssembly("SN01");
        myEvidence.AddAssembly(new Version("0.0.0.0"));
        myEvidence.AddAssembly(mSN);
        Console.WriteLine("Count of evidence items = " + myEvidence.Count.ToString());
        Url url = new Url("http://www.treyresearch.com");
        Console.WriteLine("Adding host evidence " + url.ToString());
        myEvidence.AddHost(url);
        PrintEvidence(myEvidence).ToString();
        Console.WriteLine("Count of evidence items = " + myEvidence.Count.ToString());
        Console.WriteLine("\nCopy the evidence to an array using CopyTo, then display the array.");
        object[] evidenceArray = new object[myEvidence.Count];
        myEvidence.CopyTo(evidenceArray, 0);
        foreach (object obj in evidenceArray)
        {
            Console.WriteLine(obj.ToString());
        }
        Console.WriteLine("\nDisplay the contents of the properties.");
        Console.WriteLine("Locked is the only property normally used by code.");
        Console.WriteLine("IsReadOnly, IsSynchronized, and SyncRoot properties are not normally used.");
        Console.WriteLine("\nThe default value for the Locked property = " + myEvidence.Locked.ToString());

        Console.WriteLine("\nGet the hashcode for the evidence.");
        Console.WriteLine("HashCode = " + myEvidence.GetHashCode().ToString());
        Console.WriteLine("\nGet the type for the evidence.");
        Console.WriteLine("Type = " + myEvidence.GetType().ToString());
        Console.WriteLine("\nMerge new evidence with the current evidence.");
        Object [] oa1 = {};
        Site site = new Site("www.wideworldimporters.com");
        Object [] oa2 = { url, site };
        Evidence newEvidence = new Evidence(oa1, oa2);
        myEvidence.Merge(newEvidence);
        Console.WriteLine("Evidence count = " + PrintEvidence(myEvidence).ToString());
        Console.WriteLine("\nRemove URL evidence.");
        myEvidence.RemoveType(url.GetType());
        Console.WriteLine("Evidence count is now: " + myEvidence.Count.ToString());
        Console.WriteLine("\nMake a copy of the current evidence.");
        Evidence evidenceCopy = new Evidence(myEvidence);
        Console.WriteLine("Count of new evidence items = " + evidenceCopy.Count);
        Console.WriteLine("Does the copy equal the current evidence? " + myEvidence.Equals(evidenceCopy));
        Console.WriteLine("\nClear the current evidence.");
        myEvidence.Clear();
        Console.WriteLine("Count is now " + myEvidence.Count.ToString());
        return myEvidence;
    }
    public static int PrintEvidence(Evidence myEvidence)
    {
        int p = 0;
        Console.WriteLine("\nCurrent evidence = ");
        if (null == myEvidence) return 0;
        IEnumerator list = myEvidence.GetEnumerator();
        while (list.MoveNext())
        {
            Console.WriteLine(list.Current.ToString());
        }

        Console.WriteLine("\n");
        return p;
    }
    // Convert a hexidecimal string to an array.
    public static byte[] HexsToArray(string sHexString)
    {
        Byte[] array = new Byte[sHexString.Length/2];
        for (int i = 0; i < sHexString.Length; i += 2)
        {
            array[i / 2] = Byte.Parse(sHexString.Substring(i, 2), NumberStyles.HexNumber);
        }
        return array;
    }



    // Main method.
    public static void Main()
    {
        try
        {
            Evidence_Example EvidenceTest = new Evidence_Example();
            bool ret = EvidenceTest.CreateEvidence();
            if (ret)
            {
                Console.WriteLine("Evidence successfully created.");
            }
            else
            {
                Console.WriteLine("Evidence creation failed.");
            }

            EvidenceTest.DemonstrateEvidenceMembers();
        }
        catch(Exception e)
        {

            Console.WriteLine(e.ToString());
            Environment.ExitCode = 101;
        }
    }
}

.NET Framework
Disponible depuis 1.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: