AggregateException.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / AggregateException.cs / 1305376 / AggregateException.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
// 
// AggregateException.cs 
//
// [....] 
//
// Public type to communicate multiple failures to an end-user.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- 

using System; 
using System.Collections.Generic; 
using System.Collections.ObjectModel;
using System.Diagnostics; 
using System.Globalization;
using System.Runtime.Serialization;
using System.Security;
using System.Threading; 

namespace System 
{ 

    /// 
Represents one or more errors that occur during application execution.
 
    /// 
    ///  is used to consolidate multiple failures into a single, throwable
    /// exception object.
    ///  
    [Serializable]
    [DebuggerDisplay("Count = {InnerExceptions.Count}")] 
    public class AggregateException : Exception 
    {
 
        private ReadOnlyCollection m_innerExceptions; // Complete set of exceptions.

        /// 

        /// Initializes a new instance of the  class. 
        /// 
        public AggregateException() 
            : base(Environment.GetResourceString("AggregateException_ctor_DefaultMessage")) 
        {
            m_innerExceptions = new ReadOnlyCollection(new Exception[0]); 
        }

        /// 

        /// Initializes a new instance of the  class with 
        /// a specified error message.
        /// 
 
        /// The error message that explains the reason for the exception. 
        public AggregateException(string message)
            : base(message) 
        {
            m_innerExceptions = new ReadOnlyCollection(new Exception[0]);
        }
 
        /// 

        /// Initializes a new instance of the  class with a specified error 
        /// message and a reference to the inner exception that is the cause of this exception. 
        /// 
        /// The error message that explains the reason for the exception. 
        /// The exception that is the cause of the current exception.
        /// The  argument
        /// is null.
        public AggregateException(string message, Exception innerException) 
            : base(message, innerException)
        { 
            if (innerException == null) 
            {
                throw new ArgumentNullException("innerException"); 
            }

            m_innerExceptions = new ReadOnlyCollection(new Exception[] { innerException });
        } 

        /// 
 
        /// Initializes a new instance of the  class with 
        /// references to the inner exceptions that are the cause of this exception.
        /// 
 
        /// The exceptions that are the cause of the current exception.
        /// The  argument
        /// is null.
        /// An element of  is 
        /// null.
        public AggregateException(IEnumerable innerExceptions) : 
            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions) 
        {
        } 

        /// 

