Export (0) Print
Expand All

PolicyStatement Class

Represents the statement of a CodeGroup describing the permissions and other information that apply to code with a particular set of evidence. This class cannot be inherited.

System.Object
  System.Security.Policy.PolicyStatement

Namespace:  System.Security.Policy
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class PolicyStatement : ISecurityPolicyEncodable, 
	ISecurityEncodable

The PolicyStatement type exposes the following members.

  NameDescription
Public methodPolicyStatement(PermissionSet)Initializes a new instance of the PolicyStatement class with the specified PermissionSet.
Public methodPolicyStatement(PermissionSet, PolicyStatementAttribute)Initializes a new instance of the PolicyStatement class with the specified PermissionSet and attributes.
Top

  NameDescription
Public propertyAttributesGets or sets the attributes of the policy statement.
Public propertyAttributeStringGets a string representation of the attributes of the policy statement.
Public propertyPermissionSetGets or sets the PermissionSet of the policy statement.
Top

  NameDescription
Public methodCopyCreates an equivalent copy of the current policy statement.
Public methodEqualsDetermines whether the specified PolicyStatement object is equal to the current PolicyStatement. (Overrides Object.Equals(Object).)
Public methodFromXml(SecurityElement)Reconstructs a security object with a given state from an XML encoding.
Public methodFromXml(SecurityElement, PolicyLevel)Reconstructs a security object with a given state from an XML encoding.
Public methodGetHashCodeGets a hash code for the PolicyStatement object that is suitable for use in hashing algorithms and data structures such as a hash table. (Overrides Object.GetHashCode().)
Public methodGetTypeGets the Type of the current instance. (Inherited from Object.)
Public methodToStringReturns a string that represents the current object. (Inherited from Object.)
Public methodToXml()Creates an XML encoding of the security object and its current state.
Public methodToXml(PolicyLevel)Creates an XML encoding of the security object and its current state.
Top

A PolicyStatement consists of a set of granted permissions, and possible special attributes for the code group.

Policy statements are typically used as the return value of a Resolve operation on a PolicyLevel.

The following code example shows the use of members of the PolicyStatement class

using System;
using System.Security;
using System.Security.Policy;
using System.Security.Principal;
using System.Security.Permissions;

