C# (CSharp) ITextFormatter示例

        /// <summary>
        /// Creates a new instance of the sink
        /// </summary>
        /// <param name="splunkHost">The host of the Splunk instance with the Event collector configured</param>
        /// <param name="eventCollectorToken">The token to use when authenticating with the event collector</param>
        /// <param name="uriPath">Change the default endpoint of the Event Collector e.g. services/collector/event</param>
        /// <param name="batchSizeLimit">The size of the batch when sending to the event collector</param>
        /// <param name="batchIntervalInSeconds">The interval in seconds that batching should occur</param>
        /// <param name="queueLimit">Maximum number of events in the queue</param>
        /// <param name="jsonFormatter">The text formatter used to render log events into a JSON format for consumption by Splunk</param>
        /// <param name="messageHandler">The handler used to send HTTP requests</param>
        public EventCollectorSink(
            string splunkHost,
            string eventCollectorToken,
            string uriPath,
            int batchIntervalInSeconds,
            int batchSizeLimit,
            int?queueLimit,
            ITextFormatter jsonFormatter,
            HttpMessageHandler messageHandler = null)
            : base(batchSizeLimit, TimeSpan.FromSeconds(batchIntervalInSeconds), queueLimit ?? DefaultQueueLimit)
            _uriPath       = uriPath;
            _splunkHost    = splunkHost;
            _jsonFormatter = jsonFormatter;
            _httpClient = messageHandler != null
                ? new EventCollectorClient(eventCollectorToken, messageHandler)
                : new EventCollectorClient(eventCollectorToken);
        }

        /// <summary>
        /// Adds a sink that sends log events as UDP packages over the network.
        /// </summary>
        /// <param name="sinkConfiguration">Logger sink configuration.</param>
        /// <param name="remoteAddress">
        /// The <see cref="IPAddress"/> of the remote host or multicast group to which the UDP
        /// client should sent the logging event.
        /// </param>
        /// <param name="remotePort">
        /// The TCP port of the remote host or multicast group to which the UDP client should sent
        /// the logging event.
        /// </param>
        /// <param name="formatter">
        /// Controls the rendering of log events into text, for example to log JSON. To control
        /// plain text formatting, use the overload that accepts an output template.
        /// </param>
        /// <param name="localPort">
        /// The TCP port from which the UDP client will communicate. The default is 0 and will
        /// cause the UDP client not to bind to a local port.
        /// </param>
        /// <param name="restrictedToMinimumLevel">
        /// The minimum level for events passed through the sink. The default is
        /// <see cref="LevelAlias.Minimum"/>.
        /// </param>
        /// <param name="levelSwitch">
        /// A switch allowing the pass-through minimum level to be changed at runtime.
        /// </param>
        /// <returns>Logger configuration, allowing configuration to continue.</returns>
        public static LoggerConfiguration Udp(
            this LoggerSinkConfiguration sinkConfiguration,
            IPAddress remoteAddress,
            int remotePort,
            ITextFormatter formatter,
            int localPort = 0,
            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
            LoggingLevelSwitch levelSwitch         = null)
            if (sinkConfiguration == null)
                throw new ArgumentNullException(nameof(sinkConfiguration));
            var client = UdpClientFactory.Create(localPort, remoteAddress);
            var sink   = new UdpSink(client, remoteAddress, remotePort, formatter);
            return(sinkConfiguration.Sink(sink, restrictedToMinimumLevel, levelSwitch));
        }

        /// <summary>
        /// Adds a sink that writes log events as records in Azure Table Storage table (default name LogEventEntity) using the given
        /// storage account name and Shared Access Signature (SAS) URL.
        /// </summary>
        /// <param name="loggerConfiguration">The logger configuration.</param>
        /// <param name="formatter">Use a Serilog ITextFormatter such as CompactJsonFormatter to store object in data column of Azure table</param>
        /// <param name="sharedAccessSignature">The storage account/table SAS key.</param>
        /// <param name="accountName">The storage account name.</param>
        /// <param name="tableEndpoint">The (optional) table endpoint. Only needed for testing.</param>
        /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
        /// <param name="storageTableName">Table name that log entries will be written to. Note: Optional, setting this may impact performance</param>
        /// <param name="writeInBatches">Use a periodic batching sink, as opposed to a synchronous one-at-a-time sink; this alters the partition
        /// key used for the events so is not enabled by default.</param>
        /// <param name="batchPostingLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        /// <param name="keyGenerator">The key generator used to create the PartitionKey and the RowKey for each log entry</param>
        /// <param name="cloudQueueProvider">Cloud table provider to get current log table.</param>
        /// <returns>Logger configuration, allowing configuration to continue.</returns>
        /// <exception cref="ArgumentNullException">A required parameter is null.</exception>
        public static LoggerConfiguration AzureQueueStorage(
            this LoggerSinkConfiguration loggerConfiguration,
            ITextFormatter formatter,
            string sharedAccessSignature,
            string accountName,
            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
            string storageQueueName = null,
            ICloudQueueProvider cloudQueueProvider = null)
            if (loggerConfiguration == null)
                throw new ArgumentNullException(nameof(loggerConfiguration));
            if (formatter == null)
                throw new ArgumentNullException(nameof(formatter));
            if (string.IsNullOrWhiteSpace(accountName))
                throw new ArgumentNullException(nameof(accountName));
            if (string.IsNullOrWhiteSpace(sharedAccessSignature))
                throw new ArgumentNullException(nameof(sharedAccessSignature));
                var credentials = new StorageCredentials(sharedAccessSignature);
                CloudStorageAccount storageAccount = new CloudStorageAccount(credentials, accountName, endpointSuffix: null, useHttps: true);
                // We set bypassTableCreationValidation to true explicitly here as the the SAS URL might not have enough permissions to query if the table exists.
                return(AzureQueueStorage(loggerConfiguration, formatter, storageAccount, restrictedToMinimumLevel, storageQueueName, true, cloudQueueProvider));
            catch (Exception ex)
                Debugging.SelfLog.WriteLine($"Error configuring AzureQueueStorage: {ex}");
                ILogEventSink sink = new LoggerConfiguration().CreateLogger();
                return(loggerConfiguration.Sink(sink, restrictedToMinimumLevel));
        }

        /// <summary>
        /// Construct a sink that saves log events to the specified EventHubClient.
        /// </summary>
        /// <param name="eventHubClient">The EventHubClient to use in this sink.</param>
        /// <param name="formatter">Provides formatting for outputting log data</param>
        /// <param name="batchSizeLimit">Default is 5 messages at a time</param>
        /// <param name="period">How often the batching should be done</param>
        /// <param name="eventDataAction">An optional action for setting extra properties on each EventData.</param>
        public AzureEventHubBatchingSink(
            EventHubClient eventHubClient,
            Action <EventData, LogEvent> eventDataAction,
            TimeSpan period,
            ITextFormatter formatter = null,
            int batchSizeLimit       = 5)
            : base(batchSizeLimit, period)
            formatter = formatter ?? new ScalarValueTypeSuffixJsonFormatter(renderMessage: true);
            if (batchSizeLimit < 1 || batchSizeLimit > 100)
                throw new ArgumentException("batchSizeLimit must be between 1 and 100.");
            _eventHubClient  = eventHubClient;
            _formatter       = formatter;
            _eventDataAction = eventDataAction;
        }

        public TwilioSink(String username, String password, String accountSid, String fromPhoneNumber, String toPhoneNumber, ITextFormatter textFormatter)
            _username   = username ?? throw new ArgumentNullException(nameof(username));
            _password   = password ?? throw new ArgumentNullException(nameof(password));
            _accountSid = accountSid;              // If accountSid is null the TwilioRestClient will automatically substitute the username
            if (String.IsNullOrWhiteSpace(fromPhoneNumber))
                throw new ArgumentException("Invalid fromPhoneNumber", nameof(fromPhoneNumber));
            _fromPhoneNumber = new PhoneNumber(fromPhoneNumber);
            if (String.IsNullOrWhiteSpace(toPhoneNumber))
                throw new ArgumentException("Invalid toPhoneNumber", nameof(toPhoneNumber));
            _toPhoneNumber = new PhoneNumber(toPhoneNumber);
            _textFormatter = textFormatter ?? throw new ArgumentNullException(nameof(textFormatter));
            TwilioClient.Init(username, password, accountSid);
        }

 /// <summary>
 /// Adds a sink that writes log events to a table in a MSSqlServer database.
 /// Create a database and execute the table creation script found here
 /// https://gist.github.com/mivano/10429656
 /// or use the autoCreateSqlTable option.
 /// </summary>
 /// <param name="loggerConfiguration">The logger configuration.</param>
 /// <param name="connectionString">The connection string to the database where to store the events.</param>
 /// <param name="sinkOptions">Supplies additional settings for the sink</param>
 /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param>
 /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
 /// <param name="columnOptions"></param>
 /// <param name="logEventFormatter">Supplies custom formatter for the LogEvent column, or null</param>
 /// <returns>Logger configuration, allowing configuration to continue.</returns>
 /// <exception cref="ArgumentNullException">A required parameter is null.</exception>
 public static LoggerConfiguration MSSqlServer(
     this LoggerSinkConfiguration loggerConfiguration,
     string connectionString,
     MSSqlServerSinkOptions sinkOptions,
     LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
     IFormatProvider formatProvider         = null,
     ColumnOptions columnOptions            = null,
     ITextFormatter logEventFormatter       = null) =>
 loggerConfiguration.MSSqlServerInternal(
     configSectionName: AppConfigSectionName,
     connectionString: connectionString,
     sinkOptions: sinkOptions,
     restrictedToMinimumLevel: restrictedToMinimumLevel,
     formatProvider: formatProvider,
     columnOptions: columnOptions,
     logEventFormatter: logEventFormatter,
     applySystemConfiguration: new ApplySystemConfiguration(),
     sinkFactory: new MSSqlServerSinkFactory(),
     batchingSinkFactory: new PeriodicBatchingSinkFactory());

        SetupClientAndFormatters(
            IEnumerable <LokiLabel> labels,
            IEnumerable <string> excludedLabels,
            ITextFormatter textFormatter,
            string outputTemplate,
            IHttpClient httpClient,
            LokiCredentials credentials)
            var batchFormatter = new LokiBatchFormatter(labels, excludedLabels);
            var formatter      = textFormatter ?? new MessageTemplateTextFormatter(outputTemplate);
            var client         = httpClient ?? new DefaultLokiHttpClient();
            if (client is ILokiHttpClient lokiHttpClient)
                lokiHttpClient.SetCredentials(credentials);
            return((IBatchFormatter)batchFormatter, formatter, client);
        }

        public static IHostBuilder CreateHostBuilder(LoggerMode mode, string[] args)
            ITextFormatter formatter = mode switch
                LoggerMode.Text => new MessageTemplateTextFormatter("{Timestamp:yyyy-MM-dd HH:mm:ss.fff zzz} [{Level:u3}] {Message:lj}{NewLine}{Exception}"),
                LoggerMode.Json => new JsonFormatter(renderMessage: true),
                LoggerMode.ECS => new EcsTextFormatter(),
                _ => throw new NotSupportedException()
            return(Host.CreateDefaultBuilder(args)
                   .UseSerilog((context, services, configuration) => configuration
                               .ReadFrom.Configuration(context.Configuration)
                               .ReadFrom.Services(services)
                               .Enrich.FromLogContext()
                               .WriteTo.Console(formatter: formatter))
                   .ConfigureWebHostDefaults(webBuilder => { webBuilder.UseStartup <Startup>(); }));
    }

        /// <summary>
        /// Construct a sink emailing with the specified details.
        /// </summary>
        /// <param name="connectionInfo">Connection information used to construct the SMTP client and mail messages.</param>
        /// <param name="batchSizeLimit">The maximum number of events to post in a single batch.</param>
        /// <param name="period">The time to wait between checking for event batches.</param>
        /// <param name="textFormatter">Supplies culture-specific formatting information, or null.</param>
        /// <param name="subjectLineFormatter">The subject line formatter.</param>
        /// <exception cref="System.ArgumentNullException">connectionInfo</exception>
        public EmailSink(EmailConnectionInfo connectionInfo, int batchSizeLimit, TimeSpan period, ITextFormatter textFormatter, ITextFormatter subjectLineFormatter)
            : base(batchSizeLimit, period)
            if (connectionInfo == null)
                throw new ArgumentNullException(nameof(connectionInfo));
            _connectionInfo = connectionInfo;
            _fromAddress    = MimeKit.MailboxAddress.Parse(_connectionInfo.FromEmail);
            _toAddresses    = connectionInfo
                              .ToEmail
                              .Split(",;".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
                              .Select(MimeKit.MailboxAddress.Parse)
                              .ToArray();
            _textFormatter    = textFormatter;
            _subjectFormatter = subjectLineFormatter;
        }

        public static LoggerAuditSinkConfiguration RabbitMq(
            this LoggerAuditSinkConfiguration configuration,
            Action <RabbitMqSinkOptions> optionsSetup,
            IConnection connection,
            ITextFormatter formatter,
            LogEventLevel restrictedToMinimumLevel        = LogEventLevel.Verbose,
            LoggingLevelSwitch levelSwitch                = null,
            TextToBinaryFormatterOptions formatterOptions = null,
            bool autoCloseConnection = true)
            RabbitMqSinkOptions options = configuration.Create(optionsSetup);
            RabbitMqSink rabbitMqSink = new RabbitMqSink(options, connection, formatter,
                                                         formatterOptions, autoCloseConnection);
            configuration.Sink(rabbitMqSink, restrictedToMinimumLevel, levelSwitch);
            return(configuration);
        }

        public LoggerRelayEventSink(ILoggerRelay loggerRelay, CancellationToken cancellationToken, LoggerRelayEventSinkConfigArgs loggerRelayEventSinkConfigArgs = null) : base(ThreadPriority.Highest, 100)
            bool mutexCreated;
            var  outputTemplate = "{Timestamp:yyyy-MM-dd hh:mm:ss.fff} [{Level}] {SourceContext} {Message}";
            DateTime.Now.ToDebugDateText();
            this.Domain            = loggerRelay.Domain;
            this.RootPath          = Environment.ExpandEnvironmentVariables(loggerRelayEventSinkConfigArgs.RootPath);
            this.CancellationToken = cancellationToken;
            this.ID = Guid.NewGuid().ToString();
                mutex = Mutex.OpenExisting(string.Format(@"Global\{0}+Mutex", this.Domain));
            catch
                mutex = new Mutex(false, string.Format(@"Global\{0}+Mutex", this.Domain), out mutexCreated);
            this.loggerRelayEventSinkConfigArgs = loggerRelayEventSinkConfigArgs;
            this.loggerRelay  = loggerRelay;
            this.formatter    = new MessageTemplateTextFormatter(outputTemplate);
            this.queuedEvents = new FixedDictionary <LoggerRelayEvent, LogEvent>(NumberExtensions.MB);
            if (loggerRelayEventSinkConfigArgs != null)
                if (!loggerRelayEventSinkConfigArgs.Enabled)
                    return;
                captureStack = loggerRelayEventSinkConfigArgs.CaptureStack.Where(c => c.Enabled).ToDictionary(c => c.Log, c => c.Assemblies.Where(a => a.Enabled).ToDictionary(a => a.Assembly, a => a));
            this.Start();
            cancellationToken.Register(() =>
                this.Stopped = true;
        }

 /// <summary>
 /// Adds a sink that sends log events as UDP packages over the network.
 /// </summary>
 /// <param name="sinkConfiguration">
 /// Logger sink configuration.
 /// </param>
 /// <param name="remoteAddress">
 /// The <see cref="IPAddress"/> of the remote host or multicast group to which the UDP
 /// client should sent the logging event.
 /// </param>
 /// <param name="remotePort">
 /// The TCP port of the remote host or multicast group to which the UDP client should sent
 /// the logging event.
 /// </param>
 /// <param name="formatter">
 /// Controls the rendering of log events into text, for example to log JSON. To control
 /// plain text formatting, use the overload that accepts an output template.
 /// </param>
 /// <param name="localPort">
 /// The TCP port from which the UDP client will communicate. The default is 0 and will
 /// cause the UDP client not to bind to a local port.
 /// </param>
 /// <param name="restrictedToMinimumLevel">
 /// The minimum level for events passed through the sink. The default is
 /// <see cref="LevelAlias.Minimum"/>.
 /// </param>
 /// <param name="levelSwitch">
 /// A switch allowing the pass-through minimum level to be changed at runtime.
 /// </param>
 /// <returns>
 /// Logger configuration, allowing configuration to continue.
 /// </returns>
 public static LoggerConfiguration Udp(
     this LoggerSinkConfiguration sinkConfiguration,
     IPAddress remoteAddress,
     int remotePort,
     ITextFormatter formatter,
     int localPort = 0,
     LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
     LoggingLevelSwitch levelSwitch         = null)
     return(Udp(
                sinkConfiguration,
                remoteAddress.ToString(),
                remotePort,
                formatter,
                localPort,
                restrictedToMinimumLevel,
                levelSwitch
 }

        public static LoggerConfiguration AzureBlobOrEventHub(
            this LoggerSinkConfiguration loggerConfiguration,
            string eventHubConnectionString,
            string eventHubName,
            int eventSizeLimitInBytes,
            BlobServiceClient blobServiceClient,
            string storageContainerName = null,
            ITextFormatter formatter    = null)
            if (loggerConfiguration == null)
                throw new ArgumentNullException(nameof(loggerConfiguration));
            if (string.IsNullOrWhiteSpace(eventHubConnectionString))
                throw new ArgumentNullException(nameof(eventHubConnectionString));
            if (string.IsNullOrWhiteSpace(eventHubName))
                throw new ArgumentNullException(nameof(eventHubName));
            if (blobServiceClient == null)
                throw new ArgumentNullException(nameof(blobServiceClient));
            if (formatter == null)
                throw new ArgumentNullException(nameof(formatter));
            var eventHubConnectionstringBuilder = new EventHubsConnectionStringBuilder(eventHubConnectionString)
                EntityPath = eventHubName
            var eventHubclient = EventHubClient.CreateFromConnectionString(eventHubConnectionstringBuilder.ToString());
            return(loggerConfiguration.Sink(new AzureBlobOrEventHubCustomSink(blobServiceClient, eventHubclient, formatter, eventSizeLimitInBytes, storageContainerName)));
        }

        /// <summary>
        /// Write log events to a CustomOutput in VisualStudio.
        /// </summary>
        /// <param name="sinkConfiguration">Logger sink configuration.</param>
        /// <param name="restrictedToMinimumLevel">The minimum level for
        /// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param>
        /// <param name="levelSwitch">A switch allowing the pass-through minimum level
        /// to be changed at runtime.</param>
        /// <param name="formatter">A custom formatter to apply to the output events. This can be used with
        /// e.g. <see cref="JsonFormatter"/> to produce JSON output. To customize the text layout only, use the
        /// overload that accepts an output template instead.</param>
        /// <returns>Configuration object allowing method chaining.</returns>
        public static LoggerConfiguration CustomOutput(
            this LoggerSinkConfiguration sinkConfiguration,
            Guid id,
            string title,
            ITextFormatter formatter,
            LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
            LoggingLevelSwitch levelSwitch         = null)
            if (sinkConfiguration == null)
                throw new ArgumentNullException(nameof(sinkConfiguration));
            if (formatter == null)
                throw new ArgumentNullException(nameof(formatter));
            return(sinkConfiguration.Sink(new CustomOutputPaneSink(id, title, formatter), restrictedToMinimumLevel, levelSwitch));
        }