Initialize DataTableCreator and SqlTableCreator with options on contruction to reduce dependencies on SinkOptions and ColumnOption in the sink classes.

ckadluba · ckadluba · commit f333ce64eef2 · 2020-05-01T21:15:13.000+02:00
diff --git a/src/Serilog.Sinks.MSSqlServer/GlobalSuppressions.cs b/src/Serilog.Sinks.MSSqlServer/GlobalSuppressions.cs
@@ -7,7 +7,7 @@
 
 [assembly: SuppressMessage("Globalization", "CA1303:Do not pass literals as localized parameters", Justification = "Supplying string literals and not using resources is accepted within this project.", Scope = "namespaceanddescendants", Target = "Serilog.Sinks.MSSqlServer")]
 [assembly: SuppressMessage("Security", "CA2100:Review SQL queries for security vulnerabilities", Justification = "Too hard to change. Accepted for now.", Scope = "namespaceanddescendants", Target = "Serilog.Sinks.MSSqlServer")]
-[assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.Platform.SqlTableCreator.CreateTable(System.String,System.String,System.Data.DataTable,Serilog.Sinks.MSSqlServer.ColumnOptions)")]
+[assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.Platform.SqlTableCreator.CreateTable(System.Data.DataTable)")]
 [assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.Sinks.MSSqlServer.Platform.SqlBulkBatchWriter.WriteBatch(System.Collections.Generic.IEnumerable{Serilog.Events.LogEvent},System.Data.DataTable)~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.Output.StandardColumnDataGenerator.ConvertPropertiesToXmlStructure(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,Serilog.Events.LogEventPropertyValue}})~System.String")]
 [assembly: SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Too hard to change. Accepted for now.", Scope = "member", Target = "~M:Serilog.Sinks.MSSqlServer.Output.PropertiesColumnDataGenerator.TryChangeType(System.Object,System.Type,System.Object@)~System.Boolean")]
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Dependencies/SinkDependenciesFactory.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Dependencies/SinkDependenciesFactory.cs
@@ -31,8 +31,10 @@ internal static SinkDependencies Create(
 
             var sinkDependencies = new SinkDependencies
             {
-                SqlTableCreator = new SqlTableCreator(new SqlCreateTableWriter(), sqlConnectionFactory),
-                DataTableCreator = new DataTableCreator(),
+                SqlTableCreator = new SqlTableCreator(
+                    sinkOptions.TableName, sinkOptions.SchemaName, columnOptions,
+                    new SqlCreateTableWriter(), sqlConnectionFactory),
+                DataTableCreator = new DataTableCreator(sinkOptions.TableName, columnOptions),
                 SqlBulkBatchWriter = new SqlBulkBatchWriter(
                     sinkOptions.TableName, sinkOptions.SchemaName,
                     columnOptions.DisableTriggers, sqlConnectionFactory, logEventDataGenerator),
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerAuditSink.cs
@@ -88,8 +88,6 @@ internal MSSqlServerAuditSink(
                 throw new InvalidOperationException("Table name must be specified!");
             }
 
-            columnOptions = columnOptions ?? new ColumnOptions();
-            columnOptions.FinalizeConfigurationForSinkConstructor();
             if (columnOptions.DisableTriggers)
                 throw new NotSupportedException($"The {nameof(ColumnOptions.DisableTriggers)} option is not supported for auditing.");
 
@@ -106,9 +104,9 @@ internal MSSqlServerAuditSink(
                     throw new InvalidOperationException($"DataTableCreator is not initialized!");
                 }
 
-                using (var eventTable = sinkDependencies.DataTableCreator.CreateDataTable(sinkOptions.TableName, columnOptions))
+                using (var eventTable = sinkDependencies.DataTableCreator.CreateDataTable())
                 {
-                    sinkDependencies.SqlTableCreator.CreateTable(sinkOptions.SchemaName, sinkOptions.TableName, eventTable, columnOptions);
+                    sinkDependencies.SqlTableCreator.CreateTable(eventTable);
                 }
             }
         }
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSink.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/MSSqlServerSink.cs
@@ -94,15 +94,13 @@ public MSSqlServerSink(
             IFormatProvider formatProvider = null,
             ColumnOptions columnOptions = null,
             ITextFormatter logEventFormatter = null)
-            : this(sinkOptions, columnOptions,
-                  SinkDependenciesFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter))
+            : this(sinkOptions, SinkDependenciesFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter))
         {
         }
 
         // Internal constructor with injectable dependencies for better testability
         internal MSSqlServerSink(
             SinkOptions sinkOptions,
-            ColumnOptions columnOptions,
             SinkDependencies sinkDependencies)
             : base(sinkOptions?.BatchPostingLimit ?? DefaultBatchPostingLimit, sinkOptions?.BatchPeriod ?? DefaultPeriod)
         {
@@ -111,9 +109,6 @@ internal MSSqlServerSink(
                 throw new InvalidOperationException("Table name must be specified!");
             }
 
-            columnOptions = columnOptions ?? new ColumnOptions();
-            columnOptions.FinalizeConfigurationForSinkConstructor();
-
             if (sinkDependencies == null)
             {
                 throw new ArgumentNullException(nameof(sinkDependencies));
@@ -125,15 +120,15 @@ internal MSSqlServerSink(
             {
                 throw new InvalidOperationException($"DataTableCreator is not initialized!");
             }
-            _eventTable = sinkDependencies.DataTableCreator.CreateDataTable(sinkOptions.TableName, columnOptions);
+            _eventTable = sinkDependencies.DataTableCreator.CreateDataTable();
 
             if (sinkOptions.AutoCreateSqlTable)
             {
                 if (sinkDependencies?.SqlBulkBatchWriter == null)
                 {
                     throw new InvalidOperationException($"SqlTableCreator is not initialized!");
                 }
-                sinkDependencies.SqlTableCreator.CreateTable(sinkOptions.SchemaName, sinkOptions.TableName, _eventTable, columnOptions);
+                sinkDependencies.SqlTableCreator.CreateTable(_eventTable);
             }
         }
 
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/DataTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/DataTableCreator.cs
@@ -1,29 +1,39 @@
+using System;
 using System.Data;
 
 namespace Serilog.Sinks.MSSqlServer.Platform
 {
     internal class DataTableCreator : IDataTableCreator
     {
-        public DataTable CreateDataTable(string tableName, ColumnOptions columnOptions)
+        private readonly string _tableName;
+        private readonly ColumnOptions _columnOptions;
+
+        public DataTableCreator(string tableName, ColumnOptions columnOptions)
+        {
+            _tableName = tableName ?? throw new ArgumentNullException(nameof(tableName));
+            _columnOptions = columnOptions ?? throw new ArgumentNullException(nameof(columnOptions));
+        }
+
+        public 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/Platform/IDataTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/IDataTableCreator.cs
@@ -4,6 +4,6 @@ namespace Serilog.Sinks.MSSqlServer.Platform
 {
     internal interface IDataTableCreator
     {
-        DataTable CreateDataTable(string tableName, ColumnOptions columnOptions);
+        DataTable CreateDataTable();
     }
-}
+}
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/ISqlTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/ISqlTableCreator.cs
@@ -4,6 +4,6 @@ namespace Serilog.Sinks.MSSqlServer.Platform
 {
     internal interface ISqlTableCreator
     {
-        void CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions);
+        void CreateTable(DataTable dataTable);
     }
 }
diff --git a/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlTableCreator.cs b/src/Serilog.Sinks.MSSqlServer/Sinks/MSSqlServer/Platform/SqlTableCreator.cs
@@ -8,22 +8,33 @@ namespace Serilog.Sinks.MSSqlServer.Platform
 {
     internal class SqlTableCreator : ISqlTableCreator
     {
+        private readonly string _tableName;
+        private readonly string _schemaName;
+        private readonly ColumnOptions _columnOptions;
         private readonly ISqlCreateTableWriter _sqlCreateTableWriter;
         private readonly ISqlConnectionFactory _sqlConnectionFactory;
 
-        public SqlTableCreator(ISqlCreateTableWriter sqlCreateTableWriter, ISqlConnectionFactory sqlConnectionFactory)
+        public SqlTableCreator(
+            string tableName,
+            string schemaName,
+            ColumnOptions columnOptions,
+            ISqlCreateTableWriter sqlCreateTableWriter,
+            ISqlConnectionFactory sqlConnectionFactory)
         {
+            _tableName = tableName ?? throw new ArgumentNullException(nameof(tableName));
+            _schemaName = schemaName ?? throw new ArgumentNullException(nameof(schemaName));
+            _columnOptions = columnOptions ?? throw new ArgumentNullException(nameof(columnOptions));
             _sqlCreateTableWriter = sqlCreateTableWriter ?? throw new ArgumentNullException(nameof(sqlCreateTableWriter));
             _sqlConnectionFactory = sqlConnectionFactory ?? throw new ArgumentNullException(nameof(sqlConnectionFactory));
         }
 
-        public void CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions)
+        public void CreateTable(DataTable dataTable)
         {
             try
             {
                 using (var conn = _sqlConnectionFactory.Create())
                 {
-                    var sql = _sqlCreateTableWriter.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions);
+                    var sql = _sqlCreateTableWriter.GetSqlFromDataTable(_schemaName, _tableName, dataTable, _columnOptions);
                     using (var cmd = new SqlCommand(sql, conn))
                     {
                         conn.Open();
@@ -33,7 +44,7 @@ public void CreateTable(string schemaName, string tableName, DataTable dataTable
             }
             catch (Exception ex)
             {
-                SelfLog.WriteLine($"Exception creating table {tableName}:\n{ex}");
+                SelfLog.WriteLine($"Exception creating table {_tableName}:\n{ex}");
             }
         }
     }
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/MSSqlServerAuditSinkTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/MSSqlServerAuditSinkTests.cs
@@ -27,7 +27,7 @@ public MSSqlServerAuditSinkTests()
         {
             _dataTable = new DataTable(_tableName);
             _dataTableCreatorMock = new Mock<IDataTableCreator>();
-            _dataTableCreatorMock.Setup(d => d.CreateDataTable(It.IsAny<string>(), It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()))
+            _dataTableCreatorMock.Setup(d => d.CreateDataTable())
                 .Returns(_dataTable);
 
             _sqlTableCreatorMock = new Mock<ISqlTableCreator>();
@@ -51,7 +51,7 @@ public void InitializeWithAutoCreateSqlTableCallsDataTableCreator()
             SetupSut(options, autoCreateSqlTable: true);
 
             // Assert
-            _dataTableCreatorMock.Verify(c => c.CreateDataTable(_tableName, options), Times.Once);
+            _dataTableCreatorMock.Verify(c => c.CreateDataTable(), Times.Once);
         }
 
         [Fact]
@@ -64,22 +64,19 @@ public void InitializeWithoutAutoCreateSqlTableDoesNotCallDataTableCreator()
             SetupSut(options, autoCreateSqlTable: false);
 
             // Assert
-            _dataTableCreatorMock.Verify(c => c.CreateDataTable(It.IsAny<string>(),
-                It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()), Times.Never);
+            _dataTableCreatorMock.Verify(c => c.CreateDataTable(), Times.Never);
         }
 
         [Fact]
         public void InitializeWithAutoCreateSqlTableCallsSqlTableCreator()
         {
-            // Arrange
             var options = new Serilog.Sinks.MSSqlServer.ColumnOptions();
 
             // Act
             SetupSut(options, autoCreateSqlTable: true);
 
             // Assert
-            _sqlTableCreatorMock.Verify(c => c.CreateTable(_schemaName, _tableName, _dataTable, options),
-                Times.Once);
+            _sqlTableCreatorMock.Verify(c => c.CreateTable(_dataTable), Times.Once);
         }
 
         [Fact]
@@ -92,9 +89,7 @@ public void InitializeWithoutAutoCreateSqlTableDoesNotCallSqlTableCreator()
             SetupSut(options, autoCreateSqlTable: false);
 
             // Assert
-            _sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<string>(), It.IsAny<string>(),
-                It.IsAny<DataTable>(), It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()),
-                Times.Never);
+            _sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<DataTable>()), Times.Never);
         }
 
         private void SetupSut(
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/MSSqlServerSinkTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/MSSqlServerSinkTests.cs
@@ -27,7 +27,7 @@ public MSSqlServerSinkTests()
         {
             _dataTable = new DataTable(_tableName);
             _dataTableCreatorMock = new Mock<IDataTableCreator>();
-            _dataTableCreatorMock.Setup(d => d.CreateDataTable(It.IsAny<string>(), It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()))
+            _dataTableCreatorMock.Setup(d => d.CreateDataTable())
                 .Returns(_dataTable);
 
             _sqlTableCreatorMock = new Mock<ISqlTableCreator>();
@@ -48,10 +48,10 @@ public void InitializeCallsDataTableCreator()
             var options = new Serilog.Sinks.MSSqlServer.ColumnOptions();
 
             // Act
-            SetupSut(options, autoCreateSqlTable: false);
+            SetupSut(autoCreateSqlTable: false);
 
             // Assert
-            _dataTableCreatorMock.Verify(c => c.CreateDataTable(_tableName, options), Times.Once);
+            _dataTableCreatorMock.Verify(c => c.CreateDataTable(), Times.Once);
         }
 
         [Fact]
@@ -61,11 +61,10 @@ public void InitializeWithAutoCreateSqlTableCallsSqlTableCreator()
             var options = new Serilog.Sinks.MSSqlServer.ColumnOptions();
 
             // Act
-            SetupSut(options, autoCreateSqlTable: true);
+            SetupSut(autoCreateSqlTable: true);
 
             // Assert
-            _sqlTableCreatorMock.Verify(c => c.CreateTable(_schemaName, _tableName, _dataTable, options),
-                Times.Once);
+            _sqlTableCreatorMock.Verify(c => c.CreateTable(_dataTable), Times.Once);
         }
 
         [Fact]
@@ -75,25 +74,21 @@ public void InitializeWithoutAutoCreateSqlTableDoesNotCallSqlTableCreator()
             var options = new Serilog.Sinks.MSSqlServer.ColumnOptions();
 
             // Act
-            SetupSut(options, autoCreateSqlTable: false);
+            SetupSut(autoCreateSqlTable: false);
 
             // Assert
-            _sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<string>(), It.IsAny<string>(),
-                It.IsAny<DataTable>(), It.IsAny<Serilog.Sinks.MSSqlServer.ColumnOptions>()),
-                Times.Never);
+            _sqlTableCreatorMock.Verify(c => c.CreateTable(It.IsAny<DataTable>()), Times.Never);
         }
 
-        private void SetupSut(
-            Serilog.Sinks.MSSqlServer.ColumnOptions options,
-            bool autoCreateSqlTable = false)
+        private void SetupSut(bool autoCreateSqlTable = false)
         {
             var sinkOptions = new SinkOptions
             {
                 TableName = _tableName,
                 SchemaName = _schemaName,
                 AutoCreateSqlTable = autoCreateSqlTable
             };
-            _sut = new MSSqlServerSink(sinkOptions, options, _sinkDependencies);
+            _sut = new MSSqlServerSink(sinkOptions, _sinkDependencies);
         }
 
         protected virtual void Dispose(bool disposing)
diff --git a/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Platform/SqlTableCreatorTests.cs b/test/Serilog.Sinks.MSSqlServer.Tests/Sinks/MSSqlServer/Platform/SqlTableCreatorTests.cs
@@ -13,6 +13,9 @@ namespace Serilog.Sinks.MSSqlServer.Tests.Sinks.MSSqlServer.Platform
 {
     public class SqlTableCreatorTests : DatabaseTestsBase
     {
+        private const string _tableName = "TestTableName";
+        private const string _schemaName = "TestSchemaName";
+        private readonly Serilog.Sinks.MSSqlServer.ColumnOptions _columnOptions;
         private readonly Mock<ISqlCreateTableWriter> _sqlWriterMock;
         private readonly SqlConnection _sqlConnection;
         private readonly Mock<ISqlConnectionFactory> _sqlConnectionFactoryMock;
@@ -29,25 +32,22 @@ public SqlTableCreatorTests(ITestOutputHelper output) : base(output)
             _sqlConnection = new SqlConnection(DatabaseFixture.LogEventsConnectionString);
             _sqlConnectionFactoryMock.Setup(f => f.Create()).Returns(_sqlConnection);
 
-            _sut = new SqlTableCreator(_sqlWriterMock.Object, _sqlConnectionFactoryMock.Object);
+            _columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
+            _sut = new SqlTableCreator(_tableName, _schemaName, _columnOptions,
+                _sqlWriterMock.Object, _sqlConnectionFactoryMock.Object);
         }
 
         [Fact]
         [Trait(TestCategory.TraitName, TestCategory.Unit)]
         public void CreateTableCallsSqlCreateTableWriterWithPassedValues()
         {
-            // Arrange
-            const string schemaName = "TestSchemaName";
-            const string tableName = "TestTableName";
-            var columnOptions = new Serilog.Sinks.MSSqlServer.ColumnOptions();
-
-            // Act
             using (var dataTable = new DataTable())
             {
-                _sut.CreateTable(schemaName, tableName, dataTable, columnOptions);
+                // Act
+                _sut.CreateTable(dataTable);
 
                 // Assert
-                _sqlWriterMock.Verify(w => w.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions), Times.Once());
+                _sqlWriterMock.Verify(w => w.GetSqlFromDataTable(_schemaName, _tableName, dataTable, _columnOptions), Times.Once());
             }
         }
 
@@ -58,7 +58,7 @@ public void CreateTableCallsSqlConnectionFactory()
             // Act
             using (var dataTable = new DataTable())
             {
-                _sut.CreateTable("TestSchemaName", "TestTableName", dataTable, new Serilog.Sinks.MSSqlServer.ColumnOptions());
+                _sut.CreateTable(dataTable);
             }
 
             // Assert
@@ -79,7 +79,7 @@ public void CreateTableExecutesCommandReturnedBySqlCreateTableWriter()
             // Act
             using (var dataTable = new DataTable())
             {
-                _sut.CreateTable("TestSchemaName", "TestTableName", dataTable, new Serilog.Sinks.MSSqlServer.ColumnOptions());
+                _sut.CreateTable(dataTable);
             }
 
             // Assert

Original file line number	Diff line number	Diff line change
`@@ -88,8 +88,6 @@ internal MSSqlServerAuditSink(`
`88`	`88`	`throw new InvalidOperationException("Table name must be specified!");`
`89`	`89`	`}`
`90`	`90`
`91`		`- columnOptions = columnOptions ?? new ColumnOptions();`
`92`		`- columnOptions.FinalizeConfigurationForSinkConstructor();`
`93`	`91`	`if (columnOptions.DisableTriggers)`
`94`	`92`	`throw new NotSupportedException($"The {nameof(ColumnOptions.DisableTriggers)} option is not supported for auditing.");`
`95`	`93`
`@@ -106,9 +104,9 @@ internal MSSqlServerAuditSink(`
`106`	`104`	`throw new InvalidOperationException($"DataTableCreator is not initialized!");`
`107`	`105`	`}`
`108`	`106`
`109`		`- using (var eventTable = sinkDependencies.DataTableCreator.CreateDataTable(sinkOptions.TableName, columnOptions))`
	`107`	`+ using (var eventTable = sinkDependencies.DataTableCreator.CreateDataTable())`
`110`	`108`	`{`
`111`		`- sinkDependencies.SqlTableCreator.CreateTable(sinkOptions.SchemaName, sinkOptions.TableName, eventTable, columnOptions);`
	`109`	`+ sinkDependencies.SqlTableCreator.CreateTable(eventTable);`
`112`	`110`	`}`
`113`	`111`	`}`
`114`	`112`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,15 +94,13 @@ public MSSqlServerSink(`
`94`	`94`	`IFormatProvider formatProvider = null,`
`95`	`95`	`ColumnOptions columnOptions = null,`
`96`	`96`	`ITextFormatter logEventFormatter = null)`
`97`		`- : this(sinkOptions, columnOptions,`
`98`		`- SinkDependenciesFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter))`
	`97`	`+ : this(sinkOptions, SinkDependenciesFactory.Create(connectionString, sinkOptions, formatProvider, columnOptions, logEventFormatter))`
`99`	`98`	`{`
`100`	`99`	`}`
`101`	`100`
`102`	`101`	`// Internal constructor with injectable dependencies for better testability`
`103`	`102`	`internal MSSqlServerSink(`
`104`	`103`	`SinkOptions sinkOptions,`
`105`		`- ColumnOptions columnOptions,`
`106`	`104`	`SinkDependencies sinkDependencies)`
`107`	`105`	`: base(sinkOptions?.BatchPostingLimit ?? DefaultBatchPostingLimit, sinkOptions?.BatchPeriod ?? DefaultPeriod)`
`108`	`106`	`{`
`@@ -111,9 +109,6 @@ internal MSSqlServerSink(`
`111`	`109`	`throw new InvalidOperationException("Table name must be specified!");`
`112`	`110`	`}`
`113`	`111`
`114`		`- columnOptions = columnOptions ?? new ColumnOptions();`
`115`		`- columnOptions.FinalizeConfigurationForSinkConstructor();`
`116`		`-`
`117`	`112`	`if (sinkDependencies == null)`
`118`	`113`	`{`
`119`	`114`	`throw new ArgumentNullException(nameof(sinkDependencies));`
`@@ -125,15 +120,15 @@ internal MSSqlServerSink(`
`125`	`120`	`{`
`126`	`121`	`throw new InvalidOperationException($"DataTableCreator is not initialized!");`
`127`	`122`	`}`
`128`		`- _eventTable = sinkDependencies.DataTableCreator.CreateDataTable(sinkOptions.TableName, columnOptions);`
	`123`	`+ _eventTable = sinkDependencies.DataTableCreator.CreateDataTable();`
`129`	`124`
`130`	`125`	`if (sinkOptions.AutoCreateSqlTable)`
`131`	`126`	`{`
`132`	`127`	`if (sinkDependencies?.SqlBulkBatchWriter == null)`
`133`	`128`	`{`
`134`	`129`	`throw new InvalidOperationException($"SqlTableCreator is not initialized!");`
`135`	`130`	`}`
`136`		`- sinkDependencies.SqlTableCreator.CreateTable(sinkOptions.SchemaName, sinkOptions.TableName, _eventTable, columnOptions);`
	`131`	`+ sinkDependencies.SqlTableCreator.CreateTable(_eventTable);`
`137`	`132`	`}`
`138`	`133`	`}`
`139`	`134`
Original file line number	Diff line number	Diff line change
`@@ -1,29 +1,39 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Data;`
`2`	`3`
`3`	`4`	`namespace Serilog.Sinks.MSSqlServer.Platform`
`4`	`5`	`{`
`5`	`6`	`internal class DataTableCreator : IDataTableCreator`
`6`	`7`	`{`
`7`		`- public DataTable CreateDataTable(string tableName, ColumnOptions columnOptions)`
	`8`	`+ private readonly string _tableName;`
	`9`	`+ private readonly ColumnOptions _columnOptions;`
	`10`	`+`
	`11`	`+ public DataTableCreator(string tableName, ColumnOptions columnOptions)`
	`12`	`+ {`
	`13`	`+ _tableName = tableName ?? throw new ArgumentNullException(nameof(tableName));`
	`14`	`+ _columnOptions = columnOptions ?? throw new ArgumentNullException(nameof(columnOptions));`
	`15`	`+ }`
	`16`	`+`
	`17`	`+ public DataTable CreateDataTable()`
`8`	`18`	`{`
`9`		`- var eventsTable = new DataTable(tableName);`
	`19`	`+ var eventsTable = new DataTable(_tableName);`
`10`	`20`
`11`		`- foreach (var standardColumn in columnOptions.Store)`
	`21`	`+ foreach (var standardColumn in _columnOptions.Store)`
`12`	`22`	`{`
`13`		`- var standardOpts = columnOptions.GetStandardColumnOptions(standardColumn);`
	`23`	`+ var standardOpts = _columnOptions.GetStandardColumnOptions(standardColumn);`
`14`	`24`	`var dataColumn = standardOpts.AsDataColumn();`
`15`	`25`	`eventsTable.Columns.Add(dataColumn);`
`16`		`- if (standardOpts == columnOptions.PrimaryKey)`
	`26`	`+ if (standardOpts == _columnOptions.PrimaryKey)`
`17`	`27`	`eventsTable.PrimaryKey = new DataColumn[] { dataColumn };`
`18`	`28`	`}`
`19`	`29`
`20`		`- if (columnOptions.AdditionalColumns != null)`
	`30`	`+ if (_columnOptions.AdditionalColumns != null)`
`21`	`31`	`{`
`22`		`- foreach (var addCol in columnOptions.AdditionalColumns)`
	`32`	`+ foreach (var addCol in _columnOptions.AdditionalColumns)`
`23`	`33`	`{`
`24`	`34`	`var dataColumn = addCol.AsDataColumn();`
`25`	`35`	`eventsTable.Columns.Add(dataColumn);`
`26`		`- if (addCol == columnOptions.PrimaryKey)`
	`36`	`+ if (addCol == _columnOptions.PrimaryKey)`
`27`	`37`	`eventsTable.PrimaryKey = new DataColumn[] { dataColumn };`
`28`	`38`	`}`
`29`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ namespace Serilog.Sinks.MSSqlServer.Platform`
`4`	`4`	`{`
`5`	`5`	`internal interface IDataTableCreator`
`6`	`6`	`{`
`7`		`- DataTable CreateDataTable(string tableName, ColumnOptions columnOptions);`
	`7`	`+ DataTable CreateDataTable();`
`8`	`8`	`}`
`9`		`-}`
	`9`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,6 @@ namespace Serilog.Sinks.MSSqlServer.Platform`
`4`	`4`	`{`
`5`	`5`	`internal interface ISqlTableCreator`
`6`	`6`	`{`
`7`		`- void CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions);`
	`7`	`+ void CreateTable(DataTable dataTable);`
`8`	`8`	`}`
`9`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,22 +8,33 @@ namespace Serilog.Sinks.MSSqlServer.Platform`
`8`	`8`	`{`
`9`	`9`	`internal class SqlTableCreator : ISqlTableCreator`
`10`	`10`	`{`
	`11`	`+ private readonly string _tableName;`
	`12`	`+ private readonly string _schemaName;`
	`13`	`+ private readonly ColumnOptions _columnOptions;`
`11`	`14`	`private readonly ISqlCreateTableWriter _sqlCreateTableWriter;`
`12`	`15`	`private readonly ISqlConnectionFactory _sqlConnectionFactory;`
`13`	`16`
`14`		`- public SqlTableCreator(ISqlCreateTableWriter sqlCreateTableWriter, ISqlConnectionFactory sqlConnectionFactory)`
	`17`	`+ public SqlTableCreator(`
	`18`	`+ string tableName,`
	`19`	`+ string schemaName,`
	`20`	`+ ColumnOptions columnOptions,`
	`21`	`+ ISqlCreateTableWriter sqlCreateTableWriter,`
	`22`	`+ ISqlConnectionFactory sqlConnectionFactory)`
`15`	`23`	`{`
	`24`	`+ _tableName = tableName ?? throw new ArgumentNullException(nameof(tableName));`
	`25`	`+ _schemaName = schemaName ?? throw new ArgumentNullException(nameof(schemaName));`
	`26`	`+ _columnOptions = columnOptions ?? throw new ArgumentNullException(nameof(columnOptions));`
`16`	`27`	`_sqlCreateTableWriter = sqlCreateTableWriter ?? throw new ArgumentNullException(nameof(sqlCreateTableWriter));`
`17`	`28`	`_sqlConnectionFactory = sqlConnectionFactory ?? throw new ArgumentNullException(nameof(sqlConnectionFactory));`
`18`	`29`	`}`
`19`	`30`
`20`		`- public void CreateTable(string schemaName, string tableName, DataTable dataTable, ColumnOptions columnOptions)`
	`31`	`+ public void CreateTable(DataTable dataTable)`
`21`	`32`	`{`
`22`	`33`	`try`
`23`	`34`	`{`
`24`	`35`	`using (var conn = _sqlConnectionFactory.Create())`
`25`	`36`	`{`
`26`		`- var sql = _sqlCreateTableWriter.GetSqlFromDataTable(schemaName, tableName, dataTable, columnOptions);`
	`37`	`+ var sql = _sqlCreateTableWriter.GetSqlFromDataTable(_schemaName, _tableName, dataTable, _columnOptions);`
`27`	`38`	`using (var cmd = new SqlCommand(sql, conn))`
`28`	`39`	`{`
`29`	`40`	`conn.Open();`
`@@ -33,7 +44,7 @@ public void CreateTable(string schemaName, string tableName, DataTable dataTable`
`33`	`44`	`}`
`34`	`45`	`catch (Exception ex)`
`35`	`46`	`{`
`36`		`- SelfLog.WriteLine($"Exception creating table {tableName}:\n{ex}");`
	`47`	`+ SelfLog.WriteLine($"Exception creating table {_tableName}:\n{ex}");`
`37`	`48`	`}`
`38`	`49`	`}`
`39`	`50`	`}`