Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase SecurityElement

 

Publicado: octubre de 2016

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

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

System.Object
  System.Security.SecurityElement

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

NombreDescripción
System_CAPS_pubmethodSecurityElement(String)

Inicializa una nueva instancia de la SecurityElement clase con la etiqueta especificada.

System_CAPS_pubmethodSecurityElement(String, String)

Inicializa una nueva instancia de la SecurityElement clase con la etiqueta especificada y el texto.

NombreDescripción
System_CAPS_pubpropertyAttributes

Obtiene o establece los atributos de un elemento XML como pares nombre/valor.

System_CAPS_pubpropertyChildren

Obtiene o establece la matriz de elementos secundarios del elemento XML.

System_CAPS_pubpropertyTag

Obtiene o establece el nombre de etiqueta de un elemento XML.

System_CAPS_pubpropertyText

Obtiene o establece el texto dentro de un elemento XML.

NombreDescripción
System_CAPS_pubmethodAddAttribute(String, String)

Agrega un atributo de nombre/valor a un elemento XML.

System_CAPS_pubmethodAddChild(SecurityElement)

Agrega un elemento secundario al elemento XML.

System_CAPS_pubmethodAttribute(String)

Busca un atributo por el nombre de un elemento XML.

System_CAPS_pubmethodCopy()

Crea y devuelve una copia idéntica del actual SecurityElement objeto.

System_CAPS_pubmethodEqual(SecurityElement)

Compara la igualdad de dos objetos de elemento XML.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticEscape(String)

Reemplaza caracteres XML no válidos en una cadena con su equivalente XML válido.

System_CAPS_pubmethodSystem_CAPS_staticFromString(String)

Crea un elemento de seguridad de una cadena codificada en XML.

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticIsValidAttributeName(String)

Determina si una cadena es un nombre de atributo válido.

System_CAPS_pubmethodSystem_CAPS_staticIsValidAttributeValue(String)

Determina si una cadena es un valor de atributo válido.

System_CAPS_pubmethodSystem_CAPS_staticIsValidTag(String)

Determina si una cadena es una etiqueta válida.

System_CAPS_pubmethodSystem_CAPS_staticIsValidText(String)

Determina si una cadena es válida como texto dentro de un elemento XML.

System_CAPS_pubmethodSearchForChildByTag(String)

Busca a un elemento secundario por su nombre de etiqueta.

System_CAPS_pubmethodSearchForTextOfTag(String)

Busca a un elemento secundario por su nombre de etiqueta y devuelve el texto que contiene.

System_CAPS_pubmethodToString()

Genera una representación de cadena de un elemento XML y sus atributos constituyentes, elementos secundarios y texto.(Invalida Object.ToString()).

Esta clase pretende ser una implementación ligera de un modelo de objetos XML simple para su uso en el sistema de seguridad y no para su uso como un modelo de objetos XML general. Esta documentación asume un conocimiento básico de XML.

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

  • La etiqueta es el nombre del elemento.

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

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

Se recomienda encarecidamente que se utiliza la representación de XML basado en atributos para expresar los elementos de seguridad y sus valores. Esto significa que las propiedades de un elemento se expresan como atributos y valores de propiedad se expresan como valores de atributo. Evite anidar texto dentro de etiquetas. Para cualquier <tag>text</tag> representación una representación de tipo <tag value="text"/> suele estar disponible. Mediante esta representación XML basada en atributos aumenta la legibilidad y permite que 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 usa la representación de valores basada en elementos, elementos con un texto de cadena que es null se representan en el <tag/> formulario; en caso contrario, el texto está delimitado por el <tag> y </tag> tokens. Ambas formas se pueden combinar con atributos, que se muestran si está presente.

Las etiquetas, atributos y texto de los elementos, si está presente, siempre distinguen mayúsculas de minúsculas. La forma XML contiene comillas y secuencias de escape donde es necesario. Valores de cadena que incluyen caracteres no válidos para su uso en XML como resultado un ArgumentException. Estas reglas se aplican a todas las propiedades y métodos.

System_CAPS_noteNota

Por motivos de rendimiento, validación de caracteres sólo se comprueba cuando el elemento se codifica en formato de texto XML y no en cada conjunto de una propiedad o método. Los métodos estáticos permiten la comprobación explícitos cuando sea necesario.

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

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
Disponible desde 1.1

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: