private static IEnumerable<string> GetAggregateExceptionMessages(AggregateException exception)
 {
     foreach (var ie in exception.InnerExceptions)
     {
         yield return ie.Message;
     }
 }

        public override void OnException(HttpActionExecutedContext context)
        {
            Exception exp;
            try
            {
                var logLevel = GetLogLevel(context.Exception);
                _logException(context.Exception, logLevel);

                var error = ToError(context.Exception);
                var httpResponseMessage = new HttpResponseMessage
                {
                    StatusCode = GetStatusCode(context.Exception),
                    ReasonPhrase = context.Exception.Message,
                    RequestMessage = context.Request,
                    Content = new ObjectContent<Error>(error, new JsonMediaTypeFormatter(), "application/json"),                    
                };
                exp = new HttpResponseException(httpResponseMessage);
            }
            catch (Exception exception)
            {
                var e = new AggregateException(exception, context.Exception);
                _logException(e, LogLevel.SystemError);
                throw;
            }

            throw exp;
        }

        public void Should_flatten_aggregate_exceptions()
        {
            var exception1 = new Exception("Exception 1", new Exception("Inner exception of exception 1"));
            var exception2 = new Exception("Exception 2", new Exception("Inner exception of exception 2"));
            var exception3 = new Exception("Exception 3", new Exception("Inner exception of exception 3"));
            
            // Aggregate exceptions nested three levels deep.
            var aggregate3 = new AggregateException(exception3);
            var aggregate2 = new AggregateException(aggregate3, exception2);
            var aggregate1 = new AggregateException(aggregate2, exception1);

            var result = aggregate1.FlattenInnerExceptions();

            Assert.IsType<AggregateException>(result);

            // Only the inner exceptions of any aggregates should be returned. The inner exception
            // of a non-aggregate should not be flattened.
            var innerExceptions = ((AggregateException)result).InnerExceptions;
            var expectedExceptions = new[] { exception1, exception2, exception3 };

            Assert.Equal(3, innerExceptions.Count);

            foreach (var exception in expectedExceptions)
                Assert.True(innerExceptions.Contains(exception));
        }

        public void ExceptionPropertySetterHandlesAggregateExceptionsWithMultipleNestedExceptionsAndTrimsAfterReachingMaxCount()
        {
            const int Overage = 5;
            List<Exception> innerExceptions = new List<Exception>();
            for (int i = 0; i < Constants.MaxExceptionCountToSave + Overage; i++)
            {
                innerExceptions.Add(new Exception((i + 1).ToString(CultureInfo.InvariantCulture)));
            }

            AggregateException rootLevelException = new AggregateException("0", innerExceptions);

            ExceptionTelemetry telemetry = new ExceptionTelemetry { Exception = rootLevelException };

            Assert.Equal(Constants.MaxExceptionCountToSave + 1, telemetry.Exceptions.Count);
            int counter = 0;
            foreach (ExceptionDetails details in telemetry.Exceptions.Take(Constants.MaxExceptionCountToSave))
            {
                Assert.Equal(counter.ToString(CultureInfo.InvariantCulture), details.message);
                counter++;
            }

            ExceptionDetails first = telemetry.Exceptions.First();
            ExceptionDetails last = telemetry.Exceptions.Last();
            Assert.Equal(first.id, last.outerId);
            Assert.Equal(typeof(InnerExceptionCountExceededException).FullName, last.typeName);
            Assert.Equal(
                string.Format(
                    CultureInfo.InvariantCulture,
                    "The number of inner exceptions was {0} which is larger than {1}, the maximum number allowed during transmission. All but the first {1} have been dropped.",
                    1 + Constants.MaxExceptionCountToSave + Overage,
                    Constants.MaxExceptionCountToSave),
                last.message);
        }

		private void Warn ()
		{
			try {
				numReports += 1;

				// Create a collection container to hold exceptions
				List<Exception> exceptions = new List<Exception>();

				// We have an exception with an innerexception, so add it to the list
				exceptions.Add(new TimeoutException("This is part 1 of aggregate exception", new ArgumentException("ID missing")));

				// Another exception, add to list
				exceptions.Add(new NotImplementedException("This is part 2 of aggregate exception"));

				// All done, now create the AggregateException and throw it
				AggregateException aggEx = new AggregateException(exceptions);
				throw aggEx;
			} catch(Exception exp) {
				Xamarin.Insights.Report(exp, new Dictionary <string, string> { 
					{"warning-local-time", DateTime.Now.ToString()}
				}, Xamarin.Insights.Severity.Warning);

				MessagingCenter.Send<TrackViewModel, string>(this, "Alert", "Warning registered");
			}
		}

 public static void HandleException(AggregateException ex, Activity activity)
 {
     AlertDialog.Builder builder = new AlertDialog.Builder(activity);
     builder.SetTitle("One or more Error(s)");
     builder.SetMessage("First:" + ex.InnerExceptions.First().Message);
     builder.Create().Show();
 }

        private static AggregateException HandleRecursively(
            AggregateException aggregateException, Func<Exception, bool> predicate)
        {
            // Maintain a list of exceptions to be rethrown
            List<Exception> innerExceptions = null;

            // Loop over all of the inner exceptions
            foreach (var inner in aggregateException.InnerExceptions)
            {
                // If the inner exception is itself an aggregate, process recursively
                AggregateException innerAsAggregate = inner as AggregateException;
                if (innerAsAggregate != null)
                {
                    // Process recursively, and if we get back a new aggregate, store it
                    AggregateException newChildAggregate = HandleRecursively(innerAsAggregate, predicate);
                    if (newChildAggregate != null)
                    {
                        if (innerExceptions != null) innerExceptions = new List<Exception>();
                        innerExceptions.Add(newChildAggregate);
                    }
                }
                // Otherwise, if the exception does not match the filter, store it
                else if (!predicate(inner))
                {
                    if (innerExceptions != null) innerExceptions = new List<Exception>();
                    innerExceptions.Add(inner);
                }
            }

            // If there are any remaining exceptions, return them in a new aggregate.
            return innerExceptions.Count > 0 ?
                new AggregateException(aggregateException.Message, innerExceptions) :
                null;
        }

        /// <summary>
        /// Starts a list of tasks.
        /// </summary>
        /// <param name="tasks">The tasks to start.</param>
        /// <param name="exceptions">The variable where to write the occurred exceptions to.</param>
        /// <param name="scheduler">The custom scheduler to use.</param>
        /// <returns>
        /// The started tasks or <see langword="null" /> if <paramref name="tasks" /> is also <see langword="null" />.
        /// </returns>
        public static Task[] StartAll(
            this IEnumerable<Task> tasks,
            out AggregateException exceptions,
            TaskScheduler scheduler = null)
        {
            exceptions = null;

            if (tasks == null)
            {
                return null;
            }

            var occurredExceptions = new List<Exception>();

            var startedTasks = new List<Task>();

            try
            {
                using (var e = tasks.GetEnumerator())
                {
                    while (e.MoveNext())
                    {
                        try
                        {
                            var t = e.Current;
                            if (t == null)
                            {
                                continue;
                            }

                            if (scheduler == null)
                            {
                                t.Start();
                            }
                            else
                            {
                                t.Start(scheduler);
                            }

                            startedTasks.Add(t);
                        }
                        catch (Exception ex)
                        {
                            occurredExceptions.Add(ex);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                occurredExceptions.Add(ex);
            }

            if (occurredExceptions.Count > 0)
            {
                exceptions = new AggregateException(occurredExceptions);
            }

            return startedTasks.ToArray();
        }

        static void DumpException(StringBuilder sb, int indent, AggregateException aggregateException)
        {
            AppendWithIndent(sb, indent, aggregateException);

            foreach (var ex in aggregateException.InnerExceptions)
                DumpException(sb, indent + 1, ex);
        }

 private void HandleAggregateException(AggregateException ex)
 {
     foreach (var innerException in ex.InnerExceptions)
     {
         _logger.Error("", innerException);
     }
 }

        public void Stack_CreateFromAggregatedExceptionWithInnerException()
        {
            bool caughtException = false;
            try
            {
                File.Create(Path.GetInvalidFileNameChars()[0].ToString(), 0);
            }
            catch (ArgumentException exception)
            {
                var innerException1 = new InvalidOperationException("Test exception 1.");
                var innerException2 = new InvalidOperationException("Test exception 2.", exception);

                var aggregated = new AggregateException(innerException1, innerException2);

                IList<Stack> stacks = Stack.CreateStacks(aggregated).ToList();

                stacks.Count.Should().Be(4);
                aggregated.StackTrace.Should().Be(null);

                Assert.AreEqual("[No frames]", stacks[0].ToString());
                Assert.AreEqual("[No frames]", stacks[1].ToString());
                Assert.AreEqual("[No frames]", stacks[2].ToString());
                Assert.AreEqual(exception.StackTrace, stacks[3].ToString());

                Assert.AreEqual(aggregated.FormatMessage(), stacks[0].Message);
                Assert.AreEqual(innerException1.FormatMessage(), stacks[1].Message);
                Assert.AreEqual(innerException2.FormatMessage(), stacks[2].Message);
                Assert.AreEqual(exception.FormatMessage(), stacks[3].Message);

                caughtException = true;
            }
            Assert.IsTrue(caughtException);
        }

 private async Task<string> DoSomethingInPrivate()
 {
     LogTo.Error("After do somehting in private task");
     var list = new List<Exception>() { new NullReferenceException(), new ArgumentNullException() };
     var aggregate = new AggregateException(list);
     throw aggregate;
 }

 private static void HandleException(AggregateException ex)
 {
     foreach (var x in ex.InnerExceptions)
     {
         Console.WriteLine(x.Message);
     }
 }

 public static void TraceAllErrors(string msg, AggregateException aggregateException)
 {
     foreach (Exception innerException in aggregateException.InnerExceptions)
     {
         Trace.TraceError("{0} Exception: {1}", msg, innerException);
     }
 }

 public Error MapMessageToErrorSchema(AggregateException exception, string correlationId, string messageType, string payload, MessageProperties properties, IDictionary<string, object> headers, MessageReceivedInfo info)
 {
     return new Error
     {
         errorDateTime = DateTime.Now,
         errorType = ErrorTypeEnum.ApplicationError,
         component = exception.InnerException.Source,
         server = Environment.MachineName,
         serviceName = messageType,
         summary = exception.InnerException.Message,
         detail = exception.InnerException.StackTrace,
         original = new OriginalDetails
         {
             jobId = correlationId,
             exchangeName = (info == null) ? string.Empty : info.Exchange,
             queueName = (info == null) ? string.Empty : info.Queue,
             payload = payload,
             correlationId = correlationId,
             routingKey = (info == null) ? string.Empty : info.RoutingKey,
             deliveryMode = properties.DeliveryMode.ToString(),
             headers = ConvertDictionaryToHeaderDetails(headers),
             headerProperties = ConvertMessagePropertiesToHeaderDetails(properties)
         }
     };
 }

 public MessageDeserializationFailedQuarantinedEvent(AggregateException exceptions, string queueName, string storeName, Type messageType, byte[] data)
 {
     Exceptions = exceptions;
     QueueName = queueName;
     QuarantineStoreName = storeName;
     MessageType = messageType;
     Data = data;
 }

 public void RaiseErrors()
 {
     if (exceptions.Count > 0)
     {
         AggregateException aggregate = new AggregateException(exceptions);
         throw aggregate;
     }
 }

 public static void LogAggregateException(this ILog log, string message, AggregateException ex)
 {
     log.Error(message, ex);
     foreach (Exception e in ex.InnerExceptions)
     {
         log.Error(e);
     }
 }

		void GenerateAggregateError(IEnumerable<Exception> errors)
		{
			var message = new StringBuilder();
			foreach (Exception ex in errors) {
				message.AppendLine(ex.Message);
			}
			Error = new AggregateException(message.ToString(), errors);
		}

        public void An_insert_concurrency_exception_wrapped_in_an_exception_is_a_concurrency_exception()
        {
            var exception =
                new AggregateException(
                    new DataException("Cannot insert duplicate key"));

            exception.IsConcurrencyException().Should().BeTrue();
        }