Tento článek byl přeložený strojově. Pokud chcete zobrazit článek v angličtině, zaškrtněte políčko Angličtina. Anglickou verzi článku můžete také zobrazit v místním okně přesunutím ukazatele myši nad text.
Překlad
Angličtina

SecurityElement – třída

.NET Framework (current version)
 

Představuje objektový model XML pro kódování objekty zabezpečení. Tato třída nemůže být zděděna.

Obor názvů:   System.Security
Sestavení:  mscorlib (v mscorlib.dll)

System.Object
  System.Security.SecurityElement

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

NázevPopis
System_CAPS_pubmethodSecurityElement(String)

Inicializuje novou instanci SecurityElement třídy s stanovené značky.

System_CAPS_pubmethodSecurityElement(String, String)

Inicializuje novou instanci SecurityElement třídy s stanovené značky a text.

NázevPopis
System_CAPS_pubpropertyAttributes

Získá nebo nastaví atributy elementu XML jako dvojice název/hodnota.

System_CAPS_pubpropertyChildren

Získá nebo nastaví pole podřízené prvky prvku XML.

System_CAPS_pubpropertyTag

Získá nebo nastaví název značky elementu XML.

System_CAPS_pubpropertyText

Získá nebo nastaví text v rámci elementu XML.

NázevPopis
System_CAPS_pubmethodAddAttribute(String, String)

Přidá název hodnota atributu do elementu XML.

System_CAPS_pubmethodAddChild(SecurityElement)

Přidá podřízený element elementu XML.

System_CAPS_pubmethodAttribute(String)

Vyhledá atribut podle názvu v elementu XML.

System_CAPS_pubmethodCopy()

Vytvoří a vrátí identické kopii aktuální SecurityElement objektu.

System_CAPS_pubmethodEqual(SecurityElement)

Porovná dva objekty element XML rovnosti.

System_CAPS_pubmethodEquals(Object)

Určuje, zda zadaný objekt je rovna aktuálního objektu.(Zděděno od Object.)

System_CAPS_pubmethodSystem_CAPS_staticEscape(String)

Nahradí neplatné znaky XML v řetězci s jejich platný kód XML ekvivalentní.

System_CAPS_pubmethodSystem_CAPS_staticFromString(String)

Vytvoří element zabezpečení z řetězec s kódováním XML.

System_CAPS_pubmethodGetHashCode()

Slouží jako výchozí funkce hash.(Zděděno od Object.)

System_CAPS_pubmethodGetType()

Získá Type aktuální instance.(Zděděno od Object.)

System_CAPS_pubmethodSystem_CAPS_staticIsValidAttributeName(String)

Určuje, zda řetězec je platný atribut name.

System_CAPS_pubmethodSystem_CAPS_staticIsValidAttributeValue(String)

Určuje řetězec, zda je hodnota platný atribut.

System_CAPS_pubmethodSystem_CAPS_staticIsValidTag(String)

Určuje, zda je řetězec platnou značku.

System_CAPS_pubmethodSystem_CAPS_staticIsValidText(String)

Určuje, zda je řetězec platný jako text v rámci elementu XML.

System_CAPS_pubmethodSearchForChildByTag(String)

Vyhledá podřízený podle názvu značky.

System_CAPS_pubmethodSearchForTextOfTag(String)

Vyhledá podřízený podle názvu značky a vrátí obsažené text.

System_CAPS_pubmethodToString()

Vytváří řetězcovou reprezentaci XML element a jeho základní atributy, podřízené prvky a text.(Přepisy: Object.ToString())

Tato třída má být prosté provádění jednoduchého modelu objektu XML, pro použití v rámci systému zabezpečení a nikoli pro použití jako obecný objektový model XML. Tato dokumentace předpokládá základní znalost XML.

Jednoduché objektový model XML pro element se skládá z následujících částí:

  • Značka je název elementu.

  • Atributy jsou nula nebo více dvojic atribut název hodnota u elementu.

  • Podřízené objekty jsou nula nebo více prvků vnořené <tag> a </tag>.

Důrazně doporučujeme, aby atribut na základě reprezentaci XML se používá k express prvků zabezpečení a jejich hodnoty. To znamená vlastností elementu jsou vyjádřeny jako atributy a hodnoty vlastností jsou vyjádřeny jako hodnoty atributů. Vyhněte se vnoření text v rámci značek. Pro jakékoli <tag>text</tag> vyjádření a reprezentace typu <tag value="text"/> je obvykle k dispozici. Pomocí této založený na atributu XML reprezentaci zvyšuje čitelnost a umožňuje snadno WMI přenositelnost výsledný serializace XML.

Název atributu musí být jeden znak nebo déle a nemůže být null. Pokud se používá reprezentaci hodnoty založené na elementu, elementy s textový řetězec, který je null jsou reprezentována ve <tag/> formuláři; jinak je ohraničen text <tag> a </tag> tokeny. Obě formy mohou být kombinovány s atributy, které jsou uvedeny Pokud je k dispozici.

Značky, atributy a textové prvky, pokud je k dispozici, jsou vždy malá a velká písmena. Formát XML obsahuje uvozovky a řídicí sekvence, kde je to nezbytné. Řetězcové hodnoty, které obsahují znaky, které jsou neplatné pro použití v kódu XML za následek ArgumentException. Tato pravidla platí pro všechny vlastnosti a metody.

System_CAPS_notePoznámka

Z důvodů výkonu platnosti znak je kontrolována v elementu s kódováním do textového formátu XML a nikoli na každou sadu vlastnosti nebo metody. Statické metody umožňují explicitní kontrole, kde je to potřeba.

Následující příklad ukazuje použití členů SecurityElement třídy.

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
K dispozici od 1.1

Všichni členové tohoto typu deklarovaní jako public static (Shared v jazyce Visual Basic) jsou bezpečné pro přístup z více vláken. Není zaručeno, že členové instancí jsou bezpeční pro přístup z více vláken.

Zpátky na začátek
Zobrazit: