ReflectionPermission.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / clr / src / BCL / System / Security / Permissions / ReflectionPermission.cs / 1 / ReflectionPermission.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// ReflectionPermission.cs
// 
 
namespace System.Security.Permissions
{ 
    using System;
    using System.IO;
    using System.Security.Util;
    using System.Text; 
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting; 
    using System.Security; 
    using System.Reflection;
    using System.Globalization; 

    [ComVisible(true)]
    [Flags]
    [Serializable] 
    public enum ReflectionPermissionFlag
    { 
        NoFlags = 0x00, 
        [Obsolete("This API has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
        TypeInformation = 0x01, 
        MemberAccess = 0x02,
        ReflectionEmit = 0x04,
        [ComVisible(false)]
        RestrictedMemberAccess = 0x08, 
        AllFlags = 0x07
    } 
 
    [ComVisible(true)]
    [Serializable] 
    sealed public class ReflectionPermission
           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
    {
        // ReflectionPermissionFlag.AllFlags doesn't contain the new value RestrictedMemberAccess, 
        // but we cannot change its value now because that will break apps that have that old value baked in.
        // We should use this const that truely contains "all" flags instead of ReflectionPermissionFlag.AllFlags. 
        internal const ReflectionPermissionFlag AllFlagsAndMore = ReflectionPermissionFlag.AllFlags | ReflectionPermissionFlag.RestrictedMemberAccess; 

        private ReflectionPermissionFlag m_flags; 

        //
        // Public Constructors
        // 

        public ReflectionPermission(PermissionState state) 
        { 
            if (state == PermissionState.Unrestricted)
            { 
                SetUnrestricted( true );
            }
            else if (state == PermissionState.None)
            { 
                SetUnrestricted( false );
            } 
            else 
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState")); 
            }
        }

         // Parameters: 
         //
        public ReflectionPermission(ReflectionPermissionFlag flag) 
        { 
            VerifyAccess(flag);
 
            SetUnrestricted(false);
            m_flags = flag;
        }
 
        //------------------------------------------------------
        // 
        // PRIVATE AND PROTECTED MODIFIERS 
        //
        //----------------------------------------------------- 


        private void SetUnrestricted(bool unrestricted)
        { 
            if (unrestricted)
            { 
                m_flags = ReflectionPermission.AllFlagsAndMore; 
            }
            else 
            {
                Reset();
            }
        } 

 
        private void Reset() 
        {
            m_flags = ReflectionPermissionFlag.NoFlags; 
        }


        public ReflectionPermissionFlag Flags 
        {
            set 
            { 
                VerifyAccess(value);
 
                m_flags = value;
            }

            get 
            {
                return m_flags; 
            } 
        }
 

    #if ZERO   // Do not remove this code, usefull for debugging
        public override String ToString()
        { 
            StringBuilder sb = new StringBuilder();
            sb.Append("ReflectionPermission("); 
            if (IsUnrestricted()) 
            {
                sb.Append("Unrestricted"); 
            }
            else
            {
                if (GetFlag(ReflectionPermissionFlag.TypeInformation)) 
                    sb.Append("TypeInformation; ");
                if (GetFlag(ReflectionPermissionFlag.MemberAccess)) 
                    sb.Append("MemberAccess; "); 
                if (GetFlag(ReflectionPermissionFlag.ReflectionEmit))
                    sb.Append("ReflectionEmit; "); 
            }

            sb.Append(")");
            return sb.ToString(); 
        }
    #endif 
 

        // 
        // CodeAccessPermission implementation
        //

        public bool IsUnrestricted() 
        {
            return m_flags == ReflectionPermission.AllFlagsAndMore; 
        } 

        // 
        // IPermission implementation
        //

        public override IPermission Union(IPermission other) 
        {
            if (other == null) 
            { 
                return this.Copy();
            } 
            else if (!VerifyType(other))
            {
                throw new
                    ArgumentException( 
                                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName)
                                     ); 
            } 

            ReflectionPermission operand = (ReflectionPermission)other; 

            if (this.IsUnrestricted() || operand.IsUnrestricted())
            {
                return new ReflectionPermission( PermissionState.Unrestricted ); 
            }
            else 
            { 
                ReflectionPermissionFlag flag_union = (ReflectionPermissionFlag)(m_flags | operand.m_flags);
                return(new ReflectionPermission(flag_union)); 
            }
        }

 

        public override bool IsSubsetOf(IPermission target) 
        { 
            if (target == null)
            { 
                return m_flags == ReflectionPermissionFlag.NoFlags;
            }

            try 
            {
                ReflectionPermission operand = (ReflectionPermission)target; 
                if (operand.IsUnrestricted()) 
                    return true;
                else if (this.IsUnrestricted()) 
                    return false;
                else
                    return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0;
            } 
            catch (InvalidCastException)
            { 
                throw new 
                    ArgumentException(
                                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName) 
                                     );
            }

        } 

        public override IPermission Intersect(IPermission target) 
        { 
            if (target == null)
                return null; 
            else if (!VerifyType(target))
            {
                throw new
                    ArgumentException( 
                                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName)
                                     ); 
            } 

            ReflectionPermission operand = (ReflectionPermission)target; 

            ReflectionPermissionFlag newFlags = operand.m_flags & this.m_flags;

            if (newFlags == ReflectionPermissionFlag.NoFlags) 
                return null;
            else 
                return new ReflectionPermission( newFlags ); 
        }
 
        public override IPermission Copy()
        {
            if (this.IsUnrestricted())
            { 
                return new ReflectionPermission(PermissionState.Unrestricted);
            } 
            else 
            {
                return new ReflectionPermission((ReflectionPermissionFlag)m_flags); 
            }
        }

 
        //
        // IEncodable Interface 
 
        private
        void VerifyAccess(ReflectionPermissionFlag type) 
        {
            if ((type & ~ReflectionPermission.AllFlagsAndMore) != 0)
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)type));
        } 

 
        //----------------------------------------------------- 
        //
        // PUBLIC ENCODING METHODS 
        //
        //-----------------------------------------------------

        public override SecurityElement ToXml() 
        {
            SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.ReflectionPermission" ); 
            if (!IsUnrestricted()) 
            {
                esd.AddAttribute( "Flags", XMLUtil.BitFieldEnumToString( typeof( ReflectionPermissionFlag ), m_flags ) ); 
                }
            else
            {
                esd.AddAttribute( "Unrestricted", "true" ); 
            }
            return esd; 
        } 

        public override void FromXml(SecurityElement esd) 
        {
            CodeAccessPermission.ValidateElement( esd, this );
            if (XMLUtil.IsUnrestricted( esd ))
            { 
                m_flags = ReflectionPermission.AllFlagsAndMore;
                return; 
            } 

            Reset () ; 
            SetUnrestricted (false) ;

            String flags = esd.Attribute( "Flags" );
            if (flags != null) 
                m_flags = (ReflectionPermissionFlag)Enum.Parse( typeof( ReflectionPermissionFlag ), flags );
        } 
 
        /// 
        int IBuiltInPermission.GetTokenIndex() 
        {
            return ReflectionPermission.GetTokenIndex();
        }
 
        internal static int GetTokenIndex()
        { 
            return BuiltInPermissionIndex.ReflectionPermissionIndex; 
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// ReflectionPermission.cs
// 
 
namespace System.Security.Permissions
{ 
    using System;
    using System.IO;
    using System.Security.Util;
    using System.Text; 
    using System.Runtime.InteropServices;
    using System.Runtime.Remoting; 
    using System.Security; 
    using System.Reflection;
    using System.Globalization; 

    [ComVisible(true)]
    [Flags]
    [Serializable] 
    public enum ReflectionPermissionFlag
    { 
        NoFlags = 0x00, 
        [Obsolete("This API has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
        TypeInformation = 0x01, 
        MemberAccess = 0x02,
        ReflectionEmit = 0x04,
        [ComVisible(false)]
        RestrictedMemberAccess = 0x08, 
        AllFlags = 0x07
    } 
 
    [ComVisible(true)]
    [Serializable] 
    sealed public class ReflectionPermission
           : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
    {
        // ReflectionPermissionFlag.AllFlags doesn't contain the new value RestrictedMemberAccess, 
        // but we cannot change its value now because that will break apps that have that old value baked in.
        // We should use this const that truely contains "all" flags instead of ReflectionPermissionFlag.AllFlags. 
        internal const ReflectionPermissionFlag AllFlagsAndMore = ReflectionPermissionFlag.AllFlags | ReflectionPermissionFlag.RestrictedMemberAccess; 

        private ReflectionPermissionFlag m_flags; 

        //
        // Public Constructors
        // 

        public ReflectionPermission(PermissionState state) 
        { 
            if (state == PermissionState.Unrestricted)
            { 
                SetUnrestricted( true );
            }
            else if (state == PermissionState.None)
            { 
                SetUnrestricted( false );
            } 
            else 
            {
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState")); 
            }
        }

         // Parameters: 
         //
        public ReflectionPermission(ReflectionPermissionFlag flag) 
        { 
            VerifyAccess(flag);
 
            SetUnrestricted(false);
            m_flags = flag;
        }
 
        //------------------------------------------------------
        // 
        // PRIVATE AND PROTECTED MODIFIERS 
        //
        //----------------------------------------------------- 


        private void SetUnrestricted(bool unrestricted)
        { 
            if (unrestricted)
            { 
                m_flags = ReflectionPermission.AllFlagsAndMore; 
            }
            else 
            {
                Reset();
            }
        } 

 
        private void Reset() 
        {
            m_flags = ReflectionPermissionFlag.NoFlags; 
        }


        public ReflectionPermissionFlag Flags 
        {
            set 
            { 
                VerifyAccess(value);
 
                m_flags = value;
            }

            get 
            {
                return m_flags; 
            } 
        }
 

    #if ZERO   // Do not remove this code, usefull for debugging
        public override String ToString()
        { 
            StringBuilder sb = new StringBuilder();
            sb.Append("ReflectionPermission("); 
            if (IsUnrestricted()) 
            {
                sb.Append("Unrestricted"); 
            }
            else
            {
                if (GetFlag(ReflectionPermissionFlag.TypeInformation)) 
                    sb.Append("TypeInformation; ");
                if (GetFlag(ReflectionPermissionFlag.MemberAccess)) 
                    sb.Append("MemberAccess; "); 
                if (GetFlag(ReflectionPermissionFlag.ReflectionEmit))
                    sb.Append("ReflectionEmit; "); 
            }

            sb.Append(")");
            return sb.ToString(); 
        }
    #endif 
 

        // 
        // CodeAccessPermission implementation
        //

        public bool IsUnrestricted() 
        {
            return m_flags == ReflectionPermission.AllFlagsAndMore; 
        } 

        // 
        // IPermission implementation
        //

        public override IPermission Union(IPermission other) 
        {
            if (other == null) 
            { 
                return this.Copy();
            } 
            else if (!VerifyType(other))
            {
                throw new
                    ArgumentException( 
                                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName)
                                     ); 
            } 

            ReflectionPermission operand = (ReflectionPermission)other; 

            if (this.IsUnrestricted() || operand.IsUnrestricted())
            {
                return new ReflectionPermission( PermissionState.Unrestricted ); 
            }
            else 
            { 
                ReflectionPermissionFlag flag_union = (ReflectionPermissionFlag)(m_flags | operand.m_flags);
                return(new ReflectionPermission(flag_union)); 
            }
        }

 

        public override bool IsSubsetOf(IPermission target) 
        { 
            if (target == null)
            { 
                return m_flags == ReflectionPermissionFlag.NoFlags;
            }

            try 
            {
                ReflectionPermission operand = (ReflectionPermission)target; 
                if (operand.IsUnrestricted()) 
                    return true;
                else if (this.IsUnrestricted()) 
                    return false;
                else
                    return (((int)this.m_flags) & ~((int)operand.m_flags)) == 0;
            } 
            catch (InvalidCastException)
            { 
                throw new 
                    ArgumentException(
                                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName) 
                                     );
            }

        } 

        public override IPermission Intersect(IPermission target) 
        { 
            if (target == null)
                return null; 
            else if (!VerifyType(target))
            {
                throw new
                    ArgumentException( 
                                    String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_WrongType"), this.GetType().FullName)
                                     ); 
            } 

            ReflectionPermission operand = (ReflectionPermission)target; 

            ReflectionPermissionFlag newFlags = operand.m_flags & this.m_flags;

            if (newFlags == ReflectionPermissionFlag.NoFlags) 
                return null;
            else 
                return new ReflectionPermission( newFlags ); 
        }
 
        public override IPermission Copy()
        {
            if (this.IsUnrestricted())
            { 
                return new ReflectionPermission(PermissionState.Unrestricted);
            } 
            else 
            {
                return new ReflectionPermission((ReflectionPermissionFlag)m_flags); 
            }
        }

 
        //
        // IEncodable Interface 
 
        private
        void VerifyAccess(ReflectionPermissionFlag type) 
        {
            if ((type & ~ReflectionPermission.AllFlagsAndMore) != 0)
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)type));
        } 

 
        //----------------------------------------------------- 
        //
        // PUBLIC ENCODING METHODS 
        //
        //-----------------------------------------------------

        public override SecurityElement ToXml() 
        {
            SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.ReflectionPermission" ); 
            if (!IsUnrestricted()) 
            {
                esd.AddAttribute( "Flags", XMLUtil.BitFieldEnumToString( typeof( ReflectionPermissionFlag ), m_flags ) ); 
                }
            else
            {
                esd.AddAttribute( "Unrestricted", "true" ); 
            }
            return esd; 
        } 

        public override void FromXml(SecurityElement esd) 
        {
            CodeAccessPermission.ValidateElement( esd, this );
            if (XMLUtil.IsUnrestricted( esd ))
            { 
                m_flags = ReflectionPermission.AllFlagsAndMore;
                return; 
            } 

            Reset () ; 
            SetUnrestricted (false) ;

            String flags = esd.Attribute( "Flags" );
            if (flags != null) 
                m_flags = (ReflectionPermissionFlag)Enum.Parse( typeof( ReflectionPermissionFlag ), flags );
        } 
 
        /// 
        int IBuiltInPermission.GetTokenIndex() 
        {
            return ReflectionPermission.GetTokenIndex();
        }
 
        internal static int GetTokenIndex()
        { 
            return BuiltInPermissionIndex.ReflectionPermissionIndex; 
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• AngleUtil.cs
• TableAdapterManagerMethodGenerator.cs
• BezierSegment.cs
• DataGridViewLinkCell.cs
• Error.cs
• FlowDocumentPageViewerAutomationPeer.cs
• OleServicesContext.cs
• ToolStripPanelSelectionGlyph.cs
• StrongNameMembershipCondition.cs
• BinaryUtilClasses.cs
• XmlAttributeProperties.cs
• DefaultShape.cs
• CommunicationObjectAbortedException.cs
• BmpBitmapDecoder.cs
• GradientBrush.cs
• TableLayout.cs
• InputLanguageCollection.cs
• wgx_commands.cs
• ContainerAction.cs
• SupportingTokenChannel.cs
• RewritingProcessor.cs
• CustomSignedXml.cs
• CapabilitiesRule.cs
• SqlVisitor.cs
• PageThemeBuildProvider.cs
• BaseDataListPage.cs
• RubberbandSelector.cs
• AccessDataSourceView.cs
• xamlnodes.cs
• ComponentEditorForm.cs
• TextServicesCompartmentEventSink.cs
• InProcStateClientManager.cs
• DataGridParentRows.cs
• StylusPointPropertyUnit.cs
• XmlHierarchicalDataSourceView.cs
• RuntimeResourceSet.cs
• RoleService.cs
• ListViewItemSelectionChangedEvent.cs
• UpdateTracker.cs
• XNodeValidator.cs
• HttpWebResponse.cs
• BindableTemplateBuilder.cs
• COM2ExtendedBrowsingHandler.cs
• SapiGrammar.cs
• CodeParameterDeclarationExpressionCollection.cs
• FileSystemInfo.cs
• Regex.cs
• ToolStripSplitStackLayout.cs
• SimpleRecyclingCache.cs
• WindowCollection.cs
• StateManagedCollection.cs
• Stacktrace.cs
• unsafenativemethodstextservices.cs
• MachineSettingsSection.cs
• ExtensionDataReader.cs
• SaveCardRequest.cs
• DbConnectionInternal.cs
• AuthorizationPolicyTypeElementCollection.cs
• ContextMenuStrip.cs
• WindowsFormsLinkLabel.cs
• MailBnfHelper.cs
• DatatypeImplementation.cs
• WebException.cs
• PairComparer.cs
• DeviceContexts.cs
• StringToken.cs
• TypeToArgumentTypeConverter.cs
• RoutedEvent.cs
• KeyFrames.cs
• FieldBuilder.cs
• State.cs
• DefaultValidator.cs
• BigInt.cs
• Geometry3D.cs
• HttpRawResponse.cs
• Control.cs
• List.cs
• EnterpriseServicesHelper.cs
• FieldDescriptor.cs
• SQLGuid.cs
• TransformerConfigurationWizardBase.cs
• String.cs
• ButtonField.cs
• SqlBooleanMismatchVisitor.cs
• DiscardableAttribute.cs
• NetSectionGroup.cs
• RemoteWebConfigurationHost.cs
• Margins.cs
• StreamWithDictionary.cs
• PassportIdentity.cs
• MarginCollapsingState.cs
• DocumentViewerAutomationPeer.cs
• PageFunction.cs
• WindowsRichEditRange.cs
• NetTcpBindingElement.cs
• FileNotFoundException.cs
• DescendantQuery.cs
• CRYPTPROTECT_PROMPTSTRUCT.cs
• CanonicalFontFamilyReference.cs
• XmlSerializationReader.cs