Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Evidence (Clase)

Define el conjunto de información que constituye la entrada a las decisiones de las directivas de seguridad. Esta clase no puede heredarse.

System.Object
  System.Security.Policy.Evidence

Espacio de nombres:  System.Security.Policy
Ensamblado:  mscorlib (en mscorlib.dll)

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

El tipo Evidence expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA FrameworkEvidence()Inicializa una nueva instancia vacía de la clase Evidence.
Método públicoEvidence(Evidence)Inicializa una nueva instancia de la clase Evidence a partir de una copia superficial de una existente.
Método públicoEvidence(EvidenceBase[], EvidenceBase[])Inicializa una nueva instancia de la clase Evidence a partir de varios conjuntos de evidencias de host y ensamblado.
Método públicoEvidence(Object[], Object[]) Obsoleta. Inicializa una nueva instancia de la clase Evidence a partir de varios conjuntos de evidencias de host y ensamblado.
Arriba

  NombreDescripción
Propiedad públicaCompatible con XNA FrameworkCount Obsoleta. Obtiene el número de objetos de evidencia del conjunto de evidencias.
Propiedad públicaIsReadOnlyObtiene un valor que indica si el conjunto de evidencias es de sólo lectura.
Propiedad públicaCompatible con XNA FrameworkIsSynchronizedObtiene un valor que indica si el conjunto de evidencias es seguro para la ejecución de subprocesos.
Propiedad públicaLockedObtiene o establece un valor que indica si la evidencia está bloqueada.
Propiedad públicaCompatible con XNA FrameworkSyncRootObtiene la raíz de sincronización.
Arriba

  NombreDescripción
Método públicoAddAssembly Obsoleta. Agrega la evidencia de ensamblado especificada al conjunto de evidencias.
Método públicoAddAssemblyEvidence<T>Agrega un objeto de evidencia del tipo especificado a la lista de evidencias proporcionada por el ensamblado.
Método públicoAddHost Obsoleta. Agrega la evidencia especificada proporcionada por el host al conjunto de evidencias.
Método públicoAddHostEvidence<T>Agrega evidencia de host del tipo especificado a la colección de evidencias de host.
Método públicoClearQuita las evidencias de host y ensamblado del conjunto de evidencias.
Método públicoCloneDevuelve una copia duplicada de este objeto de evidencia.
Método públicoCompatible con XNA FrameworkCopyTo Obsoleta. Copia objetos de evidencia a un objeto Array.
Método públicoCompatible con XNA FrameworkEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoGetAssemblyEnumeratorEnumera la evidencia proporcionada por el ensamblado.
Método públicoGetAssemblyEvidence<T>Obtiene la evidencia de ensamblado del tipo especificado de la colección.
Método públicoCompatible con XNA FrameworkGetEnumerator Obsoleta. Enumera todas las evidencias del conjunto, tanto las proporcionadas por el host como las proporcionadas por el ensamblado.
Método públicoCompatible con XNA FrameworkGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetHostEnumeratorEnumera la evidencia proporcionada por el host.
Método públicoGetHostEvidence<T>Obtiene la evidencia de host del tipo especificado de la colección.
Método públicoCompatible con XNA FrameworkGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoMergeCombina el conjunto de evidencias especificado con el conjunto de evidencias actual.
Método públicoRemoveTypeQuita de las enumeraciones de host y ensamblado las evidencias de un tipo determinado.
Método públicoCompatible con XNA FrameworkToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Arriba

  NombreDescripción
Método de extensión públicoAsParallelHabilita la paralelización de una consulta. (Definido por ParallelEnumerable).
Método de extensión públicoAsQueryableConvierte una interfaz IEnumerable en IQueryable. (Definido por Queryable).
Método de extensión públicoCompatible con XNA FrameworkCast<TResult>Convierte los elementos de IEnumerable en el tipo especificado. (Definido por Enumerable).
Método de extensión públicoCompatible con XNA FrameworkOfType<TResult>Filtra los elementos de IEnumerable en función de un tipo especificado. (Definido por Enumerable).
Arriba

Los formularios comunes de evidencias incluyen firmas y la ubicación de origen del código, pero podrían contener cualquier otra cosa. Los objetos de cualquier tipo reconocidos por una directiva de seguridad representan una evidencia.

La directiva de seguridad está formada por grupos de código; un ensamblado determinado (la unidad de código básica para conceder permisos de seguridad) pertenece a un grupo de código si satisface la condición de pertenencia del grupo. Una evidencia es el conjunto de entradas para la directiva utilizado por las condiciones de pertenencia para determinar a qué grupos de código pertenece un ensamblado.

La clase Evidence es una colección (vea ICollection) que contiene un conjunto de objetos que representan la evidencia. Esta clase contiene dos conjuntos que se corresponden con el origen de la evidencia: la evidencia de host y la evidencia de ensamblado.

La directiva puede obtener evidencias de dos fuentes distintas para evaluar los permisos del código.

  • Host evidence la proporciona el host, y sólo los host a los que se haya concedido el permiso ControlEvidence pueden proporcionarla. Normalmente, se trata de una evidencia del origen del código y de las firmas digitales del ensamblado. La evidencia acerca del origen suele incluir las evidencias Url, Site y Zone. Las firmas hacen referencia a la compañía de software (firma AuthentiCode X.509v3) y a las identidades de nombres seguros. Ambos tipos de identidades basadas en firmas digitales se incorporan en el ensamblado, pero el host debe validarlas y pasarlas a la directiva; cuando se cargan, el sistema de seguridad comprueba la firma. A continuación, el sistema crea la evidencia adecuada y la pasa a la directiva si la firma correspondiente es válida.

  • Assembly evidence forma parte del propio ensamblado. Los programadores o los administradores pueden asociar una evidencia personalizada al ensamblado para ampliar el conjunto de evidencias para la directiva. La evidencia del ensamblado sólo se puede agregar durante la generación del ensamblado, que se produce antes de que éste se firme. La directiva predeterminada del sistema de seguridad no tiene en cuenta la evidencia proporcionada por el ensamblado, pero puede ampliarse la directiva para que la acepte.

En el siguiente ejemplo de código se muestra cómo crear nuevas clases Evidence con evidencia de host y evidencia de ensamblado.



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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft