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

• PackageProperties.cs
• CharacterString.cs
• HitTestParameters.cs
• _CommandStream.cs
• SystemSounds.cs
• BaseTemplateCodeDomTreeGenerator.cs
• TextBoxAutoCompleteSourceConverter.cs
• SQLMoneyStorage.cs
• PointHitTestParameters.cs
• ContainerUtilities.cs
• FixedNode.cs
• ScopelessEnumAttribute.cs
• IOException.cs
• SafeNativeMethods.cs
• SelectorAutomationPeer.cs
• ResourcePropertyMemberCodeDomSerializer.cs
• ToolStripItemTextRenderEventArgs.cs
• EmptyElement.cs
• NavigationFailedEventArgs.cs
• TreeView.cs
• RoutedEventHandlerInfo.cs
• TypeSystem.cs
• GlyphCache.cs
• WebPartVerb.cs
• BaseDataList.cs
• ScriptControlManager.cs
• StylusOverProperty.cs
• ManifestResourceInfo.cs
• GlobalizationSection.cs
• MimeTextImporter.cs
• PresentationTraceSources.cs
• CanonicalXml.cs
• PartitionResolver.cs
• MatrixAnimationUsingPath.cs
• ReadOnlyTernaryTree.cs
• CommonDialog.cs
• GeometryModel3D.cs
• IisTraceWebEventProvider.cs
• SqlCacheDependencyDatabase.cs
• FormsAuthenticationUserCollection.cs
• BindingMAnagerBase.cs
• Interlocked.cs
• PackWebRequestFactory.cs
• IgnoreSectionHandler.cs
• ObjectListShowCommandsEventArgs.cs
• XmlSerializationWriter.cs
• HostSecurityManager.cs
• VerificationAttribute.cs
• CollectionAdapters.cs
• InlinedAggregationOperator.cs
• AutomationPatternInfo.cs
• SspiNegotiationTokenProvider.cs
• TabControlEvent.cs
• PeerApplicationLaunchInfo.cs
• CodeArgumentReferenceExpression.cs
• MemberDescriptor.cs
• DocComment.cs
• ScaleTransform.cs
• XmlSerializationReader.cs
• ButtonColumn.cs
• MeasureData.cs
• TrackingRecordPreFilter.cs
• PropertyDescriptorGridEntry.cs
• DesignerActionUI.cs
• ServiceDescriptionImporter.cs
• ThreadAttributes.cs
• TransactionChannelFaultConverter.cs
• SqlServer2KCompatibilityCheck.cs
• smtppermission.cs
• SystemEvents.cs
• DataGridViewColumnDesigner.cs
• ApplicationTrust.cs
• XmlEncodedRawTextWriter.cs
• DocumentPaginator.cs
• StylusDevice.cs
• EventsTab.cs
• TemplateControlBuildProvider.cs
• Sequence.cs
• MyContact.cs
• columnmapkeybuilder.cs
• GradientBrush.cs
• CheckBoxFlatAdapter.cs
• ResourceDefaultValueAttribute.cs
• HierarchicalDataBoundControl.cs
• DigestTraceRecordHelper.cs
• XmlCharType.cs
• WeakReferenceKey.cs
• SoapIgnoreAttribute.cs
• TraceListeners.cs
• TreeViewAutomationPeer.cs
• PathFigureCollectionConverter.cs
• DataControlPagerLinkButton.cs
• XPathNavigatorKeyComparer.cs
• FormsAuthenticationUserCollection.cs
• TCPClient.cs
• OleAutBinder.cs
• DataServiceResponse.cs
• DbResourceAllocator.cs
• TreeViewImageKeyConverter.cs
• ConfigurationSectionGroupCollection.cs