        /// Initializes a new instance of the  class with
        /// references to the inner exceptions that are the cause of this exception. 
        /// 
        /// The exceptions that are the cause of the current exception. 
        /// The  argument 
        /// is null.
        /// An element of  is 
        /// null.
        public AggregateException(params Exception[] innerExceptions) :
            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions)
        { 
        }
 
        /// 
 
        /// Initializes a new instance of the  class with a specified error
        /// message and references to the inner exceptions that are the cause of this exception. 
        /// 
        /// The error message that explains the reason for the exception.
        /// The exceptions that are the cause of the current exception.
        /// The  argument 
        /// is null.
        /// An element of  is 
        /// null. 
        public AggregateException(string message, IEnumerable innerExceptions)
            : this(message, innerExceptions == null ? (List)null : new List(innerExceptions)) 
        {
        }

        /// 
 
        /// Initializes a new instance of the  class with a specified error
        /// message and references to the inner exceptions that are the cause of this exception. 
        /// 
 
        /// The error message that explains the reason for the exception.
        /// The exceptions that are the cause of the current exception. 
        /// The  argument
        /// is null.
        /// An element of  is
        /// null. 
        public AggregateException(string message, params Exception[] innerExceptions) :
            this(message, (IList)innerExceptions) 
        { 
        }
 
        /// 

        /// Allocates a new aggregate exception with the specified message and list of inner exceptions.
        /// 
        /// The error message that explains the reason for the exception. 
        /// The exceptions that are the cause of the current exception.
        /// The  argument 
        /// is null. 
        /// An element of  is
        /// null. 
        private AggregateException(string message, IList innerExceptions)
            : base(message, innerExceptions != null && innerExceptions.Count > 0 ? innerExceptions[0] : null)
        {
            if (innerExceptions == null) 
            {
                throw new ArgumentNullException("innerExceptions"); 
            } 

            // Copy exceptions to our internal array and validate them. We must copy them, 
            // because we're going to put them into a ReadOnlyCollection which simply reuses
            // the list passed in to it. We don't want callers subsequently mutating.
            Exception[] exceptionsCopy = new Exception[innerExceptions.Count];
 
            for (int i = 0; i < exceptionsCopy.Length; i++)
            { 
                exceptionsCopy[i] = innerExceptions[i]; 

                if (exceptionsCopy[i] == null) 
                {
                    throw new ArgumentException(Environment.GetResourceString("AggregateException_ctor_InnerExceptionNull"));
                }
            } 

            m_innerExceptions = new ReadOnlyCollection(exceptionsCopy); 
        } 

        /// 
 
        /// Initializes a new instance of the  class with serialized data.
        /// 
        /// The  that holds
        /// the serialized object data about the exception being thrown. 
        /// The  that
        /// contains contextual information about the source or destination.  
        /// The  argument is null. 
        /// The exception could not be deserialized correctly.
        [SecurityCritical] 
        protected AggregateException(SerializationInfo info, StreamingContext context) :
            base(info, context)
        {
            if (info == null) 
            {
                throw new ArgumentNullException("info"); 
            } 

            Exception[] innerExceptions = info.GetValue("InnerExceptions", typeof(Exception[])) as Exception[]; 
            if (innerExceptions == null)
            {
                throw new SerializationException(Environment.GetResourceString("AggregateException_DeserializationFailure"));
            } 

            m_innerExceptions = new ReadOnlyCollection(innerExceptions); 
        } 

        /// 
 
        /// Sets the  with information about
        /// the exception.
        /// 
        /// The  that holds 
        /// the serialized object data about the exception being thrown.
        /// The  that 
        /// contains contextual information about the source or destination.  
        /// The  argument is null.
        [SecurityCritical] 
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            { 
                throw new ArgumentNullException("info");
            } 
 
            base.GetObjectData(info, context);
 
            Exception[] innerExceptions = new Exception[m_innerExceptions.Count];
            m_innerExceptions.CopyTo(innerExceptions, 0);
            info.AddValue("InnerExceptions", innerExceptions, typeof(Exception[]));
        } 

        /// 
 
        /// Returns the  that is the root cause of this exception. 
        /// 
        public override Exception GetBaseException() 
        {
            // Returns the first inner AggregateException that contains more or less than one inner exception

            // Recursively traverse the inner exceptions as long as the inner exception of type AggregateException and has only one inner exception 
            Exception back = this;
            AggregateException backAsAggregate = this; 
            while (backAsAggregate != null && backAsAggregate.InnerExceptions.Count == 1) 
            {
                back = back.InnerException; 
                backAsAggregate = back as AggregateException;
            }
            return back;
        } 

        /// 
 
        /// Gets a read-only collection of the  instances that caused the 
        /// current exception.
        /// 
 
        public ReadOnlyCollection InnerExceptions
        {
            get { return m_innerExceptions; }
        } 

#if !FEATURE_CORECLR 
        /// 
 
        /// Invokes a handler on each  contained by this . 
        /// 
        /// The predicate to execute for each exception. The predicate accepts as an
        /// argument the  to be processed and returns a Boolean to indicate
        /// whether the exception was handled. 
        /// 
        /// Each invocation of the  returns true or false to indicate whether the 
        ///  was handled. After all invocations, if any exceptions went 
        /// unhandled, all unhandled exceptions will be put into a new 
        /// which will be thrown. Otherwise, the  method simply returns. If any 
        /// invocations of the  throws an exception, it will halt the processing
        /// of any more exceptions and immediately propagate the thrown exception as-is.
        /// 
        /// An exception contained by this  was not handled.
        /// The  argument is 
        /// null. 
        public void Handle(Func predicate)
        { 
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            } 

            List unhandledExceptions = null; 
            for (int i = 0; i < m_innerExceptions.Count; i++) 
            {
                // If the exception was not handled, lazily allocate a list of unhandled 
                // exceptions (to be rethrown later) and add it.
                if (!predicate(m_innerExceptions[i]))
                {
                    if (unhandledExceptions == null) 
                    {
                        unhandledExceptions = new List(); 
                    } 

                    unhandledExceptions.Add(m_innerExceptions[i]); 
                }
            }

            // If there are unhandled exceptions remaining, throw them. 
            if (unhandledExceptions != null)
            { 
                throw new AggregateException(Message, unhandledExceptions); 
            }
        } 


#endif //!FEATURE_CORECLR
 

 
        /// 
 
        /// Flattens an  instances into a single, new instance.
        /// 
 
        /// A new, flattened .
        /// 
        /// If any inner exceptions are themselves instances of
        /// , this method will recursively flatten all of them. The 
        /// inner exceptions returned in the new 
        /// will be the union of all of the the inner exceptions from exception tree rooted at the provided 
        ///  instance. 
        /// 
        public AggregateException Flatten() 
        {
            // Initialize a collection to contain the flattened exceptions.
            List flattenedExceptions = new List();
 
            // Create a list to remember all aggregates to be flattened, this will be accessed like a FIFO queue
            List exceptionsToFlatten = new List(); 
            exceptionsToFlatten.Add(this); 
            int nDequeueIndex = 0;
 
            // Continue removing and recursively flattening exceptions, until there are no more.
            while (exceptionsToFlatten.Count > nDequeueIndex)
            {
                // dequeue one from exceptionsToFlatten 
                IList currentInnerExceptions = exceptionsToFlatten[nDequeueIndex++].InnerExceptions;
 
                for (int i = 0; i < currentInnerExceptions.Count; i++) 
                {
                    Exception currentInnerException = currentInnerExceptions[i]; 

                    if (currentInnerException == null)
                    {
                        continue; 
                    }
 
                    AggregateException currentInnerAsAggregate = currentInnerException as AggregateException; 

                    // If this exception is an aggregate, keep it around for later.  Otherwise, 
                    // simply add it to the list of flattened exceptions to be returned.
                    if (currentInnerAsAggregate != null)
                    {
                        exceptionsToFlatten.Add(currentInnerAsAggregate); 
                    }
                    else 
                    { 
                        flattenedExceptions.Add(currentInnerException);
                    } 
                }
            }

 
            return new AggregateException(Message, flattenedExceptions);
        } 
 
        /// 

        /// Creates and returns a string representation of the current . 
        /// 
        /// A string representation of the current exception.
        public override string ToString()
        { 
            string text = base.ToString();
 
            for (int i = 0; i < m_innerExceptions.Count; i++) 
            {
                text = String.Format( 
                    CultureInfo.InvariantCulture,
                    Environment.GetResourceString("AggregateException_ToString"),
                    text, Environment.NewLine, i, m_innerExceptions[i].ToString(), "<---", Environment.NewLine);
            } 

            return text; 
        } 

    } 

}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
// 
// AggregateException.cs 
//
// [....] 
//
// Public type to communicate multiple failures to an end-user.
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- 

using System; 
using System.Collections.Generic; 
using System.Collections.ObjectModel;
using System.Diagnostics; 
using System.Globalization;
using System.Runtime.Serialization;
using System.Security;
using System.Threading; 

namespace System 
{ 

    /// 
Represents one or more errors that occur during application execution.
 
    /// 
    ///  is used to consolidate multiple failures into a single, throwable
    /// exception object.
    ///  
    [Serializable]
    [DebuggerDisplay("Count = {InnerExceptions.Count}")] 
    public class AggregateException : Exception 
    {
 
        private ReadOnlyCollection m_innerExceptions; // Complete set of exceptions.

        /// 

        /// Initializes a new instance of the  class. 
        /// 
        public AggregateException() 
            : base(Environment.GetResourceString("AggregateException_ctor_DefaultMessage")) 
        {
            m_innerExceptions = new ReadOnlyCollection(new Exception[0]); 
        }

        /// 

        /// Initializes a new instance of the  class with 
        /// a specified error message.
        /// 
 
        /// The error message that explains the reason for the exception. 
        public AggregateException(string message)
            : base(message) 
        {
            m_innerExceptions = new ReadOnlyCollection(new Exception[0]);
        }
 
        /// 

        /// Initializes a new instance of the  class with a specified error 
        /// message and a reference to the inner exception that is the cause of this exception. 
        /// 
        /// The error message that explains the reason for the exception. 
        /// The exception that is the cause of the current exception.
        /// The  argument
        /// is null.
        public AggregateException(string message, Exception innerException) 
            : base(message, innerException)
        { 
            if (innerException == null) 
            {
                throw new ArgumentNullException("innerException"); 
            }

            m_innerExceptions = new ReadOnlyCollection(new Exception[] { innerException });
        } 

        /// 
 
        /// Initializes a new instance of the  class with 
        /// references to the inner exceptions that are the cause of this exception.
        /// 
 
        /// The exceptions that are the cause of the current exception.
        /// The  argument
        /// is null.
        /// An element of  is 
        /// null.
        public AggregateException(IEnumerable innerExceptions) : 
            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions) 
        {
        } 

        /// 

        /// Initializes a new instance of the  class with
        /// references to the inner exceptions that are the cause of this exception. 
        /// 
        /// The exceptions that are the cause of the current exception. 
        /// The  argument 
        /// is null.
        /// An element of  is 
        /// null.
        public AggregateException(params Exception[] innerExceptions) :
            this(Environment.GetResourceString("AggregateException_ctor_DefaultMessage"), innerExceptions)
        { 
        }
 
        /// 
 
        /// Initializes a new instance of the  class with a specified error
        /// message and references to the inner exceptions that are the cause of this exception. 
        /// 
        /// The error message that explains the reason for the exception.
        /// The exceptions that are the cause of the current exception.
        /// The  argument 
        /// is null.
        /// An element of  is 
        /// null. 
        public AggregateException(string message, IEnumerable innerExceptions)
            : this(message, innerExceptions == null ? (List)null : new List(innerExceptions)) 
        {
        }

        /// 
 
        /// Initializes a new instance of the  class with a specified error
        /// message and references to the inner exceptions that are the cause of this exception. 
        /// 
 
        /// The error message that explains the reason for the exception.
        /// The exceptions that are the cause of the current exception. 
        /// The  argument
        /// is null.
        /// An element of  is
        /// null. 
        public AggregateException(string message, params Exception[] innerExceptions) :
            this(message, (IList)innerExceptions) 
        { 
        }
 
        /// 

        /// Allocates a new aggregate exception with the specified message and list of inner exceptions.
        /// 
        /// The error message that explains the reason for the exception. 
        /// The exceptions that are the cause of the current exception.
        /// The  argument 
        /// is null. 
        /// An element of  is
        /// null. 
        private AggregateException(string message, IList innerExceptions)
            : base(message, innerExceptions != null && innerExceptions.Count > 0 ? innerExceptions[0] : null)
        {
            if (innerExceptions == null) 
            {
                throw new ArgumentNullException("innerExceptions"); 
            } 

            // Copy exceptions to our internal array and validate them. We must copy them, 
            // because we're going to put them into a ReadOnlyCollection which simply reuses
            // the list passed in to it. We don't want callers subsequently mutating.
            Exception[] exceptionsCopy = new Exception[innerExceptions.Count];
 
            for (int i = 0; i < exceptionsCopy.Length; i++)
            { 
                exceptionsCopy[i] = innerExceptions[i]; 

                if (exceptionsCopy[i] == null) 
                {
                    throw new ArgumentException(Environment.GetResourceString("AggregateException_ctor_InnerExceptionNull"));
                }
            } 

            m_innerExceptions = new ReadOnlyCollection(exceptionsCopy); 
        } 

        /// 
 
        /// Initializes a new instance of the  class with serialized data.
        /// 
        /// The  that holds
        /// the serialized object data about the exception being thrown. 
        /// The  that
        /// contains contextual information about the source or destination.  
        /// The  argument is null. 
        /// The exception could not be deserialized correctly.
        [SecurityCritical] 
        protected AggregateException(SerializationInfo info, StreamingContext context) :
            base(info, context)
        {
            if (info == null) 
            {
                throw new ArgumentNullException("info"); 
            } 

            Exception[] innerExceptions = info.GetValue("InnerExceptions", typeof(Exception[])) as Exception[]; 
            if (innerExceptions == null)
            {
                throw new SerializationException(Environment.GetResourceString("AggregateException_DeserializationFailure"));
            } 

            m_innerExceptions = new ReadOnlyCollection(innerExceptions); 
        } 

        /// 
 
        /// Sets the  with information about
        /// the exception.
        /// 
        /// The  that holds 
        /// the serialized object data about the exception being thrown.
        /// The  that 
        /// contains contextual information about the source or destination.  
        /// The  argument is null.
        [SecurityCritical] 
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            { 
                throw new ArgumentNullException("info");
            } 
 
            base.GetObjectData(info, context);
 
            Exception[] innerExceptions = new Exception[m_innerExceptions.Count];
            m_innerExceptions.CopyTo(innerExceptions, 0);
            info.AddValue("InnerExceptions", innerExceptions, typeof(Exception[]));
        } 

        /// 
 
        /// Returns the  that is the root cause of this exception. 
        /// 
        public override Exception GetBaseException() 
        {
            // Returns the first inner AggregateException that contains more or less than one inner exception

            // Recursively traverse the inner exceptions as long as the inner exception of type AggregateException and has only one inner exception 
            Exception back = this;
            AggregateException backAsAggregate = this; 
            while (backAsAggregate != null && backAsAggregate.InnerExceptions.Count == 1) 
            {
                back = back.InnerException; 
                backAsAggregate = back as AggregateException;
            }
            return back;
        } 

        /// 
 
        /// Gets a read-only collection of the  instances that caused the 
        /// current exception.
        /// 
 
        public ReadOnlyCollection InnerExceptions
        {
            get { return m_innerExceptions; }
        } 

#if !FEATURE_CORECLR 
        /// 
 
        /// Invokes a handler on each  contained by this . 
        /// 
        /// The predicate to execute for each exception. The predicate accepts as an
        /// argument the  to be processed and returns a Boolean to indicate
        /// whether the exception was handled. 
        /// 
        /// Each invocation of the  returns true or false to indicate whether the 
        ///  was handled. After all invocations, if any exceptions went 
        /// unhandled, all unhandled exceptions will be put into a new 
        /// which will be thrown. Otherwise, the  method simply returns. If any 
        /// invocations of the  throws an exception, it will halt the processing
        /// of any more exceptions and immediately propagate the thrown exception as-is.
        /// 
        /// An exception contained by this  was not handled.
        /// The  argument is 
        /// null. 
        public void Handle(Func predicate)
        { 
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            } 

            List unhandledExceptions = null; 
            for (int i = 0; i < m_innerExceptions.Count; i++) 
            {
                // If the exception was not handled, lazily allocate a list of unhandled 
                // exceptions (to be rethrown later) and add it.
                if (!predicate(m_innerExceptions[i]))
                {
                    if (unhandledExceptions == null) 
                    {
                        unhandledExceptions = new List(); 
                    } 

                    unhandledExceptions.Add(m_innerExceptions[i]); 
                }
            }

            // If there are unhandled exceptions remaining, throw them. 
            if (unhandledExceptions != null)
            { 
                throw new AggregateException(Message, unhandledExceptions); 
            }
        } 


#endif //!FEATURE_CORECLR
 

 
        /// 
 
        /// Flattens an  instances into a single, new instance.
        /// 
 
        /// A new, flattened .
        /// 
        /// If any inner exceptions are themselves instances of
        /// , this method will recursively flatten all of them. The 
        /// inner exceptions returned in the new 
        /// will be the union of all of the the inner exceptions from exception tree rooted at the provided 
        ///  instance. 
        /// 
        public AggregateException Flatten() 
        {
            // Initialize a collection to contain the flattened exceptions.
            List flattenedExceptions = new List();
 
            // Create a list to remember all aggregates to be flattened, this will be accessed like a FIFO queue
            List exceptionsToFlatten = new List(); 
            exceptionsToFlatten.Add(this); 
            int nDequeueIndex = 0;
 
            // Continue removing and recursively flattening exceptions, until there are no more.
            while (exceptionsToFlatten.Count > nDequeueIndex)
            {
                // dequeue one from exceptionsToFlatten 
                IList currentInnerExceptions = exceptionsToFlatten[nDequeueIndex++].InnerExceptions;
 
                for (int i = 0; i < currentInnerExceptions.Count; i++) 
                {
                    Exception currentInnerException = currentInnerExceptions[i]; 

                    if (currentInnerException == null)
                    {
                        continue; 
                    }
 
                    AggregateException currentInnerAsAggregate = currentInnerException as AggregateException; 

                    // If this exception is an aggregate, keep it around for later.  Otherwise, 
                    // simply add it to the list of flattened exceptions to be returned.
                    if (currentInnerAsAggregate != null)
                    {
                        exceptionsToFlatten.Add(currentInnerAsAggregate); 
                    }
                    else 
                    { 
                        flattenedExceptions.Add(currentInnerException);
                    } 
                }
            }

 
            return new AggregateException(Message, flattenedExceptions);
        } 
 
        /// 

        /// Creates and returns a string representation of the current . 
        /// 
        /// A string representation of the current exception.
        public override string ToString()
        { 
            string text = base.ToString();
 
            for (int i = 0; i < m_innerExceptions.Count; i++) 
            {
                text = String.Format( 
                    CultureInfo.InvariantCulture,
                    Environment.GetResourceString("AggregateException_ToString"),
                    text, Environment.NewLine, i, m_innerExceptions[i].ToString(), "<---", Environment.NewLine);
            } 

            return text; 
        } 

    } 

}

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

