SrgsRuleRef.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Speech / Src / Recognition / SrgsGrammar / SrgsRuleRef.cs / 1 / SrgsRuleRef.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: 
//
// History: 
//		5/1/2004	jeanfp		Created from the Kurosawa Code
//---------------------------------------------------------------------------
using System;
using System.ComponentModel; 
using System.Diagnostics;
using System.Speech.Internal; 
using System.Speech.Internal.SrgsParser; 
using System.Text;
using System.Xml; 

#pragma warning disable 1634, 1691 // Allows suppression of certain PreSharp messages.

namespace System.Speech.Recognition.SrgsGrammar 
{
    /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef"]/*' /> 
    [Serializable] 
    [ImmutableObject (true)]
    [DebuggerDisplay ("{DebuggerDisplayString()}")] 
    public class SrgsRuleRef : SrgsElement, IRuleRef
    {
        //*******************************************************************
        // 
        // Constructors
        // 
        //******************************************************************* 

        #region Constructors 

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef2"]/*' />
        public SrgsRuleRef (Uri uri)
        { 
            UriInit (uri, null, null, null);
        } 
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef2"]/*' />
        public SrgsRuleRef (Uri uri, string rule) 
        {
            Helpers.ThrowIfEmptyOrNull (rule, "rule");

            UriInit (uri, rule, null, null); 
        }
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' /> 
        public SrgsRuleRef (Uri uri, string rule, string semanticKey)
        { 
            Helpers.ThrowIfEmptyOrNull (semanticKey, "semanticKey");

            UriInit (uri, rule, semanticKey, null);
        } 

#if !NO_STG 
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' />
        public SrgsRuleRef (Uri uri, string rule, string semanticKey, string parameters) 
        {
            Helpers.ThrowIfEmptyOrNull (parameters, "parameters");

            UriInit (uri, rule, semanticKey, parameters); 
        }
 
#endif 

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' /> 
        public SrgsRuleRef (SrgsRule rule)
        {
            Helpers.ThrowIfNull (rule, "rule");
 
            _uri = new Uri ("#" + rule.Id, UriKind.Relative);
        } 
 
#if !NO_STG
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' />
        public SrgsRuleRef (SrgsRule rule, string semanticKey)
            : this (rule)
        { 
            Helpers.ThrowIfEmptyOrNull (semanticKey, "semanticKey");
 
            _semanticKey = semanticKey; 
        }
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' />
        public SrgsRuleRef (SrgsRule rule, string semanticKey, string parameters)
            : this (rule)
        { 
            Helpers.ThrowIfEmptyOrNull (parameters, "parameters");
 
#pragma warning disable 56504 // The public API is not that public so remove all the parameter validation. 
            _semanticKey = semanticKey;
#pragma warning restore 56504 // The public API is not that public so remove all the parameter validation. 

            _params = parameters;
        }
 
#endif
 
        /// 
 
        /// Special private constructor for Special Rulerefs
        /// 
 
        /// 
        private SrgsRuleRef (SpecialRuleRefType type)
        {
            _type = type; 
        }
 
        internal SrgsRuleRef (string semanticKey, string parameters, Uri uri) 
        {
            _uri = uri; 
            _semanticKey = semanticKey;
            _params = parameters;
        }
 
        #endregion
 
        //******************************************************************** 
        //
        // Public Properties 
        //
        //*******************************************************************

        #region public Properties 

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.Uri"]/*' /> 
        // Uri of the rule this rule reference references. 
        public Uri Uri
        { 
            get
            {
                return _uri;
            } 
        }
 
        /// 
 
        /// Set the semanticKey for a Ruleref
        /// 
 
        /// 
        public string SemanticKey
        {
            get 
            {
                return _semanticKey; 
            } 
        }
 
        /// 

