FileCodeGroup Clase

Definición

Espacio de nombres:

System.Security.Policy

Ensamblado:

System.Security.Permissions.dll

Paquete:

System.Security.Permissions v9.0.0-rc.2.24473.5

Source:

FileCodeGroup.cs

Precaución

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

Concede permiso para manipular archivos ubicados en los ensamblados de código a ensamblados de código que coinciden con la condición de pertenencia. Esta clase no se puede heredar.

C#

[System.Obsolete("Code Access Security is not supported or honored by the runtime.", DiagnosticId="SYSLIB0003", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public sealed class FileCodeGroup : System.Security.Policy.CodeGroup

Herencia

Object

CodeGroup

FileCodeGroup

Atributos

ObsoleteAttribute

Ejemplos

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

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)
    {
        FileCodeGroup fileCodeGroup = constructDefaultGroup();
        
        // Create a deep copy of the FileCodeGroup.
        FileCodeGroup copyCodeGroup = (FileCodeGroup)fileCodeGroup.Copy();

        CompareTwoCodeGroups(fileCodeGroup, copyCodeGroup);

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

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

    // Construct a new FileCodeGroup with Read, Write, Append 
    // and PathDiscovery access.
    private static FileCodeGroup constructDefaultGroup()
    {
        // Construct a new file code group that has complete access to
        // files in the specified path.
        FileCodeGroup fileCodeGroup = 
            new FileCodeGroup(
            new AllMembershipCondition(),
            FileIOPermissionAccess.AllAccess);

        // Set the name of the file code group.
        fileCodeGroup.Name = "TempCodeGroup";

        // Set the description of the file code group.
        fileCodeGroup.Description = "Temp folder permissions group";

        // Retrieve the string representation of the  fileCodeGroup’s 
        // attributes. FileCodeGroup does not use AttributeString, so the
        // value should be null.
        if (fileCodeGroup.AttributeString != null)
        {
            throw new NullReferenceException(
                "The AttributeString property should be null.");
        }

        return fileCodeGroup;
    }

    // Add file permission to restrict write access to all files on the
    // local machine.
    private static void addPolicy(ref FileCodeGroup fileCodeGroup)
    {
        // Set the PolicyStatement property to a policy with read access to
        // the root directory of 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);
        
        fileCodeGroup.PolicyStatement =
            new PolicyStatement(namedPermissions);
    }

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

    // Add a child group with read-access file permission to the specified 
    // code group.
    private static void addChildCodeGroup(ref FileCodeGroup fileCodeGroup)
    {
        // Create a file code group with read-access permission.
        FileCodeGroup tempFolderCodeGroup = new FileCodeGroup(
            new AllMembershipCondition(), 
            FileIOPermissionAccess.Read);

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

    // Compare the two specified file code groups for equality.
    private static bool CompareTwoCodeGroups(
        FileCodeGroup firstCodeGroup, FileCodeGroup secondCodeGroup)
    {
        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 Evidence from the executing 
    // assembly found in the specified code group.
    private static string ResolveEvidence(CodeGroup fileCodeGroup)
    {
        string policyString = "";

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

        PolicyStatement policy = fileCodeGroup.Resolve(executingEvidence);

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

        return policyString;
    }

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

        return (FileCodeGroup)codeGroup;
    }

    // If a domain attribute is not found in the specified FileCodeGroup,
    // add a child XML element identifying a custom membership condition.
    private static void addXmlMember(ref FileCodeGroup fileCodeGroup)
    {
        SecurityElement xmlElement = fileCodeGroup.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);

            fileCodeGroup.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 FileCodeGroup
        // type.
        if (!codeGroup.GetType().Equals(typeof(FileCodeGroup)))
        {
            throw new ArgumentException("Expected the FileCodeGroup type.");
        }
        
        string codeGroupName = codeGroup.Name;
        string membershipCondition = codeGroup.MembershipCondition.ToString();
        string permissionSetName = codeGroup.PermissionSetName;

        int hashCode = codeGroup.GetHashCode();

        string mergeLogic = "";
        if (codeGroup.MergeLogic.Equals("Union"))
        {
            mergeLogic = " with Union merge logic";
        }

        // Retrieve the class path for FileCodeGroup.
        string fileGroupClass = codeGroup.ToString();

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

        Console.Write("The code group has the following security policy: ");
        Console.WriteLine(ResolveEvidence(codeGroup));

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

            // Iterate through the child code groups to display their names
            // and remove them from the specified code group.
            for (int i=0; i < childCount; i++)
            {
                // Get child code group as type FileCodeGroup.
                FileCodeGroup childCodeGroup = 
                    (FileCodeGroup)codeGroup.Children[i];
                
                Console.Write("Removing the " + childCodeGroup.Name + ".");
                // Remove child code group.
                codeGroup.RemoveChild(childCodeGroup);
            }

            Console.WriteLine();
        }
        else
        {
            Console.Write("There are no child code groups");
            Console.WriteLine(" 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.FileCodeGroup summary ***
// A FileCodeGroup named  with Union merge logic has been created with hash
// code 113151473. This code group contains a Zone - Intranet membership
// condition with the Same directory FileIO - NoAccess permission set. The
// code group has the following security policy:
// There are 1 child code groups in this code group.
// Removing the Read-only group.
// This sample completed successfully; press Enter to exit.

Comentarios

Advertencia

La seguridad de acceso al código (CAS) está en desuso en todas las versiones de .NET Framework y .NET. Las versiones recientes de .NET no respetan las anotaciones cas y producen errores si se usan las API relacionadas con CAS. Los desarrolladores deben buscar medios alternativos para realizar tareas de seguridad.

Los grupos de código son los bloques de creación de la directiva de seguridad de acceso al 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.

FileCodeGroup tiene la misma semántica de coincidencia secundaria que UnionCodeGroup. Sin embargo, FileCodeGroup devuelve un conjunto de permisos que contiene un FileIOPermission calculado dinámicamente que concede acceso de archivo al directorio desde el que se ejecuta el código; UnionCodeGroup solo devuelve un conjunto de permisos estático. El tipo de acceso a archivos concedido se pasa como parámetro al constructor.

Este grupo de código solo coincide con los ensamblados que se ejecutan a través de un protocolo de archivo, es decir, los ensamblados que tienen direcciones URL que apuntan a un archivo o una ruta de acceso UNC.

Constructores

FileCodeGroup(IMembershipCondition, FileIOPermissionAccess)

Obsoletos. Inicializa una nueva instancia de la clase FileCodeGroup.

Propiedades

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

Métodos

AddChild(CodeGroup)	Obsoletos. Agrega un grupo de código secundario al grupo de código actual. (Heredado de CodeGroup)
Copy()	Obsoletos. Realiza una copia profunda del grupo de código actual.
CreateXml(SecurityElement, PolicyLevel)	Obsoletos. Cuando se reemplaza en una clase derivada, serializa las propiedades y el estado interno específicos de un grupo de código derivado y agrega la serialización al SecurityElementespecificado. (Heredado de CodeGroup)
Equals(CodeGroup, Boolean)	Obsoletos. 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 especifica. (Heredado de CodeGroup)
Equals(Object)	Obsoletos. Determina si el grupo de código especificado es equivalente al grupo de código actual.
FromXml(SecurityElement, PolicyLevel)	Obsoletos. Reconstruye un objeto de seguridad con un estado y nivel de directiva determinado a partir de una codificación XML. (Heredado de CodeGroup)
FromXml(SecurityElement)	Obsoletos. Reconstruye un objeto de seguridad con un estado determinado a partir de una codificación XML. (Heredado de CodeGroup)
GetHashCode()	Obsoletos. Obtiene el código hash del grupo de código actual.
GetType()	Obsoletos. Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Obsoletos. Crea una copia superficial del Objectactual. (Heredado de Object)
ParseXml(SecurityElement, PolicyLevel)	Obsoletos. Cuando se reemplaza en una clase derivada, reconstruye las propiedades y el estado interno específicos de un grupo de código derivado del SecurityElementespecificado. (Heredado de CodeGroup)
RemoveChild(CodeGroup)	Obsoletos. Quita el grupo de código secundario especificado. (Heredado de CodeGroup)
Resolve(Evidence)	Obsoletos. Resuelve la directiva para el grupo de código y sus descendientes para un conjunto de evidencias.
ResolveMatchingCodeGroups(Evidence)	Obsoletos. Resuelve los grupos de código coincidentes.
ToString()	Obsoletos. Devuelve una cadena que representa el objeto actual. (Heredado de Object)
ToXml()	Obsoletos. Crea una codificación XML del objeto de seguridad y su estado actual. (Heredado de CodeGroup)
ToXml(PolicyLevel)	Obsoletos. Crea una codificación XML del objeto de seguridad, su estado actual y el nivel de directiva en el que existe el código. (Heredado de CodeGroup)

Se aplica a