#if MONO

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Runtime.ExceptionServices;
using System.Globalization;
using System.Runtime;
using System.Runtime.Serialization;
using System.Security;
namespace System
{
    /// <summary>Represents one or more errors that occur during application execution.</summary>
    [__DynamicallyInvokable, DebuggerDisplay("Count = {InnerExceptionCount}")]
    [Serializable]
    public class AggregateException : Exception
    {
        private ReadOnlyCollection<Exception> m_innerExceptions;
        /// <summary>Gets a read-only collection of the <see cref="T:System.Exception" /> instances that caused the current exception.</summary>
        /// <returns>Returns a read-only collection of the <see cref="T:System.Exception" /> instances that caused the current exception.</returns>
        [__DynamicallyInvokable]
        public ReadOnlyCollection<Exception> InnerExceptions
        {
            [__DynamicallyInvokable, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
            get
            {
                return this.m_innerExceptions;
            }
        }
        private int InnerExceptionCount
        {
            get
            {
                return this.InnerExceptions.Count;
            }
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a system-supplied message that describes the error.</summary>
        [__DynamicallyInvokable]
        public AggregateException()
            : base("AggregateException_ctor_DefaultMessage")
        {
            this.m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[0]);
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a specified message that describes the error.</summary>
        /// <param name="message">The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture.</param>
        [__DynamicallyInvokable]
        public AggregateException(string message)
            : base(message)
        {
            this.m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[0]);
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a specified error message and a reference to the inner exception that is the cause of this exception.</summary>
        /// <param name="message">The message that describes the exception. The caller of this constructor is required to ensure that this string has been localized for the current system culture. </param>
        /// <param name="innerException">The exception that is the cause of the current exception. If the <paramref name="innerException" /> parameter is not null, the current exception is raised in a catch block that handles the inner exception. </param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerException" /> argument is null.</exception>
        [__DynamicallyInvokable]
        public AggregateException(string message, Exception innerException)
            : base(message, innerException)
        {
            if (innerException == null)
            {
                throw new ArgumentNullException("innerException");
            }
            this.m_innerExceptions = new ReadOnlyCollection<Exception>(new Exception[]
			{
				innerException
			});
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with references to the inner exceptions that are the cause of this exception.</summary>
        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
        [__DynamicallyInvokable]
        public AggregateException(IEnumerable<Exception> innerExceptions)
            : this("AggregateException_ctor_DefaultMessage", innerExceptions)
        {
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with references to the inner exceptions that are the cause of this exception.</summary>
        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
        [__DynamicallyInvokable]
        public AggregateException(params Exception[] innerExceptions)
            : this("AggregateException_ctor_DefaultMessage", innerExceptions)
        {
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a specified error message and references to the inner exceptions that are the cause of this exception.</summary>
        /// <param name="message">The error message that explains the reason for the exception.</param>
        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
        [__DynamicallyInvokable]
        public AggregateException(string message, IEnumerable<Exception> innerExceptions)
            : this(message, (innerExceptions as IList<Exception>) ?? ((innerExceptions == null) ? null : new List<Exception>(innerExceptions)))
        {
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with a specified error message and references to the inner exceptions that are the cause of this exception.</summary>
        /// <param name="message">The error message that explains the reason for the exception.</param>
        /// <param name="innerExceptions">The exceptions that are the cause of the current exception.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="innerExceptions" /> argument is null.</exception>
        /// <exception cref="T:System.ArgumentException">An element of <paramref name="innerExceptions" /> is null.</exception>
        [__DynamicallyInvokable]
        public AggregateException(string message, params Exception[] innerExceptions)
            : this(message, (IList<Exception>)innerExceptions)
        {
        }
        internal AggregateException(IEnumerable<ExceptionDispatchInfo> innerExceptionInfos)
            : this("AggregateException_ctor_DefaultMessage", innerExceptionInfos)
        {
        }
        internal AggregateException(string message, IEnumerable<ExceptionDispatchInfo> innerExceptionInfos)
            : this(message, (innerExceptionInfos as IList<ExceptionDispatchInfo>) ?? ((innerExceptionInfos == null) ? null : new List<ExceptionDispatchInfo>(innerExceptionInfos)))
        {
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with serialized data.</summary>
        /// <param name="info">The object that holds the serialized object data. </param>
        /// <param name="context">The contextual information about the source or destination. </param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> argument is null.</exception>
        /// <exception cref="T:System.Runtime.Serialization.SerializationException">The exception could not be deserialized correctly.</exception>
        [SecurityCritical]
        protected AggregateException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }
            Exception[] array = info.GetValue("InnerExceptions", typeof(Exception[])) as Exception[];
            if (array == null)
            {
                throw new SerializationException("AggregateException_DeserializationFailure");
            }
            this.m_innerExceptions = new ReadOnlyCollection<Exception>(array);
        }
        /// <summary>Initializes a new instance of the <see cref="T:System.AggregateException" /> class with serialized data.</summary>
        /// <param name="info">The object that holds the serialized object data. </param>
        /// <param name="context">The contextual information about the source or destination. </param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="info" /> argument is null.</exception>
        [SecurityCritical]
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }
            base.GetObjectData(info, context);
            Exception[] array = new Exception[this.m_innerExceptions.Count];
            this.m_innerExceptions.CopyTo(array, 0);
            info.AddValue("InnerExceptions", array, typeof(Exception[]));
        }
        /// <summary>Returns the <see cref="T:System.AggregateException" /> that is the root cause of this exception.</summary>
        /// <returns>Returns the <see cref="T:System.AggregateException" /> that is the root cause of this exception.</returns>
        [__DynamicallyInvokable]
        public override Exception GetBaseException()
        {
            Exception ex = this;
            AggregateException ex2 = this;
            while (ex2 != null && ex2.InnerExceptions.Count == 1)
            {
                ex = ex.InnerException;
                ex2 = (ex as AggregateException);
            }
            return ex;
        }
        /// <summary>Invokes a handler on each <see cref="T:System.Exception" /> contained by this <see cref="T:System.AggregateException" />.</summary>
        /// <param name="predicate">The predicate to execute for each exception. The predicate accepts as an argument the <see cref="T:System.Exception" /> to be processed and returns a Boolean to indicate whether the exception was handled.</param>
        /// <exception cref="T:System.ArgumentNullException">The <paramref name="predicate" /> argument is null.</exception>
        /// <exception cref="T:System.AggregateException">An exception contained by this <see cref="T:System.AggregateException" /> was not handled.</exception>
        [__DynamicallyInvokable]
        public void Handle(Func<Exception, bool> predicate)
        {
            if (predicate == null)
            {
                throw new ArgumentNullException("predicate");
            }
            List<Exception> list = null;
            for (int i = 0; i < this.m_innerExceptions.Count; i++)
            {
                if (!predicate(this.m_innerExceptions[i]))
                {
                    if (list == null)
                    {
                        list = new List<Exception>();
                    }
                    list.Add(this.m_innerExceptions[i]);
                }
            }
            if (list != null)
            {
                throw new AggregateException(this.Message, list);
            }
        }
        /// <summary>Flattens an <see cref="T:System.AggregateException" /> instances into a single, new instance.</summary>
        /// <returns>A new, flattened <see cref="T:System.AggregateException" />.</returns>
        [__DynamicallyInvokable]
        public AggregateException Flatten()
        {
            List<Exception> list = new List<Exception>();
            List<AggregateException> list2 = new List<AggregateException>();
            list2.Add(this);
            int num = 0;
            while (list2.Count > num)
            {
                IList<Exception> innerExceptions = list2[num++].InnerExceptions;
                for (int i = 0; i < innerExceptions.Count; i++)
                {
                    Exception ex = innerExceptions[i];
                    if (ex != null)
                    {
                        AggregateException ex2 = ex as AggregateException;
                        if (ex2 != null)
                        {
                            list2.Add(ex2);
                        }
                        else
                        {
                            list.Add(ex);
                        }
                    }
                }
            }
            return new AggregateException(this.Message, list);
        }
        /// <summary>Creates and returns a string representation of the current <see cref="T:System.AggregateException" />.</summary>
        /// <returns>A string representation of the current exception.</returns>
        [__DynamicallyInvokable]
        public override string ToString()
        {
            string text = base.ToString();
            for (int i = 0; i < this.m_innerExceptions.Count; i++)
            {
                text = string.Format(CultureInfo.InvariantCulture, "AggregateException_ToString", new object[]
				{
					text,
					Environment.NewLine,
					i,
					this.m_innerExceptions[i].ToString(),
					"<---",
					Environment.NewLine
				});
            }
            return text;
        }
        private AggregateException(string message, IList<Exception> innerExceptions)
            : base(message, (innerExceptions != null && innerExceptions.Count > 0) ? innerExceptions[0] : null)
        {
            if (innerExceptions == null)
            {
                throw new ArgumentNullException("innerExceptions");
            }
            Exception[] array = new Exception[innerExceptions.Count];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = innerExceptions[i];
                if (array[i] == null)
                {
                    throw new ArgumentException("AggregateException_ctor_InnerExceptionNull");
                }
            }
            this.m_innerExceptions = new ReadOnlyCollection<Exception>(array);
        }
        private AggregateException(string message, IList<ExceptionDispatchInfo> innerExceptionInfos)
            : base(message, (innerExceptionInfos != null && innerExceptionInfos.Count > 0 && innerExceptionInfos[0] != null) ? innerExceptionInfos[0].SourceException : null)
        {
            if (innerExceptionInfos == null)
            {
                throw new ArgumentNullException("innerExceptionInfos");
            }
            Exception[] array = new Exception[innerExceptionInfos.Count];
            for (int i = 0; i < array.Length; i++)
            {
                ExceptionDispatchInfo exceptionDispatchInfo = innerExceptionInfos[i];
                if (exceptionDispatchInfo != null)
                {
                    array[i] = exceptionDispatchInfo.SourceException;
                }
                if (array[i] == null)
                {
                    throw new ArgumentException("AggregateException_ctor_InnerExceptionNull");
                }
            }
            this.m_innerExceptions = new ReadOnlyCollection<Exception>(array);
        }
    }
}

#endif