FirstMatchCodeGroup Clase

Definición

Espacio de nombres:

System.Security.Policy

Ensamblado:

System.Security.Permissions.dll

Ensamblado:

mscorlib.dll

Precaución

This type is obsolete. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Precaución

This type is obsolete. See https://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Precaución

Code Access Security is not supported or honored by the runtime.

Precaución

This type is obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.

Permite definir la directiva de seguridad mediante la unión de la instrucción de directiva de un grupo de código y la del primer grupo de código secundario coincidente. Esta clase no puede heredarse.

C#

[System.Obsolete("This type is obsolete. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public sealed class FirstMatchCodeGroup : System.Security.Policy.CodeGroup

C#

[System.Obsolete("This type is obsolete. See https://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public sealed class FirstMatchCodeGroup : System.Security.Policy.CodeGroup

C#

[System.Obsolete("Code Access Security is not supported or honored by the runtime.")]
public sealed class FirstMatchCodeGroup : System.Security.Policy.CodeGroup

C#

[System.Serializable]
public sealed class FirstMatchCodeGroup : System.Security.Policy.CodeGroup

C#

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class FirstMatchCodeGroup : System.Security.Policy.CodeGroup

C#

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Obsolete("This type is obsolete and will be removed in a future release of the .NET Framework. See http://go.microsoft.com/fwlink/?LinkID=155570 for more information.")]
public sealed class FirstMatchCodeGroup : System.Security.Policy.CodeGroup

Herencia

Object

CodeGroup

FirstMatchCodeGroup

Atributos

ObsoleteAttribute SerializableAttribute ComVisibleAttribute

Ejemplos

En el ejemplo siguiente se muestra el uso de miembros de la FirstMatchCodeGroup clase .

C#

using System;
using System.Security;
using System.Security.Policy;
using System.Security.Permissions;
using System.Reflection;

class Members
{
    [STAThread]
    static void Main(string[] args)
    {
        // Create a new FirstMatchCodeGroup.
        FirstMatchCodeGroup codeGroup = constructDefaultGroup();

        // Create a deep copy of the FirstMatchCodeGroup.
        FirstMatchCodeGroup copyCodeGroup = 
            (FirstMatchCodeGroup)codeGroup.Copy();
        // Compare the original code group with the copy.
        CompareTwoCodeGroups(codeGroup, copyCodeGroup);

        addPolicy(ref codeGroup);
        addXmlMember(ref codeGroup);
        updateMembershipCondition(ref codeGroup);
        addChildCodeGroup(ref codeGroup);

        Console.Write("Comparing the resolved code group ");
        Console.WriteLine("with the initial code group.");
        FirstMatchCodeGroup resolvedCodeGroup =
            ResolveGroupToEvidence(codeGroup);
        if (CompareTwoCodeGroups(codeGroup, resolvedCodeGroup))
        {
            PrintCodeGroup(resolvedCodeGroup);
        }
        else
        {
            PrintCodeGroup(codeGroup);
        }
        
        Console.WriteLine("This sample completed successfully; " +
            "press Enter to exit.");
        Console.ReadLine();
    }

    // Create a FirstMatchCodeGroup with an exclusive policy and membership
    // condition.
    private static FirstMatchCodeGroup constructDefaultGroup()
    {
        // Construct a new FirstMatchCodeGroup with Read, Write, Append
        // and PathDiscovery access.
        // Create read access permission to the root directory on drive C.
        FileIOPermission rootFilePermissions =
            new FileIOPermission(PermissionState.None);
        rootFilePermissions.AllLocalFiles = FileIOPermissionAccess.Read;
        rootFilePermissions.SetPathList(FileIOPermissionAccess.Read,"C:\\");

        // Add a permission to a named permission set.
        NamedPermissionSet namedPermissions =
            new NamedPermissionSet("RootPermissions");
        namedPermissions.AddPermission(rootFilePermissions);

        // Create a PolicyStatement with exclusive rights to the policy.
        PolicyStatement policy = new PolicyStatement(
            namedPermissions,PolicyStatementAttribute.Exclusive);

        // Create a FirstMatchCodeGroup with a membership condition that
        // matches all code, and an exclusive policy.
        FirstMatchCodeGroup codeGroup =
            new FirstMatchCodeGroup(
            new AllMembershipCondition(),
            policy);

        // Set the name of the first match code group.
        codeGroup.Name = "TempCodeGroup";

        // Set the description of the first match code group.
        codeGroup.Description = "Temp folder permissions group";

        return codeGroup;
    }

    // Add file permission to restrict write access to all files 
    // on the local machine.
    private static void addPolicy(ref FirstMatchCodeGroup codeGroup)
    {
        // Set the PolicyStatement property to a policy with read access to
        // the root directory on drive C.
        FileIOPermission rootFilePermissions =
            new FileIOPermission(PermissionState.None);
        rootFilePermissions.AllLocalFiles = FileIOPermissionAccess.Read;
        rootFilePermissions.SetPathList(FileIOPermissionAccess.Read,"C:\\");

        NamedPermissionSet namedPermissions =
            new NamedPermissionSet("RootPermissions");
        namedPermissions.AddPermission(rootFilePermissions);

        // Create a PolicyStatement with exclusive rights to the policy.
        PolicyStatement policy = new PolicyStatement(
            namedPermissions,
            PolicyStatementAttribute.Exclusive);

        codeGroup.PolicyStatement = policy;
    }

    // Set the membership condition of the code group.
    private static void updateMembershipCondition(
        ref FirstMatchCodeGroup codeGroup)
    {
        // Set the membership condition of the specified FirstMatchCodeGroup
        // to the Intranet zone.
        ZoneMembershipCondition zoneCondition =
            new ZoneMembershipCondition(SecurityZone.Intranet);
        codeGroup.MembershipCondition = zoneCondition;
    }

    // Create a child code group with read-access file permissions and add it
    // to the specified code group.
    private static void addChildCodeGroup(ref FirstMatchCodeGroup codeGroup)
    {
        // Create a first match code group with read access.
        FileIOPermission rootFilePermissions = 
            new FileIOPermission(PermissionState.None);
        rootFilePermissions.AllLocalFiles = FileIOPermissionAccess.Read;
        rootFilePermissions.SetPathList(FileIOPermissionAccess.Read,"C:\\");

        PermissionSet permissions =
            new PermissionSet(PermissionState.Unrestricted);
        permissions.AddPermission(rootFilePermissions);

        FirstMatchCodeGroup tempFolderCodeGroup = new FirstMatchCodeGroup(
            new AllMembershipCondition(), 
            new PolicyStatement(permissions));

        // Set the name of the child code group and add it to 
        // the specified code group.
        tempFolderCodeGroup.Name = "Read-only code group";
        codeGroup.AddChild(tempFolderCodeGroup);
    }

    // Compare the two FirstMatchCodeGroups.
    private static bool CompareTwoCodeGroups(
        FirstMatchCodeGroup firstCodeGroup, 
        FirstMatchCodeGroup secondCodeGroup)
    {
        // Compare the two specified FirstMatchCodeGroups for equality.
        if (firstCodeGroup.Equals(secondCodeGroup))
        {
            Console.WriteLine("The two code groups are equal.");
            return true;
        }
        else 
        {
            Console.WriteLine("The two code groups are not equal.");
            return false;
        }
    }

    // Retrieve the resolved policy based on executing evidence found 
    // in the specified code group.
    private static string ResolveEvidence(CodeGroup codeGroup)
    {
        string policyString = "None";

        // Resolve the policy based on the executing assembly's evidence.
        Assembly assembly = typeof(Members).Assembly;
        Evidence executingEvidence = assembly.Evidence;

        PolicyStatement policy = codeGroup.Resolve(executingEvidence);

        if (policy != null)
        {
            policyString = policy.ToString();
        }

        return policyString;
    }

    // Retrieve the resolved code group based on the evidence from the 
    // specified code group.
    private static FirstMatchCodeGroup ResolveGroupToEvidence(
        FirstMatchCodeGroup codeGroup)
    {
        // Resolve matching code groups to the executing assembly.
        Assembly assembly = typeof(Members).Assembly;
        Evidence evidence = assembly.Evidence;
        CodeGroup resolvedCodeGroup = 
            codeGroup.ResolveMatchingCodeGroups(evidence);

        return (FirstMatchCodeGroup)resolvedCodeGroup;
    }

    // If a domain attribute is not found in the specified 
    // FirstMatchCodeGroup, add a child XML element identifying a custom
    // membership condition.
    private static void addXmlMember(ref FirstMatchCodeGroup codeGroup)
    {
        SecurityElement xmlElement = codeGroup.ToXml();

        SecurityElement rootElement = new SecurityElement("CodeGroup");

        if (xmlElement.Attribute("domain") == null) 
        {
            SecurityElement newElement = 
                new SecurityElement("CustomMembershipCondition");
            newElement.AddAttribute("class","CustomMembershipCondition");
            newElement.AddAttribute("version","1");
            newElement.AddAttribute("domain","contoso.com");

            rootElement.AddChild(newElement);

            codeGroup.FromXml(rootElement);
        }

        Console.WriteLine("Added a custom membership condition:");
        Console.WriteLine(rootElement.ToString());
    }

    // Print the properties of the specified code group to the console.
    private static void PrintCodeGroup(CodeGroup codeGroup)
    {
        // Compare the type of the specified object with the
        // FirstMatchCodeGroup type.
        if (!codeGroup.GetType().Equals(typeof(FirstMatchCodeGroup)))
        {
            throw new ArgumentException(
                "Expected the FirstMatchCodeGroup type.");
        }
        
        string codeGroupName = codeGroup.Name;
        string membershipCondition = codeGroup.MembershipCondition.ToString();
        string permissionSetName = codeGroup.PermissionSetName;

        int hashCode = codeGroup.GetHashCode();

        string mergeLogic = "";
        if (codeGroup.MergeLogic.Equals("First Match"))
        {
            mergeLogic = "with first-match merge logic";
        }

        // Retrieve the class path for the FirstMatchCodeGroup.
        string firstMatchGroupClass = codeGroup.ToString();

        string attributeString = "";
        // Retrieve the string representation of the FirstMatchCodeGroup's
        // attributes.
        if (codeGroup.AttributeString != null)
        {
            attributeString = codeGroup.AttributeString;
        }

        // Write a summary to the console window.
        Console.WriteLine("\n*** " + firstMatchGroupClass + " summary ***");
        Console.Write("A FirstMatchCodeGroup named ");
        Console.Write(codeGroupName + mergeLogic);
        Console.Write(" has been created with hash code(" + hashCode + ").");
        Console.Write("\nThis code group contains a " + membershipCondition);
        Console.Write(" membership condition with the ");
        Console.WriteLine(permissionSetName + " permission set.");

        Console.Write("The code group contains the following policy: ");
        Console.Write(ResolveEvidence(codeGroup));
        Console.Write("\nIt also contains the following attributes: ");
        Console.WriteLine(attributeString);

        int childCount = codeGroup.Children.Count;
        if (childCount > 0 )
        {
            Console.Write("There are " + childCount);
            Console.WriteLine(" child elements in the code group.");

            // Iterate through the child code groups to display their names
            // and then remove them from the specified code group.
            for (int i=0; i < childCount; i++)
            {
                // Retrieve a child code group, which has been cast as a
                // FirstMatchCodeGroup type.
                FirstMatchCodeGroup childCodeGroup = 
                    (FirstMatchCodeGroup)codeGroup.Children[i];

                Console.Write("Removing the " + childCodeGroup.Name + ".");
                // Remove the child code group.
                codeGroup.RemoveChild(childCodeGroup);
            }

            Console.WriteLine();
        }
        else
        {
            Console.WriteLine(" No child code groups were found in this" + 
                " code group.");
        }
    }
}
//
// This sample produces the following output:
//
// The two code groups are equal.
// Added a custom membership condition:
//   <CustomMembershipCondition class="CustomMembershipCondition"
//                              version="1"
//                              domain="contoso.com"/>
//
// Comparing the resolved code group with the initial code group.
// The two code groups are not equal.
//
// *** System.Security.Policy.FirstMatchCodeGroup summary ***
// A FirstMatchCodeGroup named with first-match merge logic has been created
// with hash code(113151525).
// This code group contains a Zone - Intranet membership condition with the 
// permission set. The code group contains the following policy: 
// It also contains the following attributes:
// There are 1 child elements in the code group.
// Removing the Read-only code group.
// This sample completed successfully; press Enter to exit.

Comentarios

Los grupos de código son los bloques de creación de la directiva de seguridad de acceso de código. Cada nivel de directiva consta de un grupo de código raíz que puede tener grupos de código secundarios. Cada grupo de código secundario puede tener sus propios grupos de código secundarios; este comportamiento se extiende a cualquier número de niveles, formando un árbol. Cada grupo de código tiene una condición de pertenencia que determina si un ensamblado determinado pertenece a él en función de la evidencia de ese ensamblado. Solo los grupos de código cuyas condiciones de pertenencia coinciden con un ensamblado determinado y sus grupos de código secundarios aplican la directiva.

Al igual que cualquier grupo de código, FirstMatchCodeGroup solo se aplica cuando su condición de pertenencia coincide con la evidencia de un ensamblado. Si hay una coincidencia, comprueba la condición de pertenencia de cada elemento secundario en orden y se detiene cuando se produce la primera coincidencia. El resultado de FirstMatchCodeGroup es la unión de la instrucción policy del grupo de código raíz y la instrucción policy del primer grupo secundario de ese grupo de código que coincide.

FirstMatchCodeGroup está pensado para que los hosts de dominio de aplicación usen mediante programación para establecer la directiva de dominio.

Constructores

FirstMatchCodeGroup(IMembershipCondition, PolicyStatement)

Inicializa una nueva instancia de la clase FirstMatchCodeGroup.

Propiedades

AttributeString	Obtiene una representación en forma de cadena de los atributos de la instrucción de directiva del grupo de código. (Heredado de CodeGroup)
Children	Obtiene o establece una lista ordenada de los grupos de código secundarios de un grupo de código. (Heredado de CodeGroup)
Description	Obtiene o establece la descripción del grupo de código. (Heredado de CodeGroup)
MembershipCondition	Obtiene o establece la condición de pertenencia del grupo de código. (Heredado de CodeGroup)
MergeLogic	Obtiene la lógica de combinación.
Name	Obtiene o establece el nombre del grupo de código. (Heredado de CodeGroup)
PermissionSetName	Obtiene el nombre del conjunto de permisos con nombre del grupo de código. (Heredado de CodeGroup)
PolicyStatement	Obtiene o establece la instrucción de directiva asociada al grupo de código. (Heredado de CodeGroup)

Métodos

AddChild(CodeGroup)	Agrega un grupo de código secundario al grupo de código actual. (Heredado de CodeGroup)
Copy()	Realiza una copia profunda del código de grupo.
CreateXml(SecurityElement, PolicyLevel)	Cuando se reemplaza en una clase derivada, serializa las propiedades y el estado interno específico de un grupo de código derivado y agrega la serialización al SecurityElement especificado. (Heredado de CodeGroup)
Equals(CodeGroup, Boolean)	Determina si el grupo de código especificado es equivalente al grupo de código actual, comprobando también los grupos de código secundarios, si se especifican. (Heredado de CodeGroup)
Equals(Object)	Determina si el grupo de código especificado es equivalente al grupo de código actual. (Heredado de CodeGroup)
FromXml(SecurityElement)	Reconstruye un objeto de seguridad con un estado dado a partir de codificación XML. (Heredado de CodeGroup)
FromXml(SecurityElement, PolicyLevel)	Reconstruye un objeto de seguridad con un estado y un nivel de directiva dados a partir de codificación XML. (Heredado de CodeGroup)
GetHashCode()	Obtiene el código hash del grupo de código actual. (Heredado de CodeGroup)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ParseXml(SecurityElement, PolicyLevel)	Cuando se reemplaza en una clase derivada, reconstruye las propiedades y el estado interno específico de un grupo de código derivado del SecurityElement especificado. (Heredado de CodeGroup)
RemoveChild(CodeGroup)	Quita el grupo de código secundario especificado. (Heredado de CodeGroup)
Resolve(Evidence)	Resuelve la directiva del grupo de código y sus descendientes para un conjunto de pruebas.
ResolveMatchingCodeGroups(Evidence)	Revuelve los grupos de código coincidentes.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
ToXml()	Crea una codificación XML del objeto de seguridad y su estado actual. (Heredado de CodeGroup)
ToXml(PolicyLevel)	Crea una codificación XML del objeto de seguridad, de su estado actual y del nivel de directiva donde está incluido el código. (Heredado de CodeGroup)

Se aplica a