MSDN の SecurityPermission クラスの「使用例」。

EntryPoint.cs

using System;
using System.Security;
using System.Security.Permissions;


namespace demo.security.permission {


    /// <summary>
    ///
    /// </summary>
    class EntryPoint {
        /// <summary>
        /// Test harness.
        /// </summary>
        /// <param name="args"></param>
        public void run(string[] args) {
            string console_input;
            
            try {
                SecurityPermissionDemo democase = new SecurityPermissionDemo();
                bool ret_code = democase.run();

                if ( ret_code ) {
                    Console.Out.WriteLine( "SecurityPermission demo completed successfully." );
                    Console.Out.WriteLine( "Press the Enter key to exit." );

                    console_input = Console.ReadLine();

                    Environment.ExitCode = 100;
                } else {
                    Console.Out.WriteLine( "SecurityPermission demo failed." );
                    Console.Out.WriteLine( "Press the Enter key to exit." );

                    console_input = Console.ReadLine();

                    Environment.ExitCode = 101;
                }
            } catch ( Exception e ) {
                Console.Out.WriteLine( "SecurityPermission demo failed." );
                Console.WriteLine( e.ToString() );
                Console.Out.WriteLine( "Press the Enter key to exit." );

                console_input = Console.ReadLine();

                Environment.ExitCode = 101;
            }
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args) {
            EntryPoint progn = new EntryPoint();

            progn.run( args );
        }
    }


}

SecurityPermissionDemo.cs

using System;
using System.Security;
using System.Security.Permissions;


[assembly: CLSCompliant( true )]
namespace demo.security.permission {


    /// <summary>
    ///
    /// </summary>
    public class SecurityPermissionDemo {
        /// <summary>
        /// Invoke all demos.
        /// </summary>
        /// <returns></returns>
        public bool run() {
            bool ret_code = true;
            bool temp_ret_code;

            // Call the IsSubsetOf demo.
            temp_ret_code = isSubsetOf();
            if ( temp_ret_code ) 
                Console.Out.WriteLine( "IsSubsetOf demo completed successfully." );
            else 
                Console.Out.WriteLine( "IsSubsetOf demo failed." );
            ret_code = temp_ret_code && ret_code;

            // Call the Union demo.
            temp_ret_code = union();
            if ( temp_ret_code ) 
                Console.Out.WriteLine( "Union demo completed successfully." );
            else 
                Console.Out.WriteLine( "Union demo failed." );
            ret_code = temp_ret_code && ret_code;

            // Call the Intersect demo.
            temp_ret_code = intersect();
            if ( temp_ret_code ) 
                Console.Out.WriteLine( "Intersect demo completed successfully." );
            else 
                Console.Out.WriteLine( "Intersect demo failed." );
            ret_code = temp_ret_code && ret_code;

            // Call the Copy demo.
            temp_ret_code = copy();
            if ( temp_ret_code )
                Console.Out.WriteLine( "Copy demo completed successfully." );
            else
                Console.Out.WriteLine( "Copy demo failed." );
            ret_code = temp_ret_code && ret_code;

            // Call the ToFromXml demo.
            temp_ret_code = toFromXML();
            if ( temp_ret_code )
                Console.Out.WriteLine( "ToFromXml demo completed successfully." );
            else
                Console.Out.WriteLine( "ToFromXml demo failed." );
            ret_code = temp_ret_code && ret_code;

            return ( ret_code );
        }
        
        
        /// <summary>
        /// IsSubsetOf determines whether the current permission is a subset of the specified permission.
        /// </summary>
        /// <returns></returns>
        private bool isSubsetOf() {
            bool ret = true;
            SecurityPermissionFlag left_security, right_security;
            SecurityPermission left_security_permission, right_security_permission;
            SecurityGenerator left_security_generator = new SecurityGenerator();
            SecurityGenerator right_security_generator = new SecurityGenerator();

            left_security_generator.resetIndex();

            while ( left_security_generator.getSecurityFlag( out left_security ) ) {
                left_security_permission = new SecurityPermission( left_security );
                right_security_generator.resetIndex();

                Console.WriteLine( "********************************************************\n" );

                while ( right_security_generator.getSecurityFlag( out right_security ) ) {
                    right_security_permission = new SecurityPermission( right_security );
                    
                    try {
                        if ( left_security_permission.IsSubsetOf( right_security_permission ) ) {
                            Console.WriteLine( left_security_permission.Flags + " is a subset of " +
                                               right_security_permission.Flags );
                        } else {
                            Console.WriteLine( left_security_permission.Flags + " is not a subset of " +
                                               right_security_permission.Flags );
                        }
                    } catch ( Exception e ) {
                        Console.WriteLine( "An exception was thrown for subset :" + left_security_permission + "\n" +
                                           right_security_permission + "\n" + e );
                        ret = false;
                    }
                }
            }
            return ret;
        }


        /// <summary>
        /// Union creates a new permission that is the union of the current permission and the specified permission.
        /// </summary>
        /// <returns></returns>
        private bool union() {
            bool ret = true;
            SecurityPermissionFlag left_security, right_security;
            SecurityPermission left_security_permission, right_security_permission;
            IPermission temp_permission;

            SecurityGenerator left_security_generator = new SecurityGenerator();
            SecurityGenerator right_security_generator = new SecurityGenerator();

            left_security_generator.resetIndex();

            while ( left_security_generator.getSecurityFlag( out left_security ) ) {
                left_security_permission = new SecurityPermission( left_security );
                Console.WriteLine( "**********************************************************\n" );
                right_security_generator.resetIndex();

                while ( right_security_generator.getSecurityFlag( out right_security ) ) {
                    right_security_permission = new SecurityPermission( right_security );
                    temp_permission = (SecurityPermission)left_security_permission.Union( right_security_permission );
                    temp_permission = left_security_permission.Union( right_security_permission );

                    if ( temp_permission == null ) {
                        Console.WriteLine( "The union of " + left_security + " and " + right_security + " is null." );
                    } else {
                        Console.WriteLine( "The union of " + left_security_permission.Flags + " and " +
                                           right_security_permission.Flags + " = " +
                                           ( (SecurityPermission)temp_permission ).Flags.ToString() );
                    }

                }
            }

            return ret;

        }


        /// <summary>
        /// Intersect creates and returns a new permission that is the intersection of the current
        /// permission and the permission specified.
        /// </summary>
        /// <returns></returns>
        private bool intersect() {
            bool ret = true;
            SecurityPermissionFlag left_security, right_security;
            SecurityPermission left_security_permission, right_security_permission, temp_permission;
            SecurityGenerator left_security_generator = new SecurityGenerator();
            SecurityGenerator right_security_generator = new SecurityGenerator();

            left_security_generator.resetIndex();

            while ( left_security_generator.getSecurityFlag( out left_security ) ) {
                left_security_permission = new SecurityPermission( left_security );
                
                Console.WriteLine( "**********************************************************\n" );
                
                right_security_generator.resetIndex();

                while ( right_security_generator.getSecurityFlag( out right_security ) ) {
                    right_security_permission = new SecurityPermission( right_security );

                    temp_permission = (SecurityPermission)left_security_permission.Intersect( right_security_permission );
                    if ( temp_permission != null ) {
                        Console.WriteLine( "The intersection of " + left_security + " and " + right_security + " = " +
                                           ( (SecurityPermission)temp_permission ).Flags.ToString() );
                    } else {
                        Console.WriteLine( "The intersection of " + left_security + " and " + right_security + " is null." );
                    }
                }
            }

            return ret;
        }


        /// <summary>
        /// Copy creates and returns an identical copy of the current permission.
        /// </summary>
        /// <returns></returns>
        private bool copy() {
            bool ret = true;

            SecurityPermissionFlag left_security_flag;
            SecurityPermission left_security_permission, right_security_permission;

            SecurityGenerator left_security_generator = new SecurityGenerator();
            SecurityGenerator right_security_generator = new SecurityGenerator();

            left_security_generator.resetIndex();
            while ( left_security_generator.getSecurityFlag( out left_security_flag ) ) {
                left_security_permission = new SecurityPermission( left_security_flag );
                right_security_generator.resetIndex();

                Console.WriteLine( "********************************************************\n" );

                try {
                    right_security_permission = (SecurityPermission)left_security_permission.Copy();
                    Console.WriteLine( "Result of copy = " + right_security_permission.ToString() );

                } catch ( Exception e ) {
                    Console.WriteLine( "Copy failed :" + left_security_permission.ToString() + e );

                    continue;
                }
            }
            return ret;
        }


        /// <summary>
        /// ToXml creates an XML encoding of the permission and its current state;
        /// FromXml reconstructs a permission with the specified state from the XML encoding.</summary>
        /// <returns></returns>
        private bool toFromXML() {
            bool ret = true;

            SecurityPermissionFlag left_security_flag;
            SecurityPermission left_security_permission, right_security_permission;

            SecurityGenerator left_security_generator = new SecurityGenerator();
            SecurityGenerator right_security_generator = new SecurityGenerator();

            left_security_generator.resetIndex();
            while ( left_security_generator.getSecurityFlag( out left_security_flag ) ) {
                left_security_permission = new SecurityPermission( left_security_flag );

                Console.WriteLine( "********************************************************\n" );
                right_security_generator.resetIndex();
                try {
                    right_security_permission = new SecurityPermission( PermissionState.None );
                    right_security_permission.FromXml( left_security_permission.ToXml() );
             
                    Console.WriteLine( "Result of ToFromXml = " +
                                       right_security_permission.ToString() );

                } catch ( Exception e ) {
                    Console.WriteLine( "ToFromXml failed :" + left_security_permission.ToString() + e );

                    continue;
                }
            }

            return ret;

        }

    }


    /// <summary>
    /// This class generates SecurityPermission objects.
    /// </summary>
    internal class SecurityGenerator {
        /// <summary>
        ///
        /// </summary>
        private SecurityPermissionFlag[] my_securities_ ={
            SecurityPermissionFlag.AllFlags,
            SecurityPermissionFlag.Assertion |
                SecurityPermissionFlag.ControlAppDomain,
            SecurityPermissionFlag.ControlAppDomain,
            SecurityPermissionFlag.ControlDomainPolicy |
                SecurityPermissionFlag.ControlEvidence,
            SecurityPermissionFlag.ControlEvidence,
            SecurityPermissionFlag.ControlPolicy |
                SecurityPermissionFlag.ControlPrincipal,
            SecurityPermissionFlag.ControlPrincipal,
            SecurityPermissionFlag.ControlThread,
            SecurityPermissionFlag.Execution,
            SecurityPermissionFlag.Infrastructure,
            SecurityPermissionFlag.NoFlags,
            SecurityPermissionFlag.RemotingConfiguration |
                SecurityPermissionFlag.SerializationFormatter,
            SecurityPermissionFlag.SerializationFormatter,
            SecurityPermissionFlag.SkipVerification,
            SecurityPermissionFlag.UnmanagedCode
            };
        /// <summary>
        ///
        /// </summary>
        private int reflection_index_ = 0;


        /// <summary>
        ///
        /// </summary>
        public SecurityGenerator() {
            resetIndex();
        }


        /// <summary>
        ///
        /// </summary>
        public void resetIndex() {
            reflection_index_ = 0;
        }


        /// <summary>
        /// GetSecurityFlag returns a SecurityPermissionFlag.
        /// </summary>
        /// <param name="security"></param>
        /// <returns></returns>
        public bool getSecurityFlag(out SecurityPermissionFlag security) {
            if ( reflection_index_ >= my_securities_.Length ) {
                security = SecurityPermissionFlag.NoFlags;
                reflection_index_++;

                return false;
            }
            security = my_securities_[reflection_index_++];

            return true;
        }
    } //


}