initial implementation

Author: MV10

README.md

@@ -410,13 +410,21 @@ Standard Columns are always excluded from the XML `Properties` column  but Stand
 
 ## External Configuration Syntax
 
-The _Serilog.Settings.AppSettings_ package supports XML-based configuration (either `app.config` or `web.config`), and the _Serilog.Settings.Configuration_ package supports the many _Microsoft.Extensions.Configuration_ sources. JSON is the most common, but other sources include environment variables, command lines, Azure Key Vault, XML, and more.  
+Projects targeting the .NET Framework automatically have support for XML-based configuration (either `app.config` or `web.config`) of `ColumnOptions` settings, and the _Serilog.Settings.AppSettings_ package adds XML-based configuration of sink arguments.
 
-### JSON syntax
+Projects targeting .NET Standard can apply configuration-driven sink setup and `ColumnOptions` settings using the _Serilog.Settings.Configuration_ (SSC) package. It supports any of the configuration sources supported by the underlying _Microsoft.Extensions.Configuration_ (MEC) packages. JSON is the most common, but other sources include environment variables, command lines, Azure Key Vault, XML, and more.  
 
 All properties of the `ColumnOptions` class are configurable except the `Properties.PropertyFilter` predicate expression. In most cases configuration keynames match the class property names, but there are some exceptions. For example, because `PrimaryKey` is a `SqlColumn` object reference when configured through code, external configuration uses a `primaryKeyColumnName` setting to identify the primary key by name.
 
-Keys and values are not case-sensitive.
+All `ColumnOptions` elements and lists are optional. Some settings or properties shown are mutually exclusive and are listed for documentation purposes -- these do not necessarily reflect real-world configurations that can be copy-pasted as-is.
+
+Custom columns and the stand-alone Standard Column entires all support the same general column properties (`ColumnName`, `DataType`, etc) listed in thec [SqlColumn Objects](#sqlcolumn-objects) topic. The samples omit many of these properties for brevity.
+
+If you combine external configuration with configuration through code, external configuration changes will be applied in addition to any `ColumnOptions` object you provide through code.
+
+### JSON: .NET Standard configuration
+
+Keys and values are not case-sensitive. This is an example of configuring the sink arguments.
 
 ```json
 {
@@ -441,15 +449,15 @@ Keys and values are not case-sensitive.
 }
 ```
 
-As the name suggests, `columnOptionSection` is an entire configuration section in its own right. All possible entries  are shown below, excluding properties like `ColumnName` and `AllowNull` that are available on every column definition. Some sample values are also shown below. All properties and subsections are optional. The `AdditionalColumns` collection can also be populated from a key named `customColumns` for backwards-compatibility reasons (not shown here). Some properties shown here are mutually exclusive (such as `clusteredColumnstoreIndex` and `primaryKeyColumnName`) -- the following does not represent a real-world configuration example, it is only a reference.
+As the name suggests, `columnOptionSection` is an entire configuration section in its own right. The `AdditionalColumns` collection can also be populated from a key named `customColumns` (not shown here) for backwards-compatibility reasons.
 
 ```json
 "columnOptionsSection": {
-    "addStandardColumns": [ "LogEvent" ],
-    "removeStandardColumns": [ "MessageTemplate", "Properties" ],
     "disableTriggers": true,
     "clusteredColumnstoreIndex": false,
     "primaryKeyColumnName": "Id",
+    "addStandardColumns": [ "LogEvent" ],
+    "removeStandardColumns": [ "MessageTemplate", "Properties" ],
     "additionalColumns": [
         { "ColumnName": "EventType", "DataType": "int", "AllowNull": false },
         { "ColumnName": "Release", "DataType": "varchar", "DataLength": 32 }
@@ -488,16 +496,24 @@ As the name suggests, `columnOptionSection` is an entire configuration section i
 }
 ```
 
-### ConfigurationManager XML syntax
+### XML: .NET Framework ColumnOptions configuration
 
-When targeting the .NET Framework, built-in support for `ConfigurationManager` allows you to define custom columns as it is represented in SQL Server. Columns specified must match the physical database exactly. This section will be processed automatically if it exists in the application's `web.config` or `app.config` file. The same properties listed in the topic [SqlColumn Objects](#sqlcolumn-objects) are available here.
+Keys and values are case-sensitive. Case must match **_exactly_** as shown below.
 
 ```xml
   <configSections>
     <section name="MSSqlServerSettingsSection"
              type="Serilog.Configuration.MSSqlServerConfigurationSection, Serilog.Sinks.MSSqlServer"/>
   </configSections>
-  <MSSqlServerSettingsSection>
+  <MSSqlServerSettingsSection DisableTriggers="false"
+                       ClusteredColumnstoreIndex="false"
+                       PrimaryKeyColumnName="Id">
+    <AddStandardColumns>
+        <add Name="LogEvent"/>
+    </AddStandardColumns>
+    <RemoveStandardColumns>
+        <remove Name="Properties"/>
+    </RemoveStandardColumns>
     <Columns>
       <add ColumnName="EventType" DataType="int"/>
       <add ColumnName="Release"
@@ -506,10 +522,31 @@ When targeting the .NET Framework, built-in support for `ConfigurationManager` a
            AllowNull="true"
            NonClusteredIndex="false"/>
     </Columns>
+    <Exception ColumnName="Ex" DataLength="512"/>
+    <Id NonClusteredIndex="true"/>
+    <Level ColumnName="Severity" StoreAsEnum="true"/>
+    <LogEvent ExcludeAdditionalProperties="true"
+              ExcludeStandardColumns="true"/>
+    <Message DataLength="1024"/>
+    <MessageTemplate DataLength="1536"/>
+    <Properties DataType="xml"
+                ExcludeAdditionalProperties="true"
+                DictionaryElementName="dict"
+                ItemElementName="item"
+                OmitDictionaryContainerElement="false"
+                OmitSequenceContainerElement="false"
+                OmitStructureContainerElement="false"
+                OmitElementIfEmpty="true"
+                PropertyElementName="prop"
+                RootElementName="root"
+                SequenceElementName="seq"
+                StructureElementName="struct"
+                UsePropertyKeyAsElementName="false"/>
+    <TimeStamp ConvertToUtc="true"/>
   </MSSqlServerSettingsSection>      
 ```
 
-### AppSettings XML syntax
+### XML: AppSettings sink configuration
 
 Refer to the _Serilog.Settings.AppSetings_ package documentation for complete details about sink configuration. This is an example of seting some of the configuration parameters for this sink.
 

src/Serilog.Sinks.MSSqlServer/Configuration/Microsoft.Extensions.Configuration/LoggerConfigurationMSSqlServerExtensions.cs

@@ -151,9 +151,6 @@ private static string GetConnectionString(string nameOrConnectionString, IConfig
             return cs;
         }
 
-        // simulate using a property setter as an out parameter
-        delegate void PropertySetter<T>(T value);
-
         /// <summary>
         /// Create or add to the ColumnOptions object and apply any configuration changes to it.
         /// </summary>
@@ -184,7 +181,8 @@ void AddRemoveStandardColumns()
                 {
                     foreach (var col in addStd.GetChildren().ToList())
                     {
-                        if (Enum.TryParse(col.Value, ignoreCase: true, result: out StandardColumn stdcol))
+                        if (Enum.TryParse(col.Value, ignoreCase: true, result: out StandardColumn stdcol)
+                            && !opts.Store.Contains(stdcol))
                             opts.Store.Add(stdcol);
                     }
                 }
@@ -195,7 +193,8 @@ void AddRemoveStandardColumns()
                 {
                     foreach (var col in removeStd.GetChildren().ToList())
                     {
-                        if (Enum.TryParse(col.Value, ignoreCase: true, result: out StandardColumn stdcol))
+                        if (Enum.TryParse(col.Value, ignoreCase: true, result: out StandardColumn stdcol)
+                            && opts.Store.Contains(stdcol))
                             opts.Store.Remove(stdcol);
                     }
                 }
@@ -211,12 +210,12 @@ void AddAdditionalColumns()
                 {
                     foreach (var c in newcols)
                     {
-                        if (!string.IsNullOrWhiteSpace(c.ColumnName))// && !string.IsNullOrWhiteSpace(c.DataType))
+                        if (!string.IsNullOrWhiteSpace(c.ColumnName))
                         {
                             if (opts.AdditionalColumns == null)
                                 opts.AdditionalColumns = new Collection<SqlColumn>();
 
-                            opts.AdditionalColumns.Add(c);//.AsSqlColumn());
+                            opts.AdditionalColumns.Add(c);
                         }
                     }
                 }
@@ -229,49 +228,49 @@ void ReadStandardColumns()
                 {
                     SetCommonColumnOptions(opts.Id);
                     #pragma warning disable 618 // deprecated: BigInt property
-                    SetIfProvided<bool>((val) => { opts.Id.BigInt = val; }, section["bigInt"]);
+                    SetProperty.IfNotNull<bool>(section["bigInt"], (val) => opts.Id.BigInt = val);
                     #pragma warning restore 618
                 }
 
                 section = config.GetSection("level");
                 if (section != null)
                 {
                     SetCommonColumnOptions(opts.Level);
-                    SetIfProvided<bool>((val) => { opts.Level.StoreAsEnum = val; }, section["storeAsEnum"]);
+                    SetProperty.IfNotNull<bool>(section["storeAsEnum"], (val) => opts.Level.StoreAsEnum = val);
                 }
 
                 section = config.GetSection("properties");
                 if (section != null)
                 {
                     SetCommonColumnOptions(opts.Properties);
-                    SetIfProvided<bool>((val) => { opts.Properties.ExcludeAdditionalProperties = val; }, section["excludeAdditionalProperties"]);
-                    SetIfProvided<string>((val) => { opts.Properties.DictionaryElementName = val; }, section["dictionaryElementName"]);
-                    SetIfProvided<string>((val) => { opts.Properties.ItemElementName = val; }, section["itemElementName"]);
-                    SetIfProvided<bool>((val) => { opts.Properties.OmitDictionaryContainerElement = val; }, section["omitDictionaryContainerElement"]);
-                    SetIfProvided<bool>((val) => { opts.Properties.OmitSequenceContainerElement = val; }, section["omitSequenceContainerElement"]);
-                    SetIfProvided<bool>((val) => { opts.Properties.OmitStructureContainerElement = val; }, section["omitStructureContainerElement"]);
-                    SetIfProvided<bool>((val) => { opts.Properties.OmitElementIfEmpty = val; }, section["omitElementIfEmpty"]);
-                    SetIfProvided<string>((val) => { opts.Properties.PropertyElementName = val; }, section["propertyElementName"]);
-                    SetIfProvided<string>((val) => { opts.Properties.RootElementName = val; }, section["rootElementName"]);
-                    SetIfProvided<string>((val) => { opts.Properties.SequenceElementName = val; }, section["sequenceElementName"]);
-                    SetIfProvided<string>((val) => { opts.Properties.StructureElementName = val; }, section["structureElementName"]);
-                    SetIfProvided<bool>((val) => { opts.Properties.UsePropertyKeyAsElementName = val; }, section["usePropertyKeyAsElementName"]);
+                    SetProperty.IfNotNull<bool>(section["excludeAdditionalProperties"], (val) => opts.Properties.ExcludeAdditionalProperties = val);
+                    SetProperty.IfNotNull<string>(section["dictionaryElementName"], (val) => opts.Properties.DictionaryElementName = val);
+                    SetProperty.IfNotNull<string>(section["itemElementName"], (val) => opts.Properties.ItemElementName = val);
+                    SetProperty.IfNotNull<bool>(section["omitDictionaryContainerElement"], (val) => opts.Properties.OmitDictionaryContainerElement = val);
+                    SetProperty.IfNotNull<bool>(section["omitSequenceContainerElement"], (val) => opts.Properties.OmitSequenceContainerElement = val);
+                    SetProperty.IfNotNull<bool>(section["omitStructureContainerElement"], (val) => opts.Properties.OmitStructureContainerElement = val);
+                    SetProperty.IfNotNull<bool>(section["omitElementIfEmpty"], (val) => opts.Properties.OmitElementIfEmpty = val);
+                    SetProperty.IfNotNull<string>(section["propertyElementName"], (val) => opts.Properties.PropertyElementName = val);
+                    SetProperty.IfNotNull<string>(section["rootElementName"], (val) => opts.Properties.RootElementName = val);
+                    SetProperty.IfNotNull<string>(section["sequenceElementName"], (val) => opts.Properties.SequenceElementName = val);
+                    SetProperty.IfNotNull<string>(section["structureElementName"], (val) => opts.Properties.StructureElementName = val);
+                    SetProperty.IfNotNull<bool>(section["usePropertyKeyAsElementName"], (val) => opts.Properties.UsePropertyKeyAsElementName = val);
                     // TODO PropertiesFilter would need a compiled Predicate<string> (high Roslyn overhead, see Serilog Config repo #106)
                 }
 
                 section = config.GetSection("timeStamp");
                 if (section != null)
                 {
                     SetCommonColumnOptions(opts.TimeStamp);
-                    SetIfProvided<bool>((val) => { opts.TimeStamp.ConvertToUtc = val; }, section["convertToUtc"]);
+                    SetProperty.IfNotNull<bool>(section["convertToUtc"], (val) => opts.TimeStamp.ConvertToUtc = val);
                 }
 
                 section = config.GetSection("logEvent");
                 if (section != null)
                 {
                     SetCommonColumnOptions(opts.LogEvent);
-                    SetIfProvided<bool>((val) => { opts.LogEvent.ExcludeAdditionalProperties = val; }, section["excludeAdditionalProperties"]);
-                    SetIfProvided<bool>((val) => { opts.LogEvent.ExcludeStandardColumns = val; }, section["ExcludeStandardColumns"]);
+                    SetProperty.IfNotNull<bool>(section["excludeAdditionalProperties"], (val) => opts.LogEvent.ExcludeAdditionalProperties = val);
+                    SetProperty.IfNotNull<bool>(section["ExcludeStandardColumns"], (val) => opts.LogEvent.ExcludeStandardColumns = val);
                 }
 
                 section = config.GetSection("message");
@@ -289,18 +288,18 @@ void ReadStandardColumns()
                 // Standard Columns are subclasses of the SqlColumn class
                 void SetCommonColumnOptions(SqlColumn target)
                 {
-                    SetIfProvided<string>((val) => { target.ColumnName = val; }, section["columnName"]);
-                    SetIfProvided<string>((val) => { target.SetDataTypeFromConfigString(val); }, section["dataType"]);
-                    SetIfProvided<bool>((val) => { target.AllowNull = val; }, section["allowNull"]);
-                    SetIfProvided<int>((val) => { target.DataLength = val; }, section["dataLength"]);
-                    SetIfProvided<bool>((val) => { target.NonClusteredIndex = val; }, section["nonClusteredIndex"]);
+                    SetProperty.IfNotNullOrEmpty<string>(section["columnName"], (val) => target.ColumnName = val);
+                    SetProperty.IfNotNull<string>(section["dataType"], (val) => target.SetDataTypeFromConfigString(val));
+                    SetProperty.IfNotNull<bool>(section["allowNull"], (val) => target.AllowNull = val);
+                    SetProperty.IfNotNull<int>(section["dataLength"], (val) => target.DataLength = val);
+                    SetProperty.IfNotNull<bool>(section["nonClusteredIndex"], (val) => target.NonClusteredIndex = val);
                 }
             }
 
             void ReadMiscColumnOptions()
             {
-                SetIfProvided<bool>((val) => { opts.DisableTriggers = val; }, config["disableTriggers"]);
-                SetIfProvided<bool>((val) => { opts.ClusteredColumnstoreIndex = val; }, config["clusteredColumnstoreIndex"]);
+                SetProperty.IfNotNull<bool>(config["disableTriggers"], (val) => opts.DisableTriggers = val);
+                SetProperty.IfNotNull<bool>(config["clusteredColumnstoreIndex"], (val) => opts.ClusteredColumnstoreIndex = val);
 
                 string pkName = config["primaryKeyColumnName"];
                 if (!string.IsNullOrEmpty(pkName))
@@ -334,23 +333,6 @@ void ReadMiscColumnOptions()
                         throw new ArgumentException($"Could not match the configured primary key column name \"{pkName}\" with a data column in the table.");
                 }
             }
-
-            // This is used to only set a column property when it is actually specified in the config.
-            // When a value is requested from config, it returns null if that value hasn't been specified.
-            // This also means you can't use config to set a property to null.
-            void SetIfProvided<T>(PropertySetter<T> setter, string value)
-            {
-                if(value == null)
-                    return;
-                try
-                {
-                    var setting = (T)Convert.ChangeType(value, typeof(T));
-                    setter(setting);
-                }
-                // don't change the property if the conversion failed 
-                catch (InvalidCastException) { }
-                catch (OverflowException) { }
-            }
         }
     }
 }

src/Serilog.Sinks.MSSqlServer/Configuration/NetFramework.ConfigurationManager/ColumnCollection.cs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-using System.ComponentModel;
 using System.Configuration;
 
 // Disable XML comment warnings for internal config classes which are required to have public members