CounterSampleCalculator.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Services / Monitoring / system / Diagnosticts / CounterSampleCalculator.cs / 1305376 / CounterSampleCalculator.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Diagnostics { 
    using System.Threading; 
    using System;
    using System.ComponentModel; 
    using Microsoft.Win32;
    using System.Text;
    using System.IO;
    using System.Runtime.InteropServices; 
    using System.Security.Permissions;
    using System.Globalization; 
    using System.Runtime.Versioning; 

    ///  
    ///     Set of utility functions for interpreting the counter data
    ///     NOTE: most of this code was taken and ported from counters.c (PerfMon source code)
    /// 
    public static class CounterSampleCalculator { 
        static bool perfCounterDllLoaded = false;
 
        ///  
        ///    Converts 100NS elapsed time to fractional seconds
        ///  
        /// 
        private static float GetElapsedTime(CounterSample oldSample, CounterSample newSample) {
            float eSeconds;
            float eDifference; 

            if (newSample.RawValue == 0) { 
                // no data [start time = 0] so return 0 
                return 0.0f;
            } 
            else {
                float eFreq;
                eFreq = (float)(ulong)oldSample.CounterFrequency;
 
                if (oldSample.UnsignedRawValue >= (ulong)newSample.CounterTimeStamp || eFreq <= 0.0f)
                    return 0.0f; 
 
                // otherwise compute difference between current time and start time
                eDifference = (float)((ulong)newSample.CounterTimeStamp - oldSample.UnsignedRawValue); 

                // convert to fractional seconds using object counter
                eSeconds = eDifference / eFreq;
 
                return eSeconds;
            } 
        } 

        ///  
        ///    Computes the calculated value given a raw counter sample.
        /// 
        public static float ComputeCounterValue(CounterSample newSample) {
            return ComputeCounterValue(CounterSample.Empty, newSample); 
        }
 
        ///  
        ///    Computes the calculated value given a raw counter sample.
        ///  
        public static float ComputeCounterValue(CounterSample oldSample, CounterSample newSample) {
            int newCounterType = (int) newSample.CounterType;
            if (oldSample.SystemFrequency == 0) {
                if ((newCounterType != NativeMethods.PERF_RAW_FRACTION) && 
                    (newCounterType != NativeMethods.PERF_COUNTER_RAWCOUNT) &&
                    (newCounterType != NativeMethods.PERF_COUNTER_RAWCOUNT_HEX) && 
                    (newCounterType != NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT) && 
                    (newCounterType != NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT_HEX) &&
                    (newCounterType != NativeMethods.PERF_COUNTER_MULTI_BASE)) { 

                    // Since oldSample has a system frequency of 0, this means the newSample is the first sample
                    // on a two sample calculation.  Since we can't do anything with it, return 0.
                    return 0.0f; 
                }
            } 
            else if (oldSample.CounterType != newSample.CounterType) { 
                throw new InvalidOperationException(SR.GetString(SR.MismatchedCounterTypes));
            } 

            if (newCounterType == NativeMethods.PERF_ELAPSED_TIME)
                return (float)GetElapsedTime(oldSample, newSample);
 
            NativeMethods.PDH_RAW_COUNTER newPdhValue = new NativeMethods.PDH_RAW_COUNTER();
            NativeMethods.PDH_RAW_COUNTER oldPdhValue = new NativeMethods.PDH_RAW_COUNTER(); 
 
            FillInValues(oldSample, newSample, oldPdhValue, newPdhValue);
 
            LoadPerfCounterDll();

            NativeMethods.PDH_FMT_COUNTERVALUE pdhFormattedValue= new NativeMethods.PDH_FMT_COUNTERVALUE();
            long timeBase = newSample.SystemFrequency; 
            int result = SafeNativeMethods.FormatFromRawValue((uint) newCounterType, NativeMethods.PDH_FMT_DOUBLE | NativeMethods.PDH_FMT_NOSCALE | NativeMethods.PDH_FMT_NOCAP100,
                                                          ref timeBase, newPdhValue, oldPdhValue, pdhFormattedValue); 
 
            if (result != NativeMethods.ERROR_SUCCESS) {
                // If the numbers go negative, just return 0.  This better matches the old behavior. 
                if (result == NativeMethods.PDH_CALC_NEGATIVE_VALUE || result == NativeMethods.PDH_CALC_NEGATIVE_DENOMINATOR || result == NativeMethods.PDH_NO_DATA)
                    return 0;
                else
                    throw new Win32Exception(result, SR.GetString(SR.PerfCounterPdhError, result.ToString("x", CultureInfo.InvariantCulture))); 
            }
 
            return (float) pdhFormattedValue.data; 

        } 


        // This method figures out which values are supposed to go into which structures so that PDH can do the
        // calculation for us.  This was ported from Window's cutils.c 
        private static void FillInValues(CounterSample oldSample, CounterSample newSample, NativeMethods.PDH_RAW_COUNTER oldPdhValue, NativeMethods.PDH_RAW_COUNTER newPdhValue) {
            int newCounterType = (int) newSample.CounterType; 
 
            switch (newCounterType) {
                case NativeMethods.PERF_COUNTER_COUNTER: 
                case NativeMethods.PERF_COUNTER_QUEUELEN_TYPE:
                case NativeMethods.PERF_SAMPLE_COUNTER:
                case NativeMethods.PERF_OBJ_TIME_TIMER:
                case NativeMethods.PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE: 
                    newPdhValue.FirstValue  = newSample.RawValue;
                    newPdhValue.SecondValue = newSample.TimeStamp; 
 
                    oldPdhValue.FirstValue  = oldSample.RawValue;
                    oldPdhValue.SecondValue = oldSample.TimeStamp; 
                    break;

                case NativeMethods.PERF_COUNTER_100NS_QUEUELEN_TYPE:
                    newPdhValue.FirstValue  = newSample.RawValue; 
                    newPdhValue.SecondValue = newSample.TimeStamp100nSec;
 
                    oldPdhValue.FirstValue  = oldSample.RawValue; 
                    oldPdhValue.SecondValue = oldSample.TimeStamp100nSec;
                    break; 

                case NativeMethods.PERF_COUNTER_TIMER:
                case NativeMethods.PERF_COUNTER_TIMER_INV:
                case NativeMethods.PERF_COUNTER_BULK_COUNT: 
                case NativeMethods.PERF_COUNTER_LARGE_QUEUELEN_TYPE:
                case NativeMethods.PERF_COUNTER_MULTI_TIMER: 
                case NativeMethods.PERF_COUNTER_MULTI_TIMER_INV: 
                    newPdhValue.FirstValue  = newSample.RawValue;
                    newPdhValue.SecondValue = newSample.TimeStamp; 

                    oldPdhValue.FirstValue  = oldSample.RawValue;
                    oldPdhValue.SecondValue = oldSample.TimeStamp;
                    if (newCounterType == NativeMethods.PERF_COUNTER_MULTI_TIMER || newCounterType == NativeMethods.PERF_COUNTER_MULTI_TIMER_INV) { 
                        //  this is to make PDH work like PERFMON for
                        //  this counter type 
                        newPdhValue.FirstValue *= (uint) newSample.CounterFrequency; 
                        if (oldSample.CounterFrequency != 0) {
                            oldPdhValue.FirstValue *= (uint) oldSample.CounterFrequency; 
                        }
                    }

                    if ((newCounterType & NativeMethods.PERF_MULTI_COUNTER) == NativeMethods.PERF_MULTI_COUNTER) { 
                            newPdhValue.MultiCount = (int) newSample.BaseValue;
                            oldPdhValue.MultiCount = (int) oldSample.BaseValue; 
                    } 

 
                    break;
                //
                //  These counters do not use any time reference
                // 
                case NativeMethods.PERF_COUNTER_RAWCOUNT:
                case NativeMethods.PERF_COUNTER_RAWCOUNT_HEX: 
                case NativeMethods.PERF_COUNTER_DELTA: 
                case NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT:
                case NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT_HEX: 
                case NativeMethods.PERF_COUNTER_LARGE_DELTA:
                    newPdhValue.FirstValue  = newSample.RawValue;
                    newPdhValue.SecondValue = 0;
 
                    oldPdhValue.FirstValue  = oldSample.RawValue;
                    oldPdhValue.SecondValue = 0; 
                    break; 
                //
                //  These counters use the 100 Ns time base in thier calculation 
                //
                case NativeMethods.PERF_100NSEC_TIMER:
                case NativeMethods.PERF_100NSEC_TIMER_INV:
                case NativeMethods.PERF_100NSEC_MULTI_TIMER: 
                case NativeMethods.PERF_100NSEC_MULTI_TIMER_INV:
                    newPdhValue.FirstValue  = newSample.RawValue; 
                    newPdhValue.SecondValue = newSample.TimeStamp100nSec; 

                    oldPdhValue.FirstValue  = oldSample.RawValue; 
                    oldPdhValue.SecondValue = oldSample.TimeStamp100nSec;
                    if ((newCounterType & NativeMethods.PERF_MULTI_COUNTER) == NativeMethods.PERF_MULTI_COUNTER) {
                        newPdhValue.MultiCount = (int) newSample.BaseValue;
                        oldPdhValue.MultiCount = (int) oldSample.BaseValue; 
                    }
                    break; 
                // 
                //  These counters use two data points
                // 
                case NativeMethods.PERF_SAMPLE_FRACTION:
                case NativeMethods.PERF_RAW_FRACTION:
                case NativeMethods.PERF_LARGE_RAW_FRACTION:
                case NativeMethods.PERF_PRECISION_SYSTEM_TIMER: 
                case NativeMethods.PERF_PRECISION_100NS_TIMER:
                case NativeMethods.PERF_PRECISION_OBJECT_TIMER: 
                case NativeMethods.PERF_AVERAGE_TIMER: 
                case NativeMethods.PERF_AVERAGE_BULK:
                    newPdhValue.FirstValue = newSample.RawValue; 
                    newPdhValue.SecondValue = newSample.BaseValue;

                    oldPdhValue.FirstValue = oldSample.RawValue;
                    oldPdhValue.SecondValue = oldSample.BaseValue; 
                    break;
 
                default: 
                    // an unidentified counter was returned so
                    newPdhValue.FirstValue  = 0; 
                    newPdhValue.SecondValue = 0;

                    oldPdhValue.FirstValue  = 0;
                    oldPdhValue.SecondValue = 0; 
                    break;
            } 
        } 

        [ResourceExposure(ResourceScope.None)] 
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        private static void LoadPerfCounterDll() {
            if (perfCounterDllLoaded)
                return; 

            new FileIOPermission(PermissionState.Unrestricted).Assert(); 
 
            string installPath = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory();
            string perfcounterPath = Path.Combine(installPath, "perfcounter.dll"); 
            if (SafeNativeMethods.LoadLibrary(perfcounterPath) == IntPtr.Zero) {
                throw new Win32Exception( Marshal.GetLastWin32Error() );
            }
 
            perfCounterDllLoaded = true;
        } 
    } 
}
 

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

namespace System.Diagnostics { 
    using System.Threading; 
    using System;
    using System.ComponentModel; 
    using Microsoft.Win32;
    using System.Text;
    using System.IO;
    using System.Runtime.InteropServices; 
    using System.Security.Permissions;
    using System.Globalization; 
    using System.Runtime.Versioning; 

    ///  
    ///     Set of utility functions for interpreting the counter data
    ///     NOTE: most of this code was taken and ported from counters.c (PerfMon source code)
    /// 
    public static class CounterSampleCalculator { 
        static bool perfCounterDllLoaded = false;
 
        ///  
        ///    Converts 100NS elapsed time to fractional seconds
        ///  
        /// 
        private static float GetElapsedTime(CounterSample oldSample, CounterSample newSample) {
            float eSeconds;
            float eDifference; 

            if (newSample.RawValue == 0) { 
                // no data [start time = 0] so return 0 
                return 0.0f;
            } 
            else {
                float eFreq;
                eFreq = (float)(ulong)oldSample.CounterFrequency;
 
                if (oldSample.UnsignedRawValue >= (ulong)newSample.CounterTimeStamp || eFreq <= 0.0f)
                    return 0.0f; 
 
                // otherwise compute difference between current time and start time
                eDifference = (float)((ulong)newSample.CounterTimeStamp - oldSample.UnsignedRawValue); 

                // convert to fractional seconds using object counter
                eSeconds = eDifference / eFreq;
 
                return eSeconds;
            } 
        } 

        ///  
        ///    Computes the calculated value given a raw counter sample.
        /// 
        public static float ComputeCounterValue(CounterSample newSample) {
            return ComputeCounterValue(CounterSample.Empty, newSample); 
        }
 
        ///  
        ///    Computes the calculated value given a raw counter sample.
        ///  
        public static float ComputeCounterValue(CounterSample oldSample, CounterSample newSample) {
            int newCounterType = (int) newSample.CounterType;
            if (oldSample.SystemFrequency == 0) {
                if ((newCounterType != NativeMethods.PERF_RAW_FRACTION) && 
                    (newCounterType != NativeMethods.PERF_COUNTER_RAWCOUNT) &&
                    (newCounterType != NativeMethods.PERF_COUNTER_RAWCOUNT_HEX) && 
                    (newCounterType != NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT) && 
                    (newCounterType != NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT_HEX) &&
                    (newCounterType != NativeMethods.PERF_COUNTER_MULTI_BASE)) { 

                    // Since oldSample has a system frequency of 0, this means the newSample is the first sample
                    // on a two sample calculation.  Since we can't do anything with it, return 0.
                    return 0.0f; 
                }
            } 
            else if (oldSample.CounterType != newSample.CounterType) { 
                throw new InvalidOperationException(SR.GetString(SR.MismatchedCounterTypes));
            } 

            if (newCounterType == NativeMethods.PERF_ELAPSED_TIME)
                return (float)GetElapsedTime(oldSample, newSample);
 
            NativeMethods.PDH_RAW_COUNTER newPdhValue = new NativeMethods.PDH_RAW_COUNTER();
            NativeMethods.PDH_RAW_COUNTER oldPdhValue = new NativeMethods.PDH_RAW_COUNTER(); 
 
            FillInValues(oldSample, newSample, oldPdhValue, newPdhValue);
 
            LoadPerfCounterDll();

            NativeMethods.PDH_FMT_COUNTERVALUE pdhFormattedValue= new NativeMethods.PDH_FMT_COUNTERVALUE();
            long timeBase = newSample.SystemFrequency; 
            int result = SafeNativeMethods.FormatFromRawValue((uint) newCounterType, NativeMethods.PDH_FMT_DOUBLE | NativeMethods.PDH_FMT_NOSCALE | NativeMethods.PDH_FMT_NOCAP100,
                                                          ref timeBase, newPdhValue, oldPdhValue, pdhFormattedValue); 
 
            if (result != NativeMethods.ERROR_SUCCESS) {
                // If the numbers go negative, just return 0.  This better matches the old behavior. 
                if (result == NativeMethods.PDH_CALC_NEGATIVE_VALUE || result == NativeMethods.PDH_CALC_NEGATIVE_DENOMINATOR || result == NativeMethods.PDH_NO_DATA)
                    return 0;
                else
                    throw new Win32Exception(result, SR.GetString(SR.PerfCounterPdhError, result.ToString("x", CultureInfo.InvariantCulture))); 
            }
 
            return (float) pdhFormattedValue.data; 

        } 


        // This method figures out which values are supposed to go into which structures so that PDH can do the
        // calculation for us.  This was ported from Window's cutils.c 
        private static void FillInValues(CounterSample oldSample, CounterSample newSample, NativeMethods.PDH_RAW_COUNTER oldPdhValue, NativeMethods.PDH_RAW_COUNTER newPdhValue) {
            int newCounterType = (int) newSample.CounterType; 
 
            switch (newCounterType) {
                case NativeMethods.PERF_COUNTER_COUNTER: 
                case NativeMethods.PERF_COUNTER_QUEUELEN_TYPE:
                case NativeMethods.PERF_SAMPLE_COUNTER:
                case NativeMethods.PERF_OBJ_TIME_TIMER:
                case NativeMethods.PERF_COUNTER_OBJ_TIME_QUEUELEN_TYPE: 
                    newPdhValue.FirstValue  = newSample.RawValue;
                    newPdhValue.SecondValue = newSample.TimeStamp; 
 
                    oldPdhValue.FirstValue  = oldSample.RawValue;
                    oldPdhValue.SecondValue = oldSample.TimeStamp; 
                    break;

                case NativeMethods.PERF_COUNTER_100NS_QUEUELEN_TYPE:
                    newPdhValue.FirstValue  = newSample.RawValue; 
                    newPdhValue.SecondValue = newSample.TimeStamp100nSec;
 
                    oldPdhValue.FirstValue  = oldSample.RawValue; 
                    oldPdhValue.SecondValue = oldSample.TimeStamp100nSec;
                    break; 

                case NativeMethods.PERF_COUNTER_TIMER:
                case NativeMethods.PERF_COUNTER_TIMER_INV:
                case NativeMethods.PERF_COUNTER_BULK_COUNT: 
                case NativeMethods.PERF_COUNTER_LARGE_QUEUELEN_TYPE:
                case NativeMethods.PERF_COUNTER_MULTI_TIMER: 
                case NativeMethods.PERF_COUNTER_MULTI_TIMER_INV: 
                    newPdhValue.FirstValue  = newSample.RawValue;
                    newPdhValue.SecondValue = newSample.TimeStamp; 

                    oldPdhValue.FirstValue  = oldSample.RawValue;
                    oldPdhValue.SecondValue = oldSample.TimeStamp;
                    if (newCounterType == NativeMethods.PERF_COUNTER_MULTI_TIMER || newCounterType == NativeMethods.PERF_COUNTER_MULTI_TIMER_INV) { 
                        //  this is to make PDH work like PERFMON for
                        //  this counter type 
                        newPdhValue.FirstValue *= (uint) newSample.CounterFrequency; 
                        if (oldSample.CounterFrequency != 0) {
                            oldPdhValue.FirstValue *= (uint) oldSample.CounterFrequency; 
                        }
                    }

                    if ((newCounterType & NativeMethods.PERF_MULTI_COUNTER) == NativeMethods.PERF_MULTI_COUNTER) { 
                            newPdhValue.MultiCount = (int) newSample.BaseValue;
                            oldPdhValue.MultiCount = (int) oldSample.BaseValue; 
                    } 

 
                    break;
                //
                //  These counters do not use any time reference
                // 
                case NativeMethods.PERF_COUNTER_RAWCOUNT:
                case NativeMethods.PERF_COUNTER_RAWCOUNT_HEX: 
                case NativeMethods.PERF_COUNTER_DELTA: 
                case NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT:
                case NativeMethods.PERF_COUNTER_LARGE_RAWCOUNT_HEX: 
                case NativeMethods.PERF_COUNTER_LARGE_DELTA:
                    newPdhValue.FirstValue  = newSample.RawValue;
                    newPdhValue.SecondValue = 0;
 
                    oldPdhValue.FirstValue  = oldSample.RawValue;
                    oldPdhValue.SecondValue = 0; 
                    break; 
                //
                //  These counters use the 100 Ns time base in thier calculation 
                //
                case NativeMethods.PERF_100NSEC_TIMER:
                case NativeMethods.PERF_100NSEC_TIMER_INV:
                case NativeMethods.PERF_100NSEC_MULTI_TIMER: 
                case NativeMethods.PERF_100NSEC_MULTI_TIMER_INV:
                    newPdhValue.FirstValue  = newSample.RawValue; 
                    newPdhValue.SecondValue = newSample.TimeStamp100nSec; 

                    oldPdhValue.FirstValue  = oldSample.RawValue; 
                    oldPdhValue.SecondValue = oldSample.TimeStamp100nSec;
                    if ((newCounterType & NativeMethods.PERF_MULTI_COUNTER) == NativeMethods.PERF_MULTI_COUNTER) {
                        newPdhValue.MultiCount = (int) newSample.BaseValue;
                        oldPdhValue.MultiCount = (int) oldSample.BaseValue; 
                    }
                    break; 
                // 
                //  These counters use two data points
                // 
                case NativeMethods.PERF_SAMPLE_FRACTION:
                case NativeMethods.PERF_RAW_FRACTION:
                case NativeMethods.PERF_LARGE_RAW_FRACTION:
                case NativeMethods.PERF_PRECISION_SYSTEM_TIMER: 
                case NativeMethods.PERF_PRECISION_100NS_TIMER:
                case NativeMethods.PERF_PRECISION_OBJECT_TIMER: 
                case NativeMethods.PERF_AVERAGE_TIMER: 
                case NativeMethods.PERF_AVERAGE_BULK:
                    newPdhValue.FirstValue = newSample.RawValue; 
                    newPdhValue.SecondValue = newSample.BaseValue;

                    oldPdhValue.FirstValue = oldSample.RawValue;
                    oldPdhValue.SecondValue = oldSample.BaseValue; 
                    break;
 
                default: 
                    // an unidentified counter was returned so
                    newPdhValue.FirstValue  = 0; 
                    newPdhValue.SecondValue = 0;

                    oldPdhValue.FirstValue  = 0;
                    oldPdhValue.SecondValue = 0; 
                    break;
            } 
        } 

