Minor refactorings and cleanup.

Kadluba Christian · Kadluba Christian · commit f905e94bffa3 · 2020-03-11T09:06:11.000+01:00
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs
@@ -68,14 +68,14 @@ public void Emit(LogEvent logEvent)
         {
             try
             {
-                using (SqlConnection connection = new SqlConnection(_traits.connectionString))
+                using (SqlConnection connection = new SqlConnection(_traits.ConnectionString))
                 {
                     connection.Open();
                     using (SqlCommand command = connection.CreateCommand())
                     {
                         command.CommandType = CommandType.Text;
 
-                        StringBuilder fieldList = new StringBuilder($"INSERT INTO [{_traits.schemaName}].[{_traits.tableName}] (");
+                        StringBuilder fieldList = new StringBuilder($"INSERT INTO [{_traits.SchemaName}].[{_traits.TableName}] (");
                         StringBuilder parameterList = new StringBuilder(") VALUES (");
 
                         int index = 0;
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSink.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSink.cs
@@ -87,23 +87,23 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
 
             try
             {
-                using (var cn = new SqlConnection(_traits.connectionString))
+                using (var cn = new SqlConnection(_traits.ConnectionString))
                 {
                     await cn.OpenAsync().ConfigureAwait(false);
-                    using (var copy = _traits.columnOptions.DisableTriggers
+                    using (var copy = _traits.ColumnOptions.DisableTriggers
                             ? new SqlBulkCopy(cn)
                             : new SqlBulkCopy(cn, SqlBulkCopyOptions.CheckConstraints | SqlBulkCopyOptions.FireTriggers, null)
                     )
                     {
-                        copy.DestinationTableName = string.Format("[{0}].[{1}]", _traits.schemaName, _traits.tableName);
-                        foreach (var column in _traits.eventTable.Columns)
+                        copy.DestinationTableName = string.Format("[{0}].[{1}]", _traits.SchemaName, _traits.TableName);
+                        foreach (var column in _traits.EventTable.Columns)
                         {
                             var columnName = ((DataColumn)column).ColumnName;
                             var mapping = new SqlBulkCopyColumnMapping(columnName, columnName);
                             copy.ColumnMappings.Add(mapping);
                         }
 
-                        await copy.WriteToServerAsync(_traits.eventTable).ConfigureAwait(false);
+                        await copy.WriteToServerAsync(_traits.EventTable).ConfigureAwait(false);
                     }
                 }
             }
@@ -114,7 +114,7 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)
             finally
             {
                 // Processed the items, clear for the next run
-                _traits.eventTable.Clear();
+                _traits.EventTable.Clear();
             }
         }
 
@@ -123,17 +123,17 @@ void FillDataTable(IEnumerable<LogEvent> events)
             // Add the new rows to the collection. 
             foreach (var logEvent in events)
             {
-                var row = _traits.eventTable.NewRow();
+                var row = _traits.EventTable.NewRow();
 
                 foreach (var field in _traits.GetColumnsAndValues(logEvent))
                 {
                     row[field.Key] = field.Value;
                 }
 
-                _traits.eventTable.Rows.Add(row);
+                _traits.EventTable.Rows.Add(row);
             }
 
-            _traits.eventTable.AcceptChanges();
+            _traits.EventTable.AcceptChanges();
         }
 
         /// <summary>
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSinkTraits.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSinkTraits.cs
@@ -28,15 +28,15 @@ namespace Serilog.Sinks.MSSqlServer
     /// <summary>Contains common functionality and properties used by both MSSqlServerSinks.</summary>
     internal sealed class MSSqlServerSinkTraits : IDisposable
     {
-        public string connectionString { get; }
-        public string tableName { get; }
-        public string schemaName { get; }
-        public ColumnOptions columnOptions { get; }
-        public IFormatProvider formatProvider { get; }
-        public ITextFormatter logEventFormatter { get; }
-        public ISet<string> additionalColumnNames { get; }
-        public DataTable eventTable { get; }
-        public ISet<string> standardColumnNames { get; }
+        public string ConnectionString { get; }
+        public string TableName { get; }
+        public string SchemaName { get; }
+        public ColumnOptions ColumnOptions { get; }
+        public IFormatProvider FormatProvider { get; }
+        public ITextFormatter LogEventFormatter { get; }
+        public ISet<string> AdditionalColumnNames { get; }
+        public DataTable EventTable { get; }
+        public ISet<string> StandardColumnNames { get; }
 
         public MSSqlServerSinkTraits(
             string connectionString,
@@ -53,41 +53,40 @@ public MSSqlServerSinkTraits(
             if (string.IsNullOrWhiteSpace(tableName))
                 throw new ArgumentNullException(nameof(tableName));
 
-            this.connectionString = connectionString;
-            this.tableName = tableName;
-            this.schemaName = schemaName;
-            this.columnOptions = columnOptions ?? new ColumnOptions();
-            this.formatProvider = formatProvider;
+            ConnectionString = connectionString;
+            TableName = tableName;
+            SchemaName = schemaName;
+            ColumnOptions = columnOptions ?? new ColumnOptions();
+            FormatProvider = formatProvider;
 
-            standardColumnNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            foreach (var stdCol in this.columnOptions.Store)
+            StandardColumnNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var stdCol in ColumnOptions.Store)
             {
-                var col = this.columnOptions.GetStandardColumnOptions(stdCol);
-                standardColumnNames.Add(col.ColumnName);
+                var col = ColumnOptions.GetStandardColumnOptions(stdCol);
+                StandardColumnNames.Add(col.ColumnName);
             }
 
-            additionalColumnNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            if (this.columnOptions.AdditionalColumns != null)
-                foreach (var col in this.columnOptions.AdditionalColumns)
-                    additionalColumnNames.Add(col.ColumnName);
+            AdditionalColumnNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            if (ColumnOptions.AdditionalColumns != null)
+                foreach (var col in ColumnOptions.AdditionalColumns)
+                    AdditionalColumnNames.Add(col.ColumnName);
 
-            if (this.columnOptions.Store.Contains(StandardColumn.LogEvent))
-                this.logEventFormatter = logEventFormatter ?? new JsonLogEventFormatter(this);
+            if (ColumnOptions.Store.Contains(StandardColumn.LogEvent))
+                LogEventFormatter = logEventFormatter ?? new JsonLogEventFormatter(this);
 
-            eventTable = CreateDataTable();
+            EventTable = CreateDataTable();
 
             if (autoCreateSqlTable)
             {
                 try
                 {
-                    SqlTableCreator tableCreator = new SqlTableCreator(this.connectionString, this.schemaName, this.tableName, eventTable, this.columnOptions);
+                    SqlTableCreator tableCreator = new SqlTableCreator(ConnectionString, SchemaName, TableName, EventTable, ColumnOptions);
                     tableCreator.CreateTable(); // return code ignored, 0 = failure?
                 }
                 catch (Exception ex)
                 {
                     SelfLog.WriteLine($"Exception creating table {tableName}:\n{ex}");
                 }
-
             }
         }
 
@@ -98,14 +97,14 @@ public MSSqlServerSinkTraits(
         /// </returns>
         public IEnumerable<KeyValuePair<string, object>> GetColumnsAndValues(LogEvent logEvent)
         {
-            foreach (var column in columnOptions.Store)
+            foreach (var column in ColumnOptions.Store)
             {
                 // skip Id (auto-incrementing identity)
                 if(column != StandardColumn.Id)
                     yield return GetStandardColumnNameAndValue(column, logEvent);
             }
 
-            if (columnOptions.AdditionalColumns != null)
+            if (ColumnOptions.AdditionalColumns != null)
             {
                 foreach (var columnValuePair in ConvertPropertiesToColumn(logEvent.Properties))
                     yield return columnValuePair;
@@ -114,62 +113,62 @@ public IEnumerable<KeyValuePair<string, object>> GetColumnsAndValues(LogEvent lo
 
         public void Dispose()
         {
-            eventTable.Dispose();
+            EventTable.Dispose();
         }
 
         internal KeyValuePair<string, object> GetStandardColumnNameAndValue(StandardColumn column, LogEvent logEvent)
         {
             switch (column)
             {
                 case StandardColumn.Message:
-                    return new KeyValuePair<string, object>(columnOptions.Message.ColumnName, logEvent.RenderMessage(formatProvider));
+                    return new KeyValuePair<string, object>(ColumnOptions.Message.ColumnName, logEvent.RenderMessage(FormatProvider));
                 case StandardColumn.MessageTemplate:
-                    return new KeyValuePair<string, object>(columnOptions.MessageTemplate.ColumnName, logEvent.MessageTemplate.Text);
+                    return new KeyValuePair<string, object>(ColumnOptions.MessageTemplate.ColumnName, logEvent.MessageTemplate.Text);
                 case StandardColumn.Level:
-                    return new KeyValuePair<string, object>(columnOptions.Level.ColumnName, columnOptions.Level.StoreAsEnum ? (object)logEvent.Level : logEvent.Level.ToString());
+                    return new KeyValuePair<string, object>(ColumnOptions.Level.ColumnName, ColumnOptions.Level.StoreAsEnum ? (object)logEvent.Level : logEvent.Level.ToString());
                 case StandardColumn.TimeStamp:
                     return GetTimeStampStandardColumnNameAndValue(logEvent);
                 case StandardColumn.Exception:
-                    return new KeyValuePair<string, object>(columnOptions.Exception.ColumnName, logEvent.Exception != null ? logEvent.Exception.ToString() : null);
+                    return new KeyValuePair<string, object>(ColumnOptions.Exception.ColumnName, logEvent.Exception?.ToString());
                 case StandardColumn.Properties:
-                    return new KeyValuePair<string, object>(columnOptions.Properties.ColumnName, ConvertPropertiesToXmlStructure(logEvent.Properties));
+                    return new KeyValuePair<string, object>(ColumnOptions.Properties.ColumnName, ConvertPropertiesToXmlStructure(logEvent.Properties));
                 case StandardColumn.LogEvent:
-                    return new KeyValuePair<string, object>(columnOptions.LogEvent.ColumnName, RenderLogEventColumn(logEvent));
+                    return new KeyValuePair<string, object>(ColumnOptions.LogEvent.ColumnName, RenderLogEventColumn(logEvent));
                 default:
                     throw new ArgumentOutOfRangeException();
             }
         }
 
         private KeyValuePair<string, object> GetTimeStampStandardColumnNameAndValue(LogEvent logEvent)
         {
-            var dateTimeOffset = columnOptions.TimeStamp.ConvertToUtc ? logEvent.Timestamp.ToUniversalTime() : logEvent.Timestamp;
+            var dateTimeOffset = ColumnOptions.TimeStamp.ConvertToUtc ? logEvent.Timestamp.ToUniversalTime() : logEvent.Timestamp;
 
-            if (columnOptions.TimeStamp.DataType == SqlDbType.DateTimeOffset)
-                return new KeyValuePair<string, object>(columnOptions.TimeStamp.ColumnName, dateTimeOffset);
+            if (ColumnOptions.TimeStamp.DataType == SqlDbType.DateTimeOffset)
+                return new KeyValuePair<string, object>(ColumnOptions.TimeStamp.ColumnName, dateTimeOffset);
 
-            return new KeyValuePair<string, object>(columnOptions.TimeStamp.ColumnName, dateTimeOffset.DateTime);
+            return new KeyValuePair<string, object>(ColumnOptions.TimeStamp.ColumnName, dateTimeOffset.DateTime);
         }
 
         private string RenderLogEventColumn(LogEvent logEvent)
         {
-            if (columnOptions.LogEvent.ExcludeAdditionalProperties)
+            if (ColumnOptions.LogEvent.ExcludeAdditionalProperties)
             {
-                var filteredProperties = logEvent.Properties.Where(p => !additionalColumnNames.Contains(p.Key));
+                var filteredProperties = logEvent.Properties.Where(p => !AdditionalColumnNames.Contains(p.Key));
                 logEvent = new LogEvent(logEvent.Timestamp, logEvent.Level, logEvent.Exception, logEvent.MessageTemplate, filteredProperties.Select(x => new LogEventProperty(x.Key, x.Value)));
             }
 
             var sb = new StringBuilder();
             using (var writer = new System.IO.StringWriter(sb))
-                logEventFormatter.Format(logEvent, writer);
+                LogEventFormatter.Format(logEvent, writer);
             return sb.ToString();
         }
 
         private string ConvertPropertiesToXmlStructure(IEnumerable<KeyValuePair<string, LogEventPropertyValue>> properties)
         {
-            var options = columnOptions.Properties;
+            var options = ColumnOptions.Properties;
 
             if (options.ExcludeAdditionalProperties)
-                properties = properties.Where(p => !additionalColumnNames.Contains(p.Key));
+                properties = properties.Where(p => !AdditionalColumnNames.Contains(p.Key));
 
             if (options.PropertiesFilter != null)
             {
@@ -220,19 +219,19 @@ private IEnumerable<KeyValuePair<string, object>> ConvertPropertiesToColumn(IRea
         {
             foreach (var property in properties)
             {
-                if (!eventTable.Columns.Contains(property.Key) || standardColumnNames.Contains(property.Key))
+                if (!EventTable.Columns.Contains(property.Key) || StandardColumnNames.Contains(property.Key))
                     continue;
 
                 var columnName = property.Key;
-                var columnType = eventTable.Columns[columnName].DataType;
+                var columnType = EventTable.Columns[columnName].DataType;
 
                 if (!(property.Value is ScalarValue scalarValue))
                 {
                     yield return new KeyValuePair<string, object>(columnName, property.Value.ToString());
                     continue;
                 }
 
-                if (scalarValue.Value == null && eventTable.Columns[columnName].AllowDBNull)
+                if (scalarValue.Value == null && EventTable.Columns[columnName].AllowDBNull)
                 {
                     yield return new KeyValuePair<string, object>(columnName, DBNull.Value);
                     continue;
@@ -271,24 +270,24 @@ private static bool TryChangeType(object obj, Type type, out object conversion)
 
         private DataTable CreateDataTable()
         {
-            var eventsTable = new DataTable(tableName);
+            var eventsTable = new DataTable(TableName);
 
-            foreach (var standardColumn in columnOptions.Store)
+            foreach (var standardColumn in ColumnOptions.Store)
             {
-                var standardOpts = columnOptions.GetStandardColumnOptions(standardColumn);
+                var standardOpts = ColumnOptions.GetStandardColumnOptions(standardColumn);
                 var dataColumn = standardOpts.AsDataColumn();
                 eventsTable.Columns.Add(dataColumn);
-                if(standardOpts == columnOptions.PrimaryKey)
+                if(standardOpts == ColumnOptions.PrimaryKey)
                     eventsTable.PrimaryKey = new DataColumn[] { dataColumn };
             }
 
-            if (columnOptions.AdditionalColumns != null)
+            if (ColumnOptions.AdditionalColumns != null)
             {
-                foreach(var addCol in columnOptions.AdditionalColumns)
+                foreach(var addCol in ColumnOptions.AdditionalColumns)
                 {
                     var dataColumn = addCol.AsDataColumn();
                     eventsTable.Columns.Add(dataColumn);
-                    if (addCol == columnOptions.PrimaryKey)
+                    if (addCol == ColumnOptions.PrimaryKey)
                         eventsTable.PrimaryKey = new DataColumn[] { dataColumn };
                 }
             }
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Output/JsonLogEventFormatter.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Output/JsonLogEventFormatter.cs
@@ -31,7 +31,7 @@ internal class JsonLogEventFormatter : ITextFormatter
         static readonly JsonValueFormatter ValueFormatter = new JsonValueFormatter(typeTagName: null);
         private const string COMMA_DELIMITER = ",";
 
-        MSSqlServerSinkTraits traits;
+        private readonly MSSqlServerSinkTraits _traits;
  
         /// <summary>
         /// Constructor. A reference to the parent Traits object is used so that JSON
@@ -40,7 +40,7 @@ internal class JsonLogEventFormatter : ITextFormatter
         /// </summary>
         public JsonLogEventFormatter(MSSqlServerSinkTraits parent)
         {
-            traits = parent;
+            _traits = parent;
         }
 
         /// <summary>
@@ -55,7 +55,7 @@ public void Format(LogEvent logEvent, TextWriter output)
 
             string precedingDelimiter = "";
 
-            if (traits.columnOptions.LogEvent.ExcludeStandardColumns == false)
+            if (_traits.ColumnOptions.LogEvent.ExcludeStandardColumns == false)
             {
                 // The XML Properties column has never included the Standard Columns, but prior
                 // to adding this sink-specific JSON formatter, the LogEvent JSON column relied
@@ -66,7 +66,7 @@ public void Format(LogEvent logEvent, TextWriter output)
                 // whether Standard Columns are written (specifically, the subset of Standard
                 // columns that were output by the external JsonFormatter class).
 
-                var store = traits.columnOptions.Store;
+                var store = _traits.ColumnOptions.Store;
 
                 WriteIfPresent(StandardColumn.TimeStamp);
                 WriteIfPresent(StandardColumn.Level);
@@ -80,7 +80,7 @@ void WriteIfPresent(StandardColumn col)
                     {
                         output.Write(precedingDelimiter);
                         precedingDelimiter = COMMA_DELIMITER;
-                        var colData = traits.GetStandardColumnNameAndValue(col, logEvent);
+                        var colData = _traits.GetStandardColumnNameAndValue(col, logEvent);
                         JsonValueFormatter.WriteQuotedJsonString(colData.Key, output);
                         output.Write(":");
                         string value = (col != StandardColumn.TimeStamp) ? (colData.Value ?? string.Empty).ToString() : ((DateTime)colData.Value).ToString("o");
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlTableCreator.cs

Original file line number	Diff line number	Diff line change
`@@ -68,14 +68,14 @@ public void Emit(LogEvent logEvent)`
`68`	`68`	`{`
`69`	`69`	`try`
`70`	`70`	`{`
`71`		`- using (SqlConnection connection = new SqlConnection(_traits.connectionString))`
	`71`	`+ using (SqlConnection connection = new SqlConnection(_traits.ConnectionString))`
`72`	`72`	`{`
`73`	`73`	`connection.Open();`
`74`	`74`	`using (SqlCommand command = connection.CreateCommand())`
`75`	`75`	`{`
`76`	`76`	`command.CommandType = CommandType.Text;`
`77`	`77`
`78`		`- StringBuilder fieldList = new StringBuilder($"INSERT INTO [{_traits.schemaName}].[{_traits.tableName}] (");`
	`78`	`+ StringBuilder fieldList = new StringBuilder($"INSERT INTO [{_traits.SchemaName}].[{_traits.TableName}] (");`
`79`	`79`	`StringBuilder parameterList = new StringBuilder(") VALUES (");`
`80`	`80`
`81`	`81`	`int index = 0;`
Original file line number	Diff line number	Diff line change
`@@ -87,23 +87,23 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)`
`87`	`87`
`88`	`88`	`try`
`89`	`89`	`{`
`90`		`- using (var cn = new SqlConnection(_traits.connectionString))`
	`90`	`+ using (var cn = new SqlConnection(_traits.ConnectionString))`
`91`	`91`	`{`
`92`	`92`	`await cn.OpenAsync().ConfigureAwait(false);`
`93`		`- using (var copy = _traits.columnOptions.DisableTriggers`
	`93`	`+ using (var copy = _traits.ColumnOptions.DisableTriggers`
`94`	`94`	`? new SqlBulkCopy(cn)`
`95`	`95`	`: new SqlBulkCopy(cn, SqlBulkCopyOptions.CheckConstraints \| SqlBulkCopyOptions.FireTriggers, null)`
`96`	`96`	`)`
`97`	`97`	`{`
`98`		`- copy.DestinationTableName = string.Format("[{0}].[{1}]", _traits.schemaName, _traits.tableName);`
`99`		`- foreach (var column in _traits.eventTable.Columns)`
	`98`	`+ copy.DestinationTableName = string.Format("[{0}].[{1}]", _traits.SchemaName, _traits.TableName);`
	`99`	`+ foreach (var column in _traits.EventTable.Columns)`
`100`	`100`	`{`
`101`	`101`	`var columnName = ((DataColumn)column).ColumnName;`
`102`	`102`	`var mapping = new SqlBulkCopyColumnMapping(columnName, columnName);`
`103`	`103`	`copy.ColumnMappings.Add(mapping);`
`104`	`104`	`}`
`105`	`105`
`106`		`- await copy.WriteToServerAsync(_traits.eventTable).ConfigureAwait(false);`
	`106`	`+ await copy.WriteToServerAsync(_traits.EventTable).ConfigureAwait(false);`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`	`}`
`@@ -114,7 +114,7 @@ protected override async Task EmitBatchAsync(IEnumerable<LogEvent> events)`
`114`	`114`	`finally`
`115`	`115`	`{`
`116`	`116`	`// Processed the items, clear for the next run`
`117`		`- _traits.eventTable.Clear();`
	`117`	`+ _traits.EventTable.Clear();`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`@@ -123,17 +123,17 @@ void FillDataTable(IEnumerable<LogEvent> events)`
`123`	`123`	`// Add the new rows to the collection.`
`124`	`124`	`foreach (var logEvent in events)`
`125`	`125`	`{`
`126`		`- var row = _traits.eventTable.NewRow();`
	`126`	`+ var row = _traits.EventTable.NewRow();`
`127`	`127`
`128`	`128`	`foreach (var field in _traits.GetColumnsAndValues(logEvent))`
`129`	`129`	`{`
`130`	`130`	`row[field.Key] = field.Value;`
`131`	`131`	`}`
`132`	`132`
`133`		`- _traits.eventTable.Rows.Add(row);`
	`133`	`+ _traits.EventTable.Rows.Add(row);`
`134`	`134`	`}`
`135`	`135`
`136`		`- _traits.eventTable.AcceptChanges();`
	`136`	`+ _traits.EventTable.AcceptChanges();`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`/// <summary>`