C# AsyncLogEventInfo.BucketSort方法代码示例

 /// <summary>
 /// Renders an array logging events.
 /// </summary>
 /// <param name="logEvents">Array of logging events.</param>
 protected override void Write(AsyncLogEventInfo[] logEvents)
 {
     foreach (var bucket in logEvents.BucketSort(c => this.GetSmtpSettingsKey(c.LogEvent)))
     {
         var eventInfos = bucket.Value;
         this.ProcessSingleMailMessage(eventInfos);
     }
 }

        /// <summary>
        /// Writes the specified array of logging events to a file specified in the FileName
        /// parameter.
        /// </summary>
        /// <param name="logEvents">An array of <see cref="LogEventInfo "/> objects.</param>
        /// <remarks>
        /// This function makes use of the fact that the events are batched by sorting
        /// the requests by filename. This optimizes the number of open/close calls
        /// and can help improve performance.
        /// </remarks>
        protected override void Write(AsyncLogEventInfo[] logEvents)
        {
            var buckets = logEvents.BucketSort(c => this.FileName.Render(c.LogEvent));
            using (var ms = new MemoryStream())
            {
                var pendingContinuations = new List<AsyncContinuation>();

                foreach (var bucket in buckets)
                {
                    string fileName = bucket.Key;

                    ms.SetLength(0);
                    ms.Position = 0;

                    LogEventInfo firstLogEvent = null;

                    foreach (AsyncLogEventInfo ev in bucket.Value)
                    {
                        if (firstLogEvent == null)
                        {
                            firstLogEvent = ev.LogEvent;
                        }

                        byte[] bytes = this.GetBytesToWrite(ev.LogEvent);
                        ms.Write(bytes, 0, bytes.Length);
                        pendingContinuations.Add(ev.Continuation);
                    }

                    this.FlushCurrentFileWrites(fileName, firstLogEvent, ms, pendingContinuations);
                }
            }
        }

        /// <summary>
        /// Writes an array of logging events to the log target. By default it iterates on all
        /// events and passes them to "Write" method. Inheriting classes can use this method to
        /// optimize batch writes.
        /// </summary>
        /// <param name="logEvents">Logging events to be written out.</param>
        protected override void Write(AsyncLogEventInfo[] logEvents)
        {
            var buckets = logEvents.BucketSort(c => this.BuildConnectionString(c.LogEvent));

            try
            {
                foreach (var kvp in buckets)
                {
                    for (int i = 0; i < kvp.Value.Count; i++)
                    {
                        AsyncLogEventInfo ev = kvp.Value[i];

                        try
                        {
                            this.WriteEventToDatabase(ev.LogEvent);
                            ev.Continuation(null);
                        }
                        catch (Exception exception)
                        {
                            // in case of exception, close the connection and report it
                            InternalLogger.Error(exception, "Error when writing to database.");

                            if (exception.MustBeRethrownImmediately())
                            {
                                throw;
                            }
                            InternalLogger.Trace("DatabaseTarget: close connection because of exception");
                            this.CloseConnection();
                            ev.Continuation(exception);

                            if (exception.MustBeRethrown())
                            {
                                throw;
                            }
                        }
                    }
                }
            }
            finally
            {
                if (!this.KeepConnection)
                {
                    InternalLogger.Trace("DatabaseTarget: close connection because of KeepConnection=false");
                    this.CloseConnection();
                }
            }
        }