EnvironmentPermission.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / clr / src / BCL / System / Security / Permissions / EnvironmentPermission.cs / 1 / EnvironmentPermission.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
//  EnvironmentPermission.cs
// 
 
namespace System.Security.Permissions {
    using System.Security; 
    using System;
    using SecurityElement = System.Security.SecurityElement;
    using System.Security.Util;
    using System.IO; 
    using System.Globalization;
 
    [Flags,Serializable] 
[System.Runtime.InteropServices.ComVisible(true)]
    public enum EnvironmentPermissionAccess 
    {
        NoAccess = 0x00,
        Read = 0x01,
        Write = 0x02, 
        AllAccess = 0x03,
    } 
 
    [Serializable] internal class EnvironmentStringExpressionSet : StringExpressionSet
    { 
        public EnvironmentStringExpressionSet()
            : base( true, null, false )
        {
        } 

        public EnvironmentStringExpressionSet( String str ) 
            : base( true, str, false ) 
        {
        } 

        protected override StringExpressionSet CreateNewEmpty()
        {
            return new EnvironmentStringExpressionSet(); 
        }
 
        protected override bool StringSubsetString( String left, String right, bool ignoreCase ) 
        {
            return (ignoreCase?(String.Compare( left, right, StringComparison.OrdinalIgnoreCase) == 0): 
                (String.Compare( left, right, StringComparison.Ordinal) == 0));
        }

        protected override String ProcessWholeString( String str ) 
        {
            return str; 
        } 

        protected override String ProcessSingleString( String str ) 
        {
            return str;
        }
    } 

[System.Runtime.InteropServices.ComVisible(true)] 
    [Serializable()] sealed public class EnvironmentPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission 
    {
        private StringExpressionSet m_read; 
        private StringExpressionSet m_write;
        private bool m_unrestricted;

        public EnvironmentPermission(PermissionState state) 
        {
            if (state == PermissionState.Unrestricted) 
                m_unrestricted = true; 
            else if (state == PermissionState.None)
                m_unrestricted = false; 
            else
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
        }
 
        public EnvironmentPermission( EnvironmentPermissionAccess flag, String pathList )
        { 
            SetPathList( flag, pathList ); 
        }
 
        public void SetPathList( EnvironmentPermissionAccess flag, String pathList )
        {
            VerifyFlag( flag );
 
            m_unrestricted = false;
 
            if ((flag & EnvironmentPermissionAccess.Read) != 0) 
                m_read = null;
 
            if ((flag & EnvironmentPermissionAccess.Write) != 0)
                m_write = null;

            AddPathList( flag, pathList ); 
        }
 
        public void AddPathList( EnvironmentPermissionAccess flag, String pathList ) 
        {
            VerifyFlag( flag ); 

            if (FlagIsSet( flag, EnvironmentPermissionAccess.Read ))
            {
                if (m_read == null) 
                    m_read = new EnvironmentStringExpressionSet();
                m_read.AddExpressions( pathList ); 
            } 

            if (FlagIsSet( flag, EnvironmentPermissionAccess.Write )) 
            {
                if (m_write == null)
                    m_write = new EnvironmentStringExpressionSet();
                m_write.AddExpressions( pathList ); 
            }
 
        } 

        public String GetPathList( EnvironmentPermissionAccess flag ) 
        {
            VerifyFlag( flag );
            ExclusiveFlag( flag );
 
            if (FlagIsSet( flag, EnvironmentPermissionAccess.Read ))
            { 
                if (m_read == null) 
                {
                    return ""; 
                }
                return m_read.ToString();
            }
 
            if (FlagIsSet( flag, EnvironmentPermissionAccess.Write ))
            { 
                if (m_write == null) 
                {
                    return ""; 
                }
                return m_write.ToString();
            }
 
            /* not reached */
 
            return ""; 
        }
 

        private void VerifyFlag( EnvironmentPermissionAccess flag )
        {
            if ((flag & ~EnvironmentPermissionAccess.AllAccess) != 0) 
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag));
        } 
 
        private void ExclusiveFlag( EnvironmentPermissionAccess flag )
        { 
            if (flag == EnvironmentPermissionAccess.NoAccess)
            {
                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") );
            } 

            if (((int)flag & ((int)flag-1)) != 0) 
            { 
                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") );
            } 
        }


        private bool FlagIsSet( EnvironmentPermissionAccess flag, EnvironmentPermissionAccess question ) 
        {
            return (flag & question) != 0; 
        } 

        private bool IsEmpty() 
        {
            return (!m_unrestricted &&
                    (this.m_read == null || this.m_read.IsEmpty()) &&
                    (this.m_write == null || this.m_write.IsEmpty())); 
        }
 
        //------------------------------------------------------ 
        //
        // CODEACCESSPERMISSION IMPLEMENTATION 
        //
        //-----------------------------------------------------

        public bool IsUnrestricted() 
        {
            return m_unrestricted; 
        } 

        //----------------------------------------------------- 
        //
        // IPERMISSION IMPLEMENTATION
        //
        //----------------------------------------------------- 

        public override bool IsSubsetOf(IPermission target) 
        { 
            if (target == null)
            { 
                return this.IsEmpty();
            }

            try 
            {
                EnvironmentPermission operand = (EnvironmentPermission)target; 
                if (operand.IsUnrestricted()) 
                    return true;
                else if (this.IsUnrestricted()) 
                    return false;
                else
                    return ((this.m_read == null || this.m_read.IsSubsetOf( operand.m_read )) &&
                            (this.m_write == null || this.m_write.IsSubsetOf( operand.m_write ))); 
            }
            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) 
                                     );
            } 
            else if (this.IsUnrestricted())
            {
                return target.Copy();
            } 

            EnvironmentPermission operand = (EnvironmentPermission)target; 
 
            if (operand.IsUnrestricted())
            { 
                return this.Copy();
            }

            StringExpressionSet intersectRead = this.m_read == null ? null : this.m_read.Intersect( operand.m_read ); 
            StringExpressionSet intersectWrite = this.m_write == null ? null : this.m_write.Intersect( operand.m_write );
 
            if ((intersectRead == null || intersectRead.IsEmpty()) && 
                (intersectWrite == null || intersectWrite.IsEmpty()))
            { 
                return null;
            }

            EnvironmentPermission intersectPermission = new EnvironmentPermission(PermissionState.None); 
            intersectPermission.m_unrestricted = false;
            intersectPermission.m_read = intersectRead; 
            intersectPermission.m_write = intersectWrite; 

            return intersectPermission; 
        }

        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) 
                                     );
            } 
 
            EnvironmentPermission operand = (EnvironmentPermission)other;
 
            if (this.IsUnrestricted() || operand.IsUnrestricted())
            {
                return new EnvironmentPermission( PermissionState.Unrestricted );
            } 

            StringExpressionSet unionRead = this.m_read == null ? operand.m_read : this.m_read.Union( operand.m_read ); 
            StringExpressionSet unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union( operand.m_write ); 

            if ((unionRead == null || unionRead.IsEmpty()) && 
                (unionWrite == null || unionWrite.IsEmpty()))
            {
                return null;
            } 

            EnvironmentPermission unionPermission = new EnvironmentPermission(PermissionState.None); 
            unionPermission.m_unrestricted = false; 
            unionPermission.m_read = unionRead;
            unionPermission.m_write = unionWrite; 

            return unionPermission;
        }
 
        public override IPermission Copy()
        { 
            EnvironmentPermission copy = new EnvironmentPermission(PermissionState.None); 
            if (this.m_unrestricted)
            { 
                copy.m_unrestricted = true;
            }
            else
            { 
                copy.m_unrestricted = false;
                if (this.m_read != null) 
                { 
                    copy.m_read = this.m_read.Copy();
                } 
                if (this.m_write != null)
                {
                    copy.m_write = this.m_write.Copy();
                } 

            } 
            return copy; 
        }
 
        public override SecurityElement ToXml()
        {
            SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.EnvironmentPermission" );
            if (!IsUnrestricted()) 
            {
                if (this.m_read != null && !this.m_read.IsEmpty()) 
                { 
                    esd.AddAttribute( "Read", SecurityElement.Escape( m_read.ToString() ) );
                } 
                if (this.m_write != null && !this.m_write.IsEmpty())
                {
                    esd.AddAttribute( "Write", SecurityElement.Escape( m_write.ToString() ) );
                } 
            }
            else 
            { 
                esd.AddAttribute( "Unrestricted", "true" );
            } 
            return esd;
        }

        public override void FromXml(SecurityElement esd) 
        {
            CodeAccessPermission.ValidateElement( esd, this ); 
 
            String et;
 
            if (XMLUtil.IsUnrestricted(esd))
            {
                m_unrestricted = true;
                return; 
            }
 
            m_unrestricted = false; 
            m_read = null;
            m_write = null; 

            et = esd.Attribute( "Read" );
            if (et != null)
            { 
                m_read = new EnvironmentStringExpressionSet( et );
            } 
 
            et = esd.Attribute( "Write" );
            if (et != null) 
            {
                m_write = new EnvironmentStringExpressionSet( et );
            }
 
        }
 
        ///  
        int IBuiltInPermission.GetTokenIndex()
        { 
            return EnvironmentPermission.GetTokenIndex();
        }

        internal static int GetTokenIndex() 
        {
            return BuiltInPermissionIndex.EnvironmentPermissionIndex; 
        } 
    }
 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
//  EnvironmentPermission.cs
// 
 
namespace System.Security.Permissions {
    using System.Security; 
    using System;
    using SecurityElement = System.Security.SecurityElement;
    using System.Security.Util;
    using System.IO; 
    using System.Globalization;
 
    [Flags,Serializable] 
[System.Runtime.InteropServices.ComVisible(true)]
    public enum EnvironmentPermissionAccess 
    {
        NoAccess = 0x00,
        Read = 0x01,
        Write = 0x02, 
        AllAccess = 0x03,
    } 
 
    [Serializable] internal class EnvironmentStringExpressionSet : StringExpressionSet
    { 
        public EnvironmentStringExpressionSet()
            : base( true, null, false )
        {
        } 

        public EnvironmentStringExpressionSet( String str ) 
            : base( true, str, false ) 
        {
        } 

        protected override StringExpressionSet CreateNewEmpty()
        {
            return new EnvironmentStringExpressionSet(); 
        }
 
        protected override bool StringSubsetString( String left, String right, bool ignoreCase ) 
        {
            return (ignoreCase?(String.Compare( left, right, StringComparison.OrdinalIgnoreCase) == 0): 
                (String.Compare( left, right, StringComparison.Ordinal) == 0));
        }

        protected override String ProcessWholeString( String str ) 
        {
            return str; 
        } 

        protected override String ProcessSingleString( String str ) 
        {
            return str;
        }
    } 

[System.Runtime.InteropServices.ComVisible(true)] 
    [Serializable()] sealed public class EnvironmentPermission : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission 
    {
        private StringExpressionSet m_read; 
        private StringExpressionSet m_write;
        private bool m_unrestricted;

        public EnvironmentPermission(PermissionState state) 
        {
            if (state == PermissionState.Unrestricted) 
                m_unrestricted = true; 
            else if (state == PermissionState.None)
                m_unrestricted = false; 
            else
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
        }
 
        public EnvironmentPermission( EnvironmentPermissionAccess flag, String pathList )
        { 
            SetPathList( flag, pathList ); 
        }
 
        public void SetPathList( EnvironmentPermissionAccess flag, String pathList )
        {
            VerifyFlag( flag );
 
            m_unrestricted = false;
 
            if ((flag & EnvironmentPermissionAccess.Read) != 0) 
                m_read = null;
 
            if ((flag & EnvironmentPermissionAccess.Write) != 0)
                m_write = null;

            AddPathList( flag, pathList ); 
        }
 
        public void AddPathList( EnvironmentPermissionAccess flag, String pathList ) 
        {
            VerifyFlag( flag ); 

            if (FlagIsSet( flag, EnvironmentPermissionAccess.Read ))
            {
                if (m_read == null) 
                    m_read = new EnvironmentStringExpressionSet();
                m_read.AddExpressions( pathList ); 
            } 

            if (FlagIsSet( flag, EnvironmentPermissionAccess.Write )) 
            {
                if (m_write == null)
                    m_write = new EnvironmentStringExpressionSet();
                m_write.AddExpressions( pathList ); 
            }
 
        } 

        public String GetPathList( EnvironmentPermissionAccess flag ) 
        {
            VerifyFlag( flag );
            ExclusiveFlag( flag );
 
            if (FlagIsSet( flag, EnvironmentPermissionAccess.Read ))
            { 
                if (m_read == null) 
                {
                    return ""; 
                }
                return m_read.ToString();
            }
 
            if (FlagIsSet( flag, EnvironmentPermissionAccess.Write ))
            { 
                if (m_write == null) 
                {
                    return ""; 
                }
                return m_write.ToString();
            }
 
            /* not reached */
 
            return ""; 
        }
 

        private void VerifyFlag( EnvironmentPermissionAccess flag )
        {
            if ((flag & ~EnvironmentPermissionAccess.AllAccess) != 0) 
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Arg_EnumIllegalVal"), (int)flag));
        } 
 
        private void ExclusiveFlag( EnvironmentPermissionAccess flag )
        { 
            if (flag == EnvironmentPermissionAccess.NoAccess)
            {
                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") );
            } 

            if (((int)flag & ((int)flag-1)) != 0) 
            { 
                throw new ArgumentException( Environment.GetResourceString("Arg_EnumNotSingleFlag") );
            } 
        }


        private bool FlagIsSet( EnvironmentPermissionAccess flag, EnvironmentPermissionAccess question ) 
        {
            return (flag & question) != 0; 
        } 

        private bool IsEmpty() 
        {
            return (!m_unrestricted &&
                    (this.m_read == null || this.m_read.IsEmpty()) &&
                    (this.m_write == null || this.m_write.IsEmpty())); 
        }
 
        //------------------------------------------------------ 
        //
        // CODEACCESSPERMISSION IMPLEMENTATION 
        //
        //-----------------------------------------------------

        public bool IsUnrestricted() 
        {
            return m_unrestricted; 
        } 

        //----------------------------------------------------- 
        //
        // IPERMISSION IMPLEMENTATION
        //
        //----------------------------------------------------- 

        public override bool IsSubsetOf(IPermission target) 
        { 
            if (target == null)
            { 
                return this.IsEmpty();
            }

            try 
            {
                EnvironmentPermission operand = (EnvironmentPermission)target; 
                if (operand.IsUnrestricted()) 
                    return true;
                else if (this.IsUnrestricted()) 
                    return false;
                else
                    return ((this.m_read == null || this.m_read.IsSubsetOf( operand.m_read )) &&
                            (this.m_write == null || this.m_write.IsSubsetOf( operand.m_write ))); 
            }
            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) 
                                     );
            } 
            else if (this.IsUnrestricted())
            {
                return target.Copy();
            } 

            EnvironmentPermission operand = (EnvironmentPermission)target; 
 
            if (operand.IsUnrestricted())
            { 
                return this.Copy();
            }

            StringExpressionSet intersectRead = this.m_read == null ? null : this.m_read.Intersect( operand.m_read ); 
            StringExpressionSet intersectWrite = this.m_write == null ? null : this.m_write.Intersect( operand.m_write );
 
            if ((intersectRead == null || intersectRead.IsEmpty()) && 
                (intersectWrite == null || intersectWrite.IsEmpty()))
            { 
                return null;
            }

            EnvironmentPermission intersectPermission = new EnvironmentPermission(PermissionState.None); 
            intersectPermission.m_unrestricted = false;
            intersectPermission.m_read = intersectRead; 
            intersectPermission.m_write = intersectWrite; 

            return intersectPermission; 
        }

        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) 
                                     );
            } 
 
            EnvironmentPermission operand = (EnvironmentPermission)other;
 
            if (this.IsUnrestricted() || operand.IsUnrestricted())
            {
                return new EnvironmentPermission( PermissionState.Unrestricted );
            } 

            StringExpressionSet unionRead = this.m_read == null ? operand.m_read : this.m_read.Union( operand.m_read ); 
            StringExpressionSet unionWrite = this.m_write == null ? operand.m_write : this.m_write.Union( operand.m_write ); 

            if ((unionRead == null || unionRead.IsEmpty()) && 
                (unionWrite == null || unionWrite.IsEmpty()))
            {
                return null;
            } 

            EnvironmentPermission unionPermission = new EnvironmentPermission(PermissionState.None); 
            unionPermission.m_unrestricted = false; 
            unionPermission.m_read = unionRead;
            unionPermission.m_write = unionWrite; 

            return unionPermission;
        }
 
        public override IPermission Copy()
        { 
            EnvironmentPermission copy = new EnvironmentPermission(PermissionState.None); 
            if (this.m_unrestricted)
            { 
                copy.m_unrestricted = true;
            }
            else
            { 
                copy.m_unrestricted = false;
                if (this.m_read != null) 
                { 
                    copy.m_read = this.m_read.Copy();
                } 
                if (this.m_write != null)
                {
                    copy.m_write = this.m_write.Copy();
                } 

            } 
            return copy; 
        }
 
        public override SecurityElement ToXml()
        {
            SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.EnvironmentPermission" );
            if (!IsUnrestricted()) 
            {
                if (this.m_read != null && !this.m_read.IsEmpty()) 
                { 
                    esd.AddAttribute( "Read", SecurityElement.Escape( m_read.ToString() ) );
                } 
                if (this.m_write != null && !this.m_write.IsEmpty())
                {
                    esd.AddAttribute( "Write", SecurityElement.Escape( m_write.ToString() ) );
                } 
            }
            else 
            { 
                esd.AddAttribute( "Unrestricted", "true" );
            } 
            return esd;
        }

        public override void FromXml(SecurityElement esd) 
        {
            CodeAccessPermission.ValidateElement( esd, this ); 
 
            String et;
 
            if (XMLUtil.IsUnrestricted(esd))
            {
                m_unrestricted = true;
                return; 
            }
 
            m_unrestricted = false; 
            m_read = null;
            m_write = null; 

            et = esd.Attribute( "Read" );
            if (et != null)
            { 
                m_read = new EnvironmentStringExpressionSet( et );
            } 
 
            et = esd.Attribute( "Write" );
            if (et != null) 
            {
                m_write = new EnvironmentStringExpressionSet( et );
            }
 
        }
 
        ///  
        int IBuiltInPermission.GetTokenIndex()
        { 
            return EnvironmentPermission.GetTokenIndex();
        }

        internal static int GetTokenIndex() 
        {
            return BuiltInPermissionIndex.EnvironmentPermissionIndex; 
        } 
    }
 
}

// 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

• Comparer.cs
• ByteAnimationUsingKeyFrames.cs
• EventMetadata.cs
• SubpageParagraph.cs
• PageBuildProvider.cs
• ellipse.cs
• AccessibleObject.cs
• ImageKeyConverter.cs
• TreeView.cs
• handlecollector.cs
• CachedCompositeFamily.cs
• XhtmlBasicTextBoxAdapter.cs
• ElementHostPropertyMap.cs
• CompiledRegexRunnerFactory.cs
• AbstractDataSvcMapFileLoader.cs
• HttpDateParse.cs
• DocumentPageHost.cs
• ElementNotEnabledException.cs
• AtomParser.cs
• CdpEqualityComparer.cs
• FontWeights.cs
• EFTableProvider.cs
• DrawingImage.cs
• SwitchLevelAttribute.cs
• LongPath.cs
• SharedPersonalizationStateInfo.cs
• BehaviorEditorPart.cs
• CqlParserHelpers.cs
• LinearKeyFrames.cs
• CodeAttributeDeclarationCollection.cs
• HelpKeywordAttribute.cs
• EditorPartCollection.cs
• OdbcConnectionHandle.cs
• SectionInput.cs
• ListViewSelectEventArgs.cs
• IsolatedStorageFileStream.cs
• DecimalAnimationUsingKeyFrames.cs
• ErrorWrapper.cs
• TextEffectCollection.cs
• KeysConverter.cs
• GeometryValueSerializer.cs
• RelationshipDetailsRow.cs
• COM2ComponentEditor.cs
• MessagePropertyAttribute.cs
• CrossAppDomainChannel.cs
• DbSourceCommand.cs
• ManifestSignatureInformation.cs
• CodeBinaryOperatorExpression.cs
• UnmanagedMemoryStream.cs
• SettingsProperty.cs
• HwndSourceParameters.cs
• ColumnHeader.cs
• TableSectionStyle.cs
• FormsIdentity.cs
• ComboBox.cs
• FixedDocumentPaginator.cs
• WebPartConnectionsDisconnectVerb.cs
• SchemaObjectWriter.cs
• CodeMemberMethod.cs
• OutputCacheSection.cs
• CollectionBase.cs
• BlockCollection.cs
• XmlDictionaryReader.cs
• DataSourceSelectArguments.cs
• PersonalizableTypeEntry.cs
• DataObjectSettingDataEventArgs.cs
• RouteTable.cs
• StrokeCollectionDefaultValueFactory.cs
• SiteMapProvider.cs
• DbProviderFactories.cs
• XmlAttributes.cs
• X500Name.cs
• TypefaceCollection.cs
• ThreadExceptionDialog.cs
• FlowLayout.cs
• BindToObject.cs
• ColorInterpolationModeValidation.cs
• safelink.cs
• CommunicationObject.cs
• WebPartTransformerCollection.cs
• QilList.cs
• RoutedEventConverter.cs
• LocatorPartList.cs
• OracleConnection.cs
• HtmlInputSubmit.cs
• UnsafeNativeMethodsPenimc.cs
• HttpListenerRequest.cs
• HttpCapabilitiesBase.cs
• DataReaderContainer.cs
• Int16AnimationBase.cs
• DataObject.cs
• BufferedWebEventProvider.cs
• ChtmlTextWriter.cs
• DataSourceCache.cs
• EnumValidator.cs
• ExpressionBuilder.cs
• ContractsBCL.cs
• MobileContainerDesigner.cs
• SimplePropertyEntry.cs
• ProvidersHelper.cs