        /// Set the init parameters for a Ruleref
        /// 
        ///  
        public string Params
        { 
            get 
            {
                return _params; 
            }
        }

        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRef.Null"]/*' /> 
        // The Null SpecialRuleRef defines a rule that is automatically matched:
        // that is, matched without the user speaking any word. 
        static public readonly SrgsRuleRef Null = new SrgsRuleRef (SpecialRuleRefType.Null); 

        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRef.Void"]/*' /> 
        // The Void SpecialRuleRef defines a rule that can never be spoken. Inserting
        // VOID into a sequence automatically makes that sequence unspeakable.
        static public readonly SrgsRuleRef Void = new SrgsRuleRef (SpecialRuleRefType.Void);
 
        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRef.Garbage"]/*' />
        // The Garbage SpecialRuleRef defines a rule that may match any speech up until 
        // the next rule match, the next token or until the end of spoken input. 
        static public readonly SrgsRuleRef Garbage = new SrgsRuleRef (SpecialRuleRefType.Garbage);
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.Dictation"]/*' />
        static public readonly SrgsRuleRef Dictation = new SrgsRuleRef (new Uri ("grammar:dictation"));

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.Dictation"]/*' /> 
        static public readonly SrgsRuleRef MnemonicSpelling = new SrgsRuleRef (new Uri ("grammar:dictation#spelling"));
 
        #endregion 

        //******************************************************************** 
        //
        // Internal methods
        //
        //******************************************************************** 

        #region Internal methods 
 
        internal override void WriteSrgs (XmlWriter writer)
        { 
            // Write 
            writer.WriteStartElement ("ruleref");
            if (_uri != null)
            { 
                writer.WriteAttributeString ("uri", _uri.ToString ());
            } 
            else 
            {
                string special; 
                switch (_type)
                {
                    case SpecialRuleRefType.Null:
                        special = "NULL"; 
                        break;
 
                    case SpecialRuleRefType.Void: 
                        special = "VOID";
                        break; 

                    case SpecialRuleRefType.Garbage:
                        special = "GARBAGE";
                        break; 

                    default: 
                        XmlParser.ThrowSrgsException (SRID.InvalidSpecialRuleRef); 
                        special = null;
                        break; 
                }
                writer.WriteAttributeString ("special", special);
            }
 
            // Write the 'name' attribute
            if (_semanticKey != null) 
            { 
                writer.WriteAttributeString ("sapi", "semantic-key", XmlParser.sapiNamespace, _semanticKey);
            } 

            // Write the 'params' attribute
            if (_params != null)
            { 
                writer.WriteAttributeString ("sapi", "params", XmlParser.sapiNamespace, _params);
            } 
 
            writer.WriteEndElement ();
        } 

        /// 

        /// Validate the SRGS element.
        /// 
 
        /// 
        internal override void Validate (SrgsGrammar grammar) 
        { 
            bool fScript = _params != null || _semanticKey != null;
#if !NO_STG 
            grammar._fContainsCode |= fScript;
#endif
            grammar.HasSapiExtension |= fScript;
 
            // Validate _uri
            if (_uri != null) 
            { 
                string sUri = _uri.ToString ();
                if (sUri [0] == '#') 
                {
                    bool uriFound = false;
                    if (sUri.IndexOf ("#grammar:dictation", StringComparison.Ordinal) == 0 || sUri.IndexOf ("#grammar:dictation#spelling", StringComparison.Ordinal) == 0)
                    { 
                        uriFound = true;
                    } 
                    else 
                    {
                        sUri = sUri.Substring (1); 
                        foreach (SrgsRule rule in grammar.Rules)
                        {
                            if (rule.Id == sUri)
                            { 
                                uriFound = true;
                                break; 
                            } 
                        }
                    } 

                    if (!uriFound)
                    {
                        XmlParser.ThrowSrgsException (SRID.UndefRuleRef, sUri); 
                    }
                } 
            } 

            base.Validate (grammar); 
        }

        internal override string DebuggerDisplayString ()
        { 
            StringBuilder sb = new StringBuilder ("SrgsRuleRef");
            if (_uri != null) 
            { 
                sb.Append (" uri='");
                sb.Append (_uri.ToString ()); 
                sb.Append ("'");
            }
            else
            { 
                sb.Append (" special='");
                sb.Append (_type.ToString ()); 
                sb.Append ("'"); 
            }
            return sb.ToString (); 
        }

        #endregion
 
        //*******************************************************************
        // 
        // Private Method 
        //
        //******************************************************************** 

        #region Private Method

        /// 
 
        /// Call by constructors. No check is made on the paramaters except for the the Uri
        /// 
 
        ///  
        /// 
        ///  
        /// 
        private void UriInit (Uri uri, string rule, string semanticKey, string initParameters)
        {
            Helpers.ThrowIfNull (uri, "uri"); 

            if (string.IsNullOrEmpty (rule)) 
            { 
                _uri = uri;
            } 
            else
            {
                _uri = new Uri (uri.ToString () + "#" + rule, UriKind.RelativeOrAbsolute);
            } 
            _semanticKey = semanticKey;
            _params = initParameters; 
        } 

        #endregion 

        //*******************************************************************
        //
        // Private Fields 
        //
        //******************************************************************* 
 
        #region Private Fields
 
        //*******************************************************************
        //
        // Private Enums
        // 
        //********************************************************************
 
        #region Private Enums 

        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType"]/*' /> 
        // Special rule references allow grammars based on CFGs to have powerful
        // additional features, such as transitions into dictation (both recognized
        // or not recognized) and word seqeuences from SAPI 5.0.
        private enum SpecialRuleRefType 
        {
            /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType.Null"]/*' /> 
            // Defines a rule that is automatically matched that is, matched without 
            // the user speaking any word.
            Null, 
            /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType.Void"]/*' />
            // Defines a rule that can never be spoken. Inserting VOID into a sequence
            // automatically makes that sequence unspeakable.
            Void, 
            /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType.Garbage"]/*' />
            // Defines a rule that may match any speech up until the next rule match, 
            // the next token or until the end of spoken input. 
            // Designed for applications that would like to recognize some phrases
            // without failing due to irrelevant, or ignorable words. 
            Garbage,
        }

        #endregion 

        // if the uri is null then it is a special rule ref 
        private Uri _uri; 

        private SpecialRuleRefType _type; 

        // Alias string for the semantic dictionary
        private string _semanticKey;
 
        // Alias string for the semantic dictionary
        private string _params; 
 
        #endregion
    } 
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// 
// Description: 
//
// History: 
//		5/1/2004	jeanfp		Created from the Kurosawa Code
//---------------------------------------------------------------------------
using System;
using System.ComponentModel; 
using System.Diagnostics;
using System.Speech.Internal; 
using System.Speech.Internal.SrgsParser; 
using System.Text;
using System.Xml; 

#pragma warning disable 1634, 1691 // Allows suppression of certain PreSharp messages.

namespace System.Speech.Recognition.SrgsGrammar 
{
    /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef"]/*' /> 
    [Serializable] 
    [ImmutableObject (true)]
    [DebuggerDisplay ("{DebuggerDisplayString()}")] 
    public class SrgsRuleRef : SrgsElement, IRuleRef
    {
        //*******************************************************************
        // 
        // Constructors
        // 
        //******************************************************************* 

        #region Constructors 

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef2"]/*' />
        public SrgsRuleRef (Uri uri)
        { 
            UriInit (uri, null, null, null);
        } 
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef2"]/*' />
        public SrgsRuleRef (Uri uri, string rule) 
        {
            Helpers.ThrowIfEmptyOrNull (rule, "rule");

            UriInit (uri, rule, null, null); 
        }
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' /> 
        public SrgsRuleRef (Uri uri, string rule, string semanticKey)
        { 
            Helpers.ThrowIfEmptyOrNull (semanticKey, "semanticKey");

            UriInit (uri, rule, semanticKey, null);
        } 

#if !NO_STG 
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' />
        public SrgsRuleRef (Uri uri, string rule, string semanticKey, string parameters) 
        {
            Helpers.ThrowIfEmptyOrNull (parameters, "parameters");

            UriInit (uri, rule, semanticKey, parameters); 
        }
 
#endif 

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' /> 
        public SrgsRuleRef (SrgsRule rule)
        {
            Helpers.ThrowIfNull (rule, "rule");
 
            _uri = new Uri ("#" + rule.Id, UriKind.Relative);
        } 
 
#if !NO_STG
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' />
        public SrgsRuleRef (SrgsRule rule, string semanticKey)
            : this (rule)
        { 
            Helpers.ThrowIfEmptyOrNull (semanticKey, "semanticKey");
 
            _semanticKey = semanticKey; 
        }
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.RuleRef3"]/*' />
        public SrgsRuleRef (SrgsRule rule, string semanticKey, string parameters)
            : this (rule)
        { 
            Helpers.ThrowIfEmptyOrNull (parameters, "parameters");
 
#pragma warning disable 56504 // The public API is not that public so remove all the parameter validation. 
            _semanticKey = semanticKey;
#pragma warning restore 56504 // The public API is not that public so remove all the parameter validation. 

            _params = parameters;
        }
 
#endif
 
        /// 
 
        /// Special private constructor for Special Rulerefs
        /// 
 
        /// 
        private SrgsRuleRef (SpecialRuleRefType type)
        {
            _type = type; 
        }
 
        internal SrgsRuleRef (string semanticKey, string parameters, Uri uri) 
        {
            _uri = uri; 
            _semanticKey = semanticKey;
            _params = parameters;
        }
 
        #endregion
 
        //******************************************************************** 
        //
        // Public Properties 
        //
        //*******************************************************************

        #region public Properties 

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.Uri"]/*' /> 
        // Uri of the rule this rule reference references. 
        public Uri Uri
        { 
            get
            {
                return _uri;
            } 
        }
 
        /// 
 
        /// Set the semanticKey for a Ruleref
        /// 
 
        /// 
        public string SemanticKey
        {
            get 
            {
                return _semanticKey; 
            } 
        }
 
        /// 

        /// Set the init parameters for a Ruleref
        /// 
        ///  
        public string Params
        { 
            get 
            {
                return _params; 
            }
        }

        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRef.Null"]/*' /> 
        // The Null SpecialRuleRef defines a rule that is automatically matched:
        // that is, matched without the user speaking any word. 
        static public readonly SrgsRuleRef Null = new SrgsRuleRef (SpecialRuleRefType.Null); 

        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRef.Void"]/*' /> 
        // The Void SpecialRuleRef defines a rule that can never be spoken. Inserting
        // VOID into a sequence automatically makes that sequence unspeakable.
        static public readonly SrgsRuleRef Void = new SrgsRuleRef (SpecialRuleRefType.Void);
 
        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRef.Garbage"]/*' />
        // The Garbage SpecialRuleRef defines a rule that may match any speech up until 
        // the next rule match, the next token or until the end of spoken input. 
        static public readonly SrgsRuleRef Garbage = new SrgsRuleRef (SpecialRuleRefType.Garbage);
 
        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.Dictation"]/*' />
        static public readonly SrgsRuleRef Dictation = new SrgsRuleRef (new Uri ("grammar:dictation"));

        /// TODOC <_include file='doc\RuleRef.uex' path='docs/doc[@for="RuleRef.Dictation"]/*' /> 
        static public readonly SrgsRuleRef MnemonicSpelling = new SrgsRuleRef (new Uri ("grammar:dictation#spelling"));
 
        #endregion 

        //******************************************************************** 
        //
        // Internal methods
        //
        //******************************************************************** 

        #region Internal methods 
 
        internal override void WriteSrgs (XmlWriter writer)
        { 
            // Write 
            writer.WriteStartElement ("ruleref");
            if (_uri != null)
            { 
                writer.WriteAttributeString ("uri", _uri.ToString ());
            } 
            else 
            {
                string special; 
                switch (_type)
                {
                    case SpecialRuleRefType.Null:
                        special = "NULL"; 
                        break;
 
                    case SpecialRuleRefType.Void: 
                        special = "VOID";
                        break; 

                    case SpecialRuleRefType.Garbage:
                        special = "GARBAGE";
                        break; 

                    default: 
                        XmlParser.ThrowSrgsException (SRID.InvalidSpecialRuleRef); 
                        special = null;
                        break; 
                }
                writer.WriteAttributeString ("special", special);
            }
 
            // Write the 'name' attribute
            if (_semanticKey != null) 
            { 
                writer.WriteAttributeString ("sapi", "semantic-key", XmlParser.sapiNamespace, _semanticKey);
            } 

            // Write the 'params' attribute
            if (_params != null)
            { 
                writer.WriteAttributeString ("sapi", "params", XmlParser.sapiNamespace, _params);
            } 
 
            writer.WriteEndElement ();
        } 

        /// 

        /// Validate the SRGS element.
        /// 
 
        /// 
        internal override void Validate (SrgsGrammar grammar) 
        { 
            bool fScript = _params != null || _semanticKey != null;
#if !NO_STG 
            grammar._fContainsCode |= fScript;
#endif
            grammar.HasSapiExtension |= fScript;
 
            // Validate _uri
            if (_uri != null) 
            { 
                string sUri = _uri.ToString ();
                if (sUri [0] == '#') 
                {
                    bool uriFound = false;
                    if (sUri.IndexOf ("#grammar:dictation", StringComparison.Ordinal) == 0 || sUri.IndexOf ("#grammar:dictation#spelling", StringComparison.Ordinal) == 0)
                    { 
                        uriFound = true;
                    } 
                    else 
                    {
                        sUri = sUri.Substring (1); 
                        foreach (SrgsRule rule in grammar.Rules)
                        {
                            if (rule.Id == sUri)
                            { 
                                uriFound = true;
                                break; 
                            } 
                        }
                    } 

                    if (!uriFound)
                    {
                        XmlParser.ThrowSrgsException (SRID.UndefRuleRef, sUri); 
                    }
                } 
            } 

            base.Validate (grammar); 
        }

        internal override string DebuggerDisplayString ()
        { 
            StringBuilder sb = new StringBuilder ("SrgsRuleRef");
            if (_uri != null) 
            { 
                sb.Append (" uri='");
                sb.Append (_uri.ToString ()); 
                sb.Append ("'");
            }
            else
            { 
                sb.Append (" special='");
                sb.Append (_type.ToString ()); 
                sb.Append ("'"); 
            }
            return sb.ToString (); 
        }

        #endregion
 
        //*******************************************************************
        // 
        // Private Method 
        //
        //******************************************************************** 

        #region Private Method

        /// 
 
        /// Call by constructors. No check is made on the paramaters except for the the Uri
        /// 
 
        ///  
        /// 
        ///  
        /// 
        private void UriInit (Uri uri, string rule, string semanticKey, string initParameters)
        {
            Helpers.ThrowIfNull (uri, "uri"); 

            if (string.IsNullOrEmpty (rule)) 
            { 
                _uri = uri;
            } 
            else
            {
                _uri = new Uri (uri.ToString () + "#" + rule, UriKind.RelativeOrAbsolute);
            } 
            _semanticKey = semanticKey;
            _params = initParameters; 
        } 

        #endregion 

        //*******************************************************************
        //
        // Private Fields 
        //
        //******************************************************************* 
 
        #region Private Fields
 
        //*******************************************************************
        //
        // Private Enums
        // 
        //********************************************************************
 
        #region Private Enums 

        /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType"]/*' /> 
        // Special rule references allow grammars based on CFGs to have powerful
        // additional features, such as transitions into dictation (both recognized
        // or not recognized) and word seqeuences from SAPI 5.0.
        private enum SpecialRuleRefType 
        {
            /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType.Null"]/*' /> 
            // Defines a rule that is automatically matched that is, matched without 
            // the user speaking any word.
            Null, 
            /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType.Void"]/*' />
            // Defines a rule that can never be spoken. Inserting VOID into a sequence
            // automatically makes that sequence unspeakable.
            Void, 
            /// TODOC <_include file='doc\SpecialRuleRef.uex' path='docs/doc[@for="SpecialRuleRefType.Garbage"]/*' />
            // Defines a rule that may match any speech up until the next rule match, 
            // the next token or until the end of spoken input. 
            // Designed for applications that would like to recognize some phrases
            // without failing due to irrelevant, or ignorable words. 
            Garbage,
        }

        #endregion 

        // if the uri is null then it is a special rule ref 
        private Uri _uri; 

        private SpecialRuleRefType _type; 

        // Alias string for the semantic dictionary
        private string _semanticKey;
 
        // Alias string for the semantic dictionary
        private string _params; 
 
        #endregion
    } 
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

                        

                        

                        
                        

Link Menu

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

• HttpWebRequestElement.cs
• StorageAssociationSetMapping.cs
• InputBinding.cs
• LogAppendAsyncResult.cs
• ToolStripPanel.cs
• IteratorFilter.cs
• XsltContext.cs
• ResXBuildProvider.cs
• SeparatorAutomationPeer.cs
• EnumerableRowCollectionExtensions.cs
• ProcessInputEventArgs.cs
• FormatConvertedBitmap.cs
• EditorAttributeInfo.cs
• SmiMetaDataProperty.cs
• FixedSOMFixedBlock.cs
• WebPartCatalogAddVerb.cs
• UMPAttributes.cs
• ToolStripDropDownClosingEventArgs.cs
• SafeNativeMethods.cs
• FixedFindEngine.cs
• UIHelper.cs
• SelectedGridItemChangedEvent.cs
• LinqDataSourceDeleteEventArgs.cs
• RichTextBoxContextMenu.cs
• HttpRawResponse.cs
• MailAddressParser.cs
• ReadWriteSpinLock.cs
• LinkDesigner.cs
• BitArray.cs
• HistoryEventArgs.cs
• OleCmdHelper.cs
• SmtpFailedRecipientsException.cs
• ObfuscationAttribute.cs
• TypeDescriptionProvider.cs
• ScopedKnownTypes.cs
• NestPullup.cs
• DownloadProgressEventArgs.cs
• HMAC.cs
• CompositeFontFamily.cs
• Flattener.cs
• StackSpiller.Temps.cs
• shaper.cs
• ArglessEventHandlerProxy.cs
• SafeWaitHandle.cs
• StreamInfo.cs
• ToolStripItemClickedEventArgs.cs
• Visitor.cs
• PropertyDescriptor.cs
• XmlWrappingWriter.cs
• FunctionUpdateCommand.cs
• ApplicationHost.cs
• ValidatedMobileControlConverter.cs
• X509ChainPolicy.cs
• CalendarTable.cs
• RoleManagerSection.cs
• ISAPIApplicationHost.cs
• MetadataFile.cs
• SymDocumentType.cs
• ForceCopyBuildProvider.cs
• BasicHttpMessageSecurityElement.cs
• XPathChildIterator.cs
• WebPartConnectionsConfigureVerb.cs
• BoolExpressionVisitors.cs
• SecurityProtocolCorrelationState.cs
• CheckBoxAutomationPeer.cs
• LifetimeServices.cs
• InputLangChangeRequestEvent.cs
• TrackingStringDictionary.cs
• GeneralTransform.cs
• QilPatternFactory.cs
• webbrowsersite.cs
• InvalidCastException.cs
• TemplateNameScope.cs
• BitmapFrame.cs
• WindowsRichEditRange.cs
• ScrollProperties.cs
• RuleCache.cs
• CodeNamespaceCollection.cs
• ClockController.cs
• BitmapEffectInputData.cs
• NonParentingControl.cs
• GridLengthConverter.cs
• PerformanceCounterCategory.cs
• DrawingContextWalker.cs
• Exception.cs
• WebPartDescription.cs
• ResourceContainer.cs
• QueryCacheKey.cs
• ControlParameter.cs
• Double.cs
• AdPostCacheSubstitution.cs
• InternalDispatchObject.cs
• TranslateTransform.cs
• WebEvents.cs
• IProvider.cs
• CompiledELinqQueryState.cs
• WorkItem.cs
• basevalidator.cs
• GrammarBuilderBase.cs
• Processor.cs