• AssociationSet.cs
• sqlstateclientmanager.cs
• EntitySqlQueryCacheKey.cs
• ThousandthOfEmRealPoints.cs
• ChildDocumentBlock.cs
• UidManager.cs
• PrtCap_Base.cs
• SimpleFileLog.cs
• ErrorWebPart.cs
• x509store.cs
• DetailsViewInsertedEventArgs.cs
• CanExecuteRoutedEventArgs.cs
• RenderingBiasValidation.cs
• IdentityManager.cs
• RewritingProcessor.cs
• CqlQuery.cs
• CharacterString.cs
• SafeUserTokenHandle.cs
• CultureSpecificCharacterBufferRange.cs
• ExpanderAutomationPeer.cs
• DataReaderContainer.cs
• AdornerHitTestResult.cs
• ObjectStateManagerMetadata.cs
• EventBuilder.cs
• SystemWebCachingSectionGroup.cs
• AppDomainAttributes.cs
• X509Certificate2Collection.cs
• ContentIterators.cs
• OperandQuery.cs
• CodeDomLoader.cs
• FrameworkPropertyMetadata.cs
• BasicHttpMessageCredentialType.cs
• ActivityBindForm.Designer.cs
• CodeStatementCollection.cs
• ResourceIDHelper.cs
• MessageDecoder.cs
• PageContentAsyncResult.cs
• EnumerableValidator.cs
• SystemIPv6InterfaceProperties.cs
• ZipArchive.cs
• SmtpFailedRecipientException.cs
• GenericsInstances.cs
• MatrixAnimationUsingPath.cs
• VisualStyleRenderer.cs
• ListBoxAutomationPeer.cs
• ScrollViewer.cs
• AnnotationDocumentPaginator.cs
• MonthChangedEventArgs.cs
• CaretElement.cs
• xsdvalidator.cs
• LayoutEditorPart.cs
• followingquery.cs
• CodeGeneratorOptions.cs
• ExtractorMetadata.cs
• SHA256CryptoServiceProvider.cs
• TdsParser.cs
• UpWmlMobileTextWriter.cs
• ObjectStateFormatter.cs
• PointIndependentAnimationStorage.cs
• DataListCommandEventArgs.cs
• EmptyElement.cs
• ChangeConflicts.cs
• StorageSetMapping.cs
• TriggerAction.cs
• NonVisualControlAttribute.cs
• InvokeGenerator.cs
• VideoDrawing.cs
• XhtmlBasicCalendarAdapter.cs
• ColorTransform.cs
• GeneralTransform.cs
• MgmtConfigurationRecord.cs
• Location.cs
• Operand.cs
• NetStream.cs
• OpCellTreeNode.cs
• FixedSOMFixedBlock.cs
• figurelengthconverter.cs
• ContainerControlDesigner.cs
• SiteMapPath.cs
• AsmxEndpointPickerExtension.cs
• x509utils.cs
• MetadataException.cs
• ListViewItemSelectionChangedEvent.cs
• ScalarType.cs
• OperandQuery.cs
• ViewStateException.cs
• TreeView.cs
• QuaternionIndependentAnimationStorage.cs
• VisualStyleElement.cs
• jithelpers.cs
• EventMappingSettingsCollection.cs
• ForwardPositionQuery.cs
• TextSpanModifier.cs
• ConvertEvent.cs
• filewebrequest.cs
• StoreItemCollection.Loader.cs
• ChangeInterceptorAttribute.cs
• XMLUtil.cs
• IfAction.cs
• CommandEventArgs.cs