        [ResourceExposure(ResourceScope.None)] 
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        private static void LoadPerfCounterDll() {
            if (perfCounterDllLoaded)
                return; 

            new FileIOPermission(PermissionState.Unrestricted).Assert(); 
 
            string installPath = System.Runtime.InteropServices.RuntimeEnvironment.GetRuntimeDirectory();
            string perfcounterPath = Path.Combine(installPath, "perfcounter.dll"); 
            if (SafeNativeMethods.LoadLibrary(perfcounterPath) == IntPtr.Zero) {
                throw new Win32Exception( Marshal.GetLastWin32Error() );
            }
 
            perfCounterDllLoaded = true;
        } 
    } 
}
 

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

• DrawingContext.cs
• UserControlAutomationPeer.cs
• RTTrackingProfile.cs
• PropertyRecord.cs
• DesignBindingPicker.cs
• SqlNotificationEventArgs.cs
• MSAANativeProvider.cs
• Misc.cs
• DescendantQuery.cs
• XamlSerializer.cs
• MarshalByValueComponent.cs
• SeverityFilter.cs
• WsdlWriter.cs
• AsyncCompletedEventArgs.cs
• Geometry3D.cs
• MouseDevice.cs
• Point3DCollection.cs
• PerformanceCounterNameAttribute.cs
• CFGGrammar.cs
• TreeViewHitTestInfo.cs
• AssemblyBuilder.cs
• MatcherBuilder.cs
• TransformerInfoCollection.cs
• EntityDataSourceReferenceGroup.cs
• OrderedEnumerableRowCollection.cs
• ExceptionWrapper.cs
• BinHexDecoder.cs
• ScrollViewer.cs
• ListControlConvertEventArgs.cs
• xamlnodes.cs
• QilTargetType.cs
• Thumb.cs
• AsyncSerializedWorker.cs
• COSERVERINFO.cs
• PostBackTrigger.cs
• EntityKey.cs
• FrameworkObject.cs
• OleDbMetaDataFactory.cs
• Utils.cs
• ProfilePropertySettings.cs
• SafeRightsManagementQueryHandle.cs
• TextSpanModifier.cs
• LocatorBase.cs
• ResourceDisplayNameAttribute.cs
• DecoderNLS.cs
• GridViewRowEventArgs.cs
• SmiEventSink.cs
• CapabilitiesUse.cs
• ToolStripManager.cs
• QueryReaderSettings.cs
• BrowserDefinitionCollection.cs
• CompilerState.cs
• BitSet.cs
• SettingsPropertyIsReadOnlyException.cs
• ClientCultureInfo.cs
• SchemaTypeEmitter.cs
• IsolatedStorageException.cs
• SqlUtils.cs
• ValueOfAction.cs
• ConfigXmlText.cs
• DataServiceConfiguration.cs
• IItemProperties.cs
• XPathNode.cs
• DrawingServices.cs
• BitmapFrameDecode.cs
• SingleStorage.cs
• CollectionsUtil.cs
• ToolStripPanel.cs
• ListItemConverter.cs
• XmlSchemaObjectTable.cs
• CompiledRegexRunner.cs
• AbsoluteQuery.cs
• PerformanceCountersElement.cs
• ClientSponsor.cs
• FloatSumAggregationOperator.cs
• Permission.cs
• XmlSchemaInferenceException.cs
• GenericTypeParameterBuilder.cs
• OdbcDataReader.cs
• Match.cs
• PseudoWebRequest.cs
• AdRotator.cs
• RequestQueryParser.cs
• PrimitiveXmlSerializers.cs
• QueryInterceptorAttribute.cs
• UserControlParser.cs
• BindingWorker.cs
• RuntimeComponentFilter.cs
• RadioButtonStandardAdapter.cs
• XmlEventCache.cs
• BaseTemplateParser.cs
• SafeFindHandle.cs
• X509SecurityTokenAuthenticator.cs
• Inline.cs
• WebPartMovingEventArgs.cs
• backend.cs
• NullableBoolConverter.cs
• PageRanges.cs
• NavigationProgressEventArgs.cs
• _HTTPDateParse.cs