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

SecurityElement (Clase)

Representa el modelo de objetos XML para codificar objetos de seguridad. Esta clase no puede heredarse.

System.Object
  System.Security.SecurityElement

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class SecurityElement

El tipo SecurityElement expone los siguientes miembros.

  NombreDescripción
Método públicoSecurityElement(String)Inicializa una nueva instancia de la clase SecurityElement con la etiqueta especificada.
Método públicoSecurityElement(String, String)Inicializa una nueva instancia de la clase SecurityElement con la etiqueta y el texto especificados.
Arriba

  NombreDescripción
Propiedad públicaAttributesObtiene o establece los atributos de un elemento XML como pares nombre/valor.
Propiedad públicaChildrenObtiene o establece la matriz de elementos secundarios del elemento XML.
Propiedad públicaTagObtiene o establece el nombre de etiqueta de un elemento XML.
Propiedad públicaTextObtiene o establece el texto dentro de un elemento XML.
Arriba

  NombreDescripción
Método públicoAddAttributeAgrega un atributo de nombre/valor a un elemento XML.
Método públicoAddChildAgrega un elemento secundario al elemento XML.
Método públicoAttributeBusca un atributo por su nombre en un elemento XML.
Método públicoCopyCrea y devuelve una copia idéntica del objeto SecurityElement actual.
Método públicoEqualCompara dos objetos de elementos XML para determinar si son iguales.
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método públicoMiembro estáticoEscapeReemplaza caracteres XML no válidos en una cadena por sus equivalentes válidos.
Método públicoMiembro estáticoFromStringCrea un elemento de seguridad a partir de una cadena codificada en XML.
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoMiembro estáticoIsValidAttributeNameDetermina si una cadena es un nombre de atributo válido.
Método públicoMiembro estáticoIsValidAttributeValueDetermina si una cadena es un nombre de atributo válido.
Método públicoMiembro estáticoIsValidTagDetermina si una cadena es una etiqueta válida.
Método públicoMiembro estáticoIsValidTextDetermina si una cadena es válida como texto dentro de un elemento XML.
Método públicoSearchForChildByTagBusca un elemento secundario por su nombre de etiqueta.
Método públicoSearchForTextOfTagBusca un elemento secundario por su nombre de etiqueta y devuelve el texto que contiene.
Método públicoToStringCrea la representación de cadena de un elemento XML y los atributos, elementos secundarios y texto que lo constituyen. (Invalida a Object.ToString()).
Arriba

Esta clase pretende ser una pequeña implementación de un modelo de objetos XML simple para su uso en el sistema de seguridad y no para utilizarlo como modelo de objetos XML general. En esta documentación se da por hecho que se posee un conocimiento básico de XML.

El modelo de objetos XML simple de un elemento consta de las siguientes partes:

  • La etiqueta es el nombre del elemento.

  • Los atributos son cero o más pares de atributos nombre/valor en el elemento.

  • Los elementos secundarios son cero o más elementos anidados dentro de <tag> y </tag>.

Se recomienda utilizar la representación XML basada en atributos para expresar los elementos de seguridad y sus valores. Esto significa que las propiedades de un elemento se expresan como atributos y los valores de propiedades se expresan como valores de atributos. Evite anidar texto dentro de etiquetas. Para cualquier representación de <tag>text</tag>, suele encontrarse una representación de tipo <tag value="text"/>. La utilización de esta representación XML basada en atributos aumenta la legibilidad y facilita la portabilidad WMI de la serialización XML resultante.

Un nombre de atributo debe tener al menos un carácter y no puede ser null. Si se utiliza la representación de valores basada en elementos, los elementos con una cadena de texto que sea null se representan con la forma <tag/>; en caso contrario, el texto aparece delimitado por los símbolos (token) <tag> y </tag>. Ambas formas se pueden combinar con atributos, que se muestran si existen.

En las etiquetas, atributos y texto de los elementos, si existen, siempre se distingue entre mayúsculas y minúsculas. La forma XML contiene comillas y secuencias de escape donde se necesitan. Valores de cadena que incluyen caracteres no válidos para su uso en XML en una ArgumentException. Estas reglas se aplican a todas las propiedades y métodos.

NotaNota

Por motivos de rendimiento, la validación de caracteres sólo se realiza cuando el elemento se codifica como texto XML y no cada vez que se establece una propiedad o método. Los métodos estáticos permiten la comprobación explícita cuando es necesaria.

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


using System;
using System.Security;
using System.Collections;

class SecurityElementMembers
{
    [STAThread]
    static void Main(string[] args)
    {
        SecurityElement xmlRootElement = 
            new SecurityElement("RootTag", "XML security tree");

        AddAttribute(xmlRootElement,"creationdate",DateTime.Now.ToString());
        AddChildElement(xmlRootElement,"destroytime",
            DateTime.Now.AddSeconds(1.0).ToString());

        SecurityElement windowsRoleElement = 
            new SecurityElement("WindowsMembership.WindowsRole");

        windowsRoleElement.AddAttribute("version","1.00");

        // Add a child element and a creationdate attribute.
        AddChildElement(windowsRoleElement,"BabyElement",
            "This is a child element");
        AddAttribute(windowsRoleElement,"creationdate",
            DateTime.Now.ToString());

        xmlRootElement.AddChild(windowsRoleElement);

        CompareAttributes(xmlRootElement, "creationdate");
        ConvertToHashTable(xmlRootElement);

        DisplaySummary(xmlRootElement);

        // Determine if the security element is too old to keep.
        xmlRootElement = DestroyTree(xmlRootElement);
        if (xmlRootElement != null)
        {
            string elementInXml = xmlRootElement.ToString();
            Console.WriteLine(elementInXml);
        }

        Console.WriteLine("This sample completed successfully; " +
            "press Enter to exit.");
        Console.ReadLine();
    }

    // Add an attribute to the specified security element.
    private static SecurityElement AddAttribute(
        SecurityElement xmlElement,
        string attributeName,
        string attributeValue)
    {
        if (xmlElement != null)
        {
            // Verify that the attribute name and value are valid XML formats.
            if (SecurityElement.IsValidAttributeName(attributeName) &&
                SecurityElement.IsValidAttributeValue(attributeValue))
            {
                // Add the attribute to the security element.
                xmlElement.AddAttribute(attributeName, attributeValue);
            }
        }
        return xmlElement;
    }

    // Add a child element to the specified security element.
    private static SecurityElement AddChildElement(
        SecurityElement parentElement,
        string tagName,
        string tagText)
    {
        if (parentElement != null)
        {
            // Ensure that the tag text is in valid XML format.
            if (!SecurityElement.IsValidText(tagText))
            {
                // Replace invalid text with valid XML text 
                // to enforce proper XML formatting.
                tagText = SecurityElement.Escape(tagText);
            }

            // Determine whether the tag is in valid XML format.
            if (SecurityElement.IsValidTag(tagName))
            {
                SecurityElement childElement;
                childElement = parentElement.SearchForChildByTag(tagName);

                if (childElement != null)
                {
                    String elementText;
                    elementText = parentElement.SearchForTextOfTag(tagName);

                    if (!elementText.Equals(tagText))
                    {
                        // Add child element to the parent security element.
                        parentElement.AddChild(
                            new SecurityElement(tagName, tagText));
                    }
                }
                else 
                {
                    // Add child element to the parent security element.
                    parentElement.AddChild(
                        new SecurityElement(tagName, tagText));
                }
            }
        }
        return parentElement;
    }

    // Create and display a summary sentence 
    // about the specified security element.
    private static void DisplaySummary(SecurityElement xmlElement)
    {
        // Retrieve tag name for the security element.
        string xmlTreeName = xmlElement.Tag.ToString();

        // Retrieve tag text for the security element.
        string xmlTreeDescription = xmlElement.Text;

        // Retrieve value of the creationdate attribute.
        string xmlCreationDate = xmlElement.Attribute("creationdate");

        // Retrieve the number of children under the security element.
        string childrenCount = xmlElement.Children.Count.ToString();

        string outputMessage = "The security XML tree named " + xmlTreeName;
        outputMessage += "(" + xmlTreeDescription + ")";
        outputMessage += " was created on " + xmlCreationDate + " and ";
        outputMessage += "contains " + childrenCount + " child elements.";

        Console.WriteLine(outputMessage);
    }

    // Compare the first two occurrences of an attribute 
    // in the specified security element.
    private static void CompareAttributes(
        SecurityElement xmlElement, string attributeName)
    {
        // Create a hash table containing the security element's attributes.
        Hashtable attributeKeys = xmlElement.Attributes;
        string attributeValue = attributeKeys[attributeName].ToString();

        foreach(SecurityElement xmlChild in xmlElement.Children)
        {
            if (attributeValue.Equals(xmlChild.Attribute(attributeName)))
            {
                // The security elements were created at the exact same time.
            }
        }
    }

    // Convert the contents of the specified security element 
    // to hash codes stored in a hash table.
    private static void ConvertToHashTable(SecurityElement xmlElement)
    {
        // Create a hash table to hold hash codes of the security elements.
        Hashtable xmlAsHash = new Hashtable();
        int rootIndex = xmlElement.GetHashCode();
        xmlAsHash.Add(rootIndex, "root");

        int parentNum = 0;

        foreach(SecurityElement xmlParent in xmlElement.Children)
        {
            parentNum++;
            xmlAsHash.Add(xmlParent.GetHashCode(), "parent" + parentNum);
            if ((xmlParent.Children != null) && 
                (xmlParent.Children.Count > 0))
            {
                int childNum = 0;
                foreach(SecurityElement xmlChild in xmlParent.Children)
                {
                    childNum++;
                    xmlAsHash.Add(xmlChild.GetHashCode(), "child" + childNum);
                }
            }
        }
    }

    // Delete the specified security element if the current time is past
    // the time stored in the destroytime tag.
    private static SecurityElement DestroyTree(SecurityElement xmlElement)
    {
        SecurityElement localXmlElement = xmlElement;
        SecurityElement destroyElement = 
            localXmlElement.SearchForChildByTag("destroytime");

        // Verify that a destroytime tag exists.
        if (localXmlElement.SearchForChildByTag("destroytime") != null)
        {
            // Retrieve the destroytime text to get the time 
            // the tree can be destroyed.
            string storedDestroyTime =
                localXmlElement.SearchForTextOfTag("destroytime");

            DateTime destroyTime = DateTime.Parse(storedDestroyTime);
            if (DateTime.Now > destroyTime)
            {
                localXmlElement = null;
                Console.WriteLine("The XML security tree has been deleted.");
            }
        }

        // Verify that xmlElement is of type SecurityElement.
        if (xmlElement.GetType().Equals(
            typeof(System.Security.SecurityElement)))
        {
            // Determine whether the localXmlElement object 
            // differs from xmlElement.
            if (xmlElement.Equals(localXmlElement))
            {
                // Verify that the tags, attributes and children of the
                // two security elements are identical.
                if (xmlElement.Equal(localXmlElement))
                {
                    // Return the original security element.
                    return xmlElement;
                }
            }
        }

        // Return the modified security element.
        return localXmlElement;
    }
}
//
// This sample produces the following output:
// 
// The security XML tree named RootTag(XML security tree) 
// was created on 2/23/2004 1:23:00 PM and contains 2 child elements.
//<RootTag creationdate="2/23/2004 1:23:00 PM">XML security tree
//   <destroytime>2/23/2004 1:23:01 PM</destroytime>
//   <WindowsMembership.WindowsRole version="1.00"
//                                  creationdate="2/23/2004 1:23:00 PM">
//      <BabyElement>This is a child element.</BabyElement>
//   </WindowsMembership.WindowsRole>
//</RootTag>
//
//This sample completed successfully; press Exit to continue.


.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