class Members
{
    [STAThread]
    static void Main(string[] args)
    {
        // Create two new policy statements.
        PolicyStatement policyStatement = firstConstructorTest();
        PolicyStatement policyStatement2 = secondConstructorTest();

        // Add attributes to the first policy statement.
        policyStatement.Attributes = PolicyStatementAttribute.All;

        // Create a copy of the first policy statement.
        PolicyStatement policyStatementCopy = createCopy(policyStatement);
        addXmlMember(ref policyStatementCopy);

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

    // Construct a PolicyStatement with an Unrestricted permission set. 
    private static PolicyStatement firstConstructorTest() 
    {
        // Construct the permission set.
        PermissionSet permissions 
            = new PermissionSet(PermissionState.Unrestricted);
        permissions.AddPermission(
            new SecurityPermission(SecurityPermissionFlag.Execution));
        permissions.AddPermission(
            new ZoneIdentityPermission(SecurityZone.MyComputer));

        // Create a policy statement based on the newly created permission 
        // set.
        PolicyStatement policyStatement = new PolicyStatement(permissions);

        return policyStatement;
    }

    // Construct a PolicyStatement with an Unrestricted permission set and 
    // the LevelFinal attribute. 
    private static PolicyStatement secondConstructorTest()
    {
        // Construct the permission set.
        PermissionSet permissions =
            new PermissionSet(PermissionState.Unrestricted);
        permissions.AddPermission(
            new SecurityPermission(SecurityPermissionFlag.Execution));
        permissions.AddPermission(
            new ZoneIdentityPermission(SecurityZone.MyComputer));

        PolicyStatementAttribute levelFinalAttribute = 
            PolicyStatementAttribute.LevelFinal;

        // Create a new policy statement with the specified permission set. 
        // The LevelFinal attribute is set to prevent the evaluation of lower 
        // policy levels in a resolve operation.
        PolicyStatement policyStatement =
            new PolicyStatement(permissions, levelFinalAttribute);

        return policyStatement;
    }

    // Add a named permission set to the specified PolicyStatement. 
    private static void AddPermissions(ref PolicyStatement policyStatement)
    {
        // Construct a NamedPermissionSet with basic permissions.
        NamedPermissionSet allPerms = new NamedPermissionSet("allPerms");
        allPerms.AddPermission(
            new SecurityPermission(SecurityPermissionFlag.Execution));
        allPerms.AddPermission(
            new ZoneIdentityPermission(SecurityZone.MyComputer));
        allPerms.AddPermission(
            new SiteIdentityPermission("www.contoso.com"));

        policyStatement.PermissionSet = allPerms;
    }

    // If a class attribute is not found in the specified PolicyStatement, 
    // add a child XML element with an added class attribute. 
    private static void addXmlMember(ref PolicyStatement policyStatement) 
    {
        SecurityElement xmlElement = policyStatement.ToXml();
        if (xmlElement.Attribute("class") == null)
        {
            SecurityElement newElement = 
                new SecurityElement("PolicyStatement");
            newElement.AddAttribute("class", policyStatement.ToString());
            newElement.AddAttribute("version","1.1");

            newElement.AddChild(new SecurityElement("PermissionSet"));

            policyStatement.FromXml(newElement);

            Console.Write("Added the class attribute and modified its ");
            Console.WriteLine("version number.\n" + newElement.ToString());
        }
    }

    // Verify that the type of the specified object is a PolicyStatement type 
    // then create a copy of the object. 
    private static PolicyStatement createCopy(Object sourceObject)
    {
        PolicyStatement returnedStatement = new PolicyStatement(null);
        // Compare specified object type with the PolicyStatement type. 
        if (sourceObject.GetType().Equals(typeof(PolicyStatement)))
        {
            returnedStatement = getCopy((PolicyStatement)sourceObject);
        }
        else
        {
            throw new ArgumentException("Expected the PolicyStatement type.");
        }

        return returnedStatement;
    }

    // Return a copy of the specified PolicyStatement if the result of the 
    // Copy command is an equivalent object. Otherwise, return the 
    // original PolicyStatement object. 
    private static PolicyStatement getCopy(PolicyStatement policyStatement)
    {
        // Create an equivalent copy of the policy statement.
        PolicyStatement policyStatementCopy = policyStatement.Copy();

        // Compare the specified objects for equality. 
        if (!policyStatementCopy.Equals(policyStatement))
        {
            return policyStatementCopy;
        } 
        else 
        {
            return policyStatement;
        }
    }

    // Summarize the attributes of the specified PolicyStatement on the 
    // console window. 
    private static void summarizePolicyStatment(
        PolicyStatement policyStatement)
    {
        // Retrieve the class path for policyStatement. 
        string policyStatementClass = policyStatement.ToString();

        int hashCode = policyStatement.GetHashCode();

        string attributeString = "";
        // Retrieve the string representation of the PolicyStatement 
        // attributes. 
        if (policyStatement.AttributeString != null)
        {
            attributeString = policyStatement.AttributeString;
        }

        // Write a summary to the console window.
        Console.WriteLine("\n*** " + policyStatementClass + " summary ***");
        Console.Write("This PolicyStatement has been created with hash ");
        Console.Write("code(" + hashCode + ") ");

        Console.Write("and contains the following attributes: ");
        Console.WriteLine(attributeString);
    }
}
// 
// This sample produces the following output: 
// 
// Added the class attribute and modified the version number. 
// <PolicyStatement class="System.Security.Policy.PolicyStatement" 
//                  version="1.1">
//    <PermissionSet/> 
// </PolicyStatement> 
//  
// *** System.Security.Policy.PolicyStatement summary *** 
// PolicyStatement has been created with hash code(20) containing the 
// following attributes: Exclusive LevelFinal 
// This sample completed successfully; press Enter to exit.

.NET Framework

Supported in: 4.6, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.
Show:
© 2014 Microsoft