Notices: This section not yet converted to new layout. Download stats are rolling back out.

Stratos

0.7.1

This package skips automatic verification:

This package has a dependency for dotnet4.5.2, but that package requires a reboot to work.


This package was approved as a trusted package on 3/30/2019.

Stratos, a simple HTTP service to list out installed NuGet and Chocolatey packages from a host.

To install Stratos, run the following command from the command line or from PowerShell:

C:\> choco install stratos

To upgrade Stratos, run the following command from the command line or from PowerShell:

C:\> choco upgrade stratos

Files

Hide
  • bin\LightInject.dll Show
    md5: C75885EA1D39E56372EADBFFCC0B270F | sha1: D3E7625CB6C4091A9DB6587FCA2A5CA3DDBCC09A | sha256: 0AF01DB6E4F84D2DDEE0670B3A12637C6C2AEA6466272AE35AFEE0DF99AC09E0 | sha512: 3DD007D0D49E8D59F883F2EDD45C1E60B8E47EA535F48AC57D7944F2E5DF76FBB449185E4D0884B106E9BA851B1F6A733E22223F6C19296ED28D0E8974ED0281
  • bin\LightInject.Nancy.dll Show
    md5: 68ACC078320A4BE398B0D037C17FCE33 | sha1: 654D6746A1437BCC0446F0FD2F640879C2309310 | sha256: 186BB052FDEC69D5FF7EA37B19305D902973F54767C7732AB76F1790CE227BDF | sha512: F1B1EB1C3372A2BDF8B2F81F910AAC1F83F17CA5635FA686AB90BB72CDE01DCAF8335E902802D29280CAA24BFC9EEFE9B059DA37C7F88F8CDE042DB54666E4FD
  • bin\Microsoft.Web.XmlTransform.dll Show
    md5: 6AD7D1E92C9833F4BDDE6A4BC84F2E1A | sha1: B38D23B6A960F5F07664565835137FE3C8FDB7ED | sha256: 13DCF5066E00152238191314D4A46605204FFABDBB830BDD0C97DF3027D1261D | sha512: 01C4ECC46576618394FBBEE701F5A726F97D31FB39D5F1C6305D21CA7AD0B0ABC09B69FB733C42D4D1203FCE78DD3F3D5129C21EA0BC9B92D0AB3A7BF09C006C
  • bin\Nancy.dll Show
    md5: A8F2E5DCD9797A2B08F92BFE3936685F | sha1: 86D8DF9CF9E06BFAABEB344A4F6DC7DCC4984B37 | sha256: F6AF0F1C2E7E1102F87D0EC2DE51688C03653EF1616A64B1764C76993AFC504F | sha512: 8E9D6269D707D3793F750E02721E1EDDC138A8C3689737D83810819AF73452E991CEE843EF5A1168439281434DF7085561CBFFE39D141BE7712C4096A0F0C574
  • bin\Nancy.Hosting.Self.dll Show
    md5: 13DECF5B3D31D4896CC1DC292207A3E9 | sha1: 5F448F8CBF12A9BE55C046351AABC146E2388BF0 | sha256: 677A03C4E1BE4B17177F224F453F1DA3B120781AEF00DF8B42D92BFA8746D9BA | sha512: 9D786153220A2D7237A54F99209D0BA4D9E3210D6E81779C8A9412F65691ECBD46DF55945C732B034425AC241E9891769008D8516B5FB81D3CC280AD2138E311
  • bin\Nancy.Serialization.JsonNet.dll Show
    md5: 289D10828C34D6F7742DFA438DB492D8 | sha1: 2FACBD8F9A733F43A96EDFD3673965B164339E90 | sha256: F48A150249566FCD481AC38FA834B354BD754CBE32D4E9CD9F2489BD32D2611D | sha512: 2B3302F9976DC749C001C2F2BC826CE0A16BAE299BEA9A8E47BE1DF9968BC87071B8AD155736B0DB4FB6D5107AC688718C5EB1F4679CC51B91E3DCE636918742
  • bin\Newtonsoft.Json.dll Show
    md5: C53737821B861D454D5248034C3C097C | sha1: 6B0DA75617A2269493DC1A685D7A0B07F2E48C75 | sha256: 575E30F98E4EA42C9E516EDC8BBB29AD8B50B173A3E6B36B5BA39E133CCE9406 | sha512: 289543F5EEA472E9027030E24011BEA1E49E91059241FE6EB732E78F51822313E47D1E4769FA1C9C7D6139F6A97DCFEF2946836B3383E8643988BF8908162FB9
  • bin\NLog.dll Show
    md5: 770468383F0380A2F74598466C6B4F45 | sha1: FFB4BA12365AE6689D76590CED4F536EFC23D6DD | sha256: B7F12ACEF07973EFA8FB58F2BD6429554465EDE590FDA9B79605C70E83E322B7 | sha512: 88B1F8AF321A22B28C6C9F3A1A0CB33A901F959F2743766586D7F7F3C9D17537B348B913DF522EEF919DE6C3B33B7B3C9FE9B91186ED738E152B8A3F53EFE2E6
  • bin\NLog.xml Show
    <?xml version="1.0"?>
    <doc>
        <assembly>
            <name>NLog</name>
        </assembly>
        <members>
            <member name="T:JetBrains.Annotations.CanBeNullAttribute">
                <summary>
                Indicates that the value of the marked element could be <c>null</c> sometimes,
                so the check for <c>null</c> is necessary before its usage.
                </summary>
                <example><code>
                [CanBeNull] object Test() => null;
                
                void UseTest() {
                  var p = Test();
                  var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.NotNullAttribute">
                <summary>
                Indicates that the value of the marked element could never be <c>null</c>.
                </summary>
                <example><code>
                [NotNull] object Foo() {
                  return null; // Warning: Possible 'null' assignment
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.ItemNotNullAttribute">
                <summary>
                Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
                and Lazy classes to indicate that the value of a collection item, of the Task.Result property
                or of the Lazy.Value property can never be null.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.ItemCanBeNullAttribute">
                <summary>
                Can be appplied to symbols of types derived from IEnumerable as well as to symbols of Task
                and Lazy classes to indicate that the value of a collection item, of the Task.Result property
                or of the Lazy.Value property can be null.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.StringFormatMethodAttribute">
                <summary>
                Indicates that the marked method builds string by format pattern and (optional) arguments.
                Parameter, which contains format string, should be given in constructor. The format string
                should be in <see cref="M:System.String.Format(System.IFormatProvider,System.String,System.Object[])"/>-like form.
                </summary>
                <example><code>
                [StringFormatMethod("message")]
                void ShowError(string message, params object[] args) { /* do something */ }
                
                void Foo() {
                  ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
                }
                </code></example>
            </member>
            <member name="M:JetBrains.Annotations.StringFormatMethodAttribute.#ctor(System.String)">
                <param name="formatParameterName">
                Specifies which parameter of an annotated method should be treated as format-string
                </param>
            </member>
            <member name="T:JetBrains.Annotations.ValueProviderAttribute">
                <summary>
                For a parameter that is expected to be one of the limited set of values.
                Specify fields of which type should be used as values for this parameter.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.InvokerParameterNameAttribute">
                <summary>
                Indicates that the function argument should be string literal and match one
                of the parameters of the caller function. For example, ReSharper annotates
                the parameter of <see cref="T:System.ArgumentNullException"/>.
                </summary>
                <example><code>
                void Foo(string param) {
                  if (param == null)
                    throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.NotifyPropertyChangedInvocatorAttribute">
                 <summary>
                 Indicates that the method is contained in a type that implements
                 <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
                 is used to notify that some property value changed.
                 </summary>
                 <remarks>
                 The method should be non-static and conform to one of the supported signatures:
                 <list>
                 <item><c>NotifyChanged(string)</c></item>
                 <item><c>NotifyChanged(params string[])</c></item>
                 <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
                 <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
                 <item><c>SetProperty{T}(ref T, T, string)</c></item>
                 </list>
                 </remarks>
                 <example><code>
                 public class Foo : INotifyPropertyChanged {
                   public event PropertyChangedEventHandler PropertyChanged;
                 
                   [NotifyPropertyChangedInvocator]
                   protected virtual void NotifyChanged(string propertyName) { ... }
                
                   string _name;
                 
                   public string Name {
                     get { return _name; }
                     set { _name = value; NotifyChanged("LastName"); /* Warning */ }
                   }
                 }
                 </code>
                 Examples of generated notifications:
                 <list>
                 <item><c>NotifyChanged("Property")</c></item>
                 <item><c>NotifyChanged(() =&gt; Property)</c></item>
                 <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
                 <item><c>SetProperty(ref myField, value, "Property")</c></item>
                 </list>
                 </example>
            </member>
            <member name="T:JetBrains.Annotations.ContractAnnotationAttribute">
                <summary>
                Describes dependency between method input and output.
                </summary>
                <syntax>
                <p>Function Definition Table syntax:</p>
                <list>
                <item>FDT      ::= FDTRow [;FDTRow]*</item>
                <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
                <item>Input    ::= ParameterName: Value [, Input]*</item>
                <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
                <item>Value    ::= true | false | null | notnull | canbenull</item>
                </list>
                If method has single input parameter, it's name could be omitted.<br/>
                Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for method output
                means that the methos doesn't return normally (throws or terminates the process).<br/>
                Value <c>canbenull</c> is only applicable for output parameters.<br/>
                You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
                with rows separated by semicolon. There is no notion of order rows, all rows are checked
                for applicability and applied per each program state tracked by R# analysis.<br/>
                </syntax>
                <examples><list>
                <item><code>
                [ContractAnnotation("=&gt; halt")]
                public void TerminationMethod()
                </code></item>
                <item><code>
                [ContractAnnotation("halt &lt;= condition: false")]
                public void Assert(bool condition, string text) // regular assertion method
                </code></item>
                <item><code>
                [ContractAnnotation("s:null =&gt; true")]
                public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
                </code></item>
                <item><code>
                // A method that returns null if the parameter is null,
                // and not null if the parameter is not null
                [ContractAnnotation("null =&gt; null; notnull =&gt; notnull")]
                public object Transform(object data) 
                </code></item>
                <item><code>
                [ContractAnnotation("=&gt; true, result: notnull; =&gt; false, result: null")]
                public bool TryParse(string s, out Person result)
                </code></item>
                </list></examples>
            </member>
            <member name="T:JetBrains.Annotations.LocalizationRequiredAttribute">
                <summary>
                Indicates that marked element should be localized or not.
                </summary>
                <example><code>
                [LocalizationRequiredAttribute(true)]
                class Foo {
                  string str = "my string"; // Warning: Localizable string
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.CannotApplyEqualityOperatorAttribute">
                <summary>
                Indicates that the value of the marked type (or its derivatives)
                cannot be compared using '==' or '!=' operators and <c>Equals()</c>
                should be used instead. However, using '==' or '!=' for comparison
                with <c>null</c> is always permitted.
                </summary>
                <example><code>
                [CannotApplyEqualityOperator]
                class NoEquality { }
                
                class UsesNoEquality {
                  void Test() {
                    var ca1 = new NoEquality();
                    var ca2 = new NoEquality();
                    if (ca1 != null) { // OK
                      bool condition = ca1 == ca2; // Warning
                    }
                  }
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.BaseTypeRequiredAttribute">
                <summary>
                When applied to a target attribute, specifies a requirement for any type marked
                with the target attribute to implement or inherit specific type or types.
                </summary>
                <example><code>
                [BaseTypeRequired(typeof(IComponent)] // Specify requirement
                class ComponentAttribute : Attribute { }
                
                [Component] // ComponentAttribute requires implementing IComponent interface
                class MyComponent : IComponent { }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.UsedImplicitlyAttribute">
                <summary>
                Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
                so this symbol will not be marked as unused (as well as by other usage inspections).
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.MeansImplicitUseAttribute">
                <summary>
                Should be used on attributes and causes ReSharper to not mark symbols marked with such attributes
                as unused (as well as by other usage inspections)
                </summary>
            </member>
            <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.Access">
                <summary>Only entity marked with attribute considered used.</summary>
            </member>
            <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.Assign">
                <summary>Indicates implicit assignment to a member.</summary>
            </member>
            <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature">
                <summary>
                Indicates implicit instantiation of a type with fixed constructor signature.
                That means any unused constructor parameters won't be reported as such.
                </summary>
            </member>
            <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature">
                <summary>Indicates implicit instantiation of a type.</summary>
            </member>
            <member name="T:JetBrains.Annotations.ImplicitUseTargetFlags">
                <summary>
                Specify what is considered used implicitly when marked
                with <see cref="T:JetBrains.Annotations.MeansImplicitUseAttribute"/> or <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>.
                </summary>
            </member>
            <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.Members">
                <summary>Members of entity marked with attribute are considered used.</summary>
            </member>
            <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.WithMembers">
                <summary>Entity marked with attribute and all its members considered used.</summary>
            </member>
            <member name="T:JetBrains.Annotations.PublicAPIAttribute">
                <summary>
                This attribute is intended to mark publicly available API
                which should not be removed and so is treated as used.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.InstantHandleAttribute">
                <summary>
                Tells code analysis engine if the parameter is completely handled when the invoked method is on stack.
                If the parameter is a delegate, indicates that delegate is executed while the method is executed.
                If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.PureAttribute">
                <summary>
                Indicates that a method does not make any observable state changes.
                The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
                </summary>
                <example><code>
                [Pure] int Multiply(int x, int y) => x * y;
                
                void M() {
                  Multiply(123, 42); // Waring: Return value of pure method is not used
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.MustUseReturnValueAttribute">
                <summary>
                Indicates that the return value of method invocation must be used.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.ProvidesContextAttribute">
                <summary>
                Indicates the type member or parameter of some type, that should be used instead of all other ways
                to get the value that type. This annotation is useful when you have some "context" value evaluated
                and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
                </summary>
                <example><code>
                class Foo {
                  [ProvidesContext] IBarService _barService = ...;
                
                  void ProcessNode(INode node) {
                    DoSomething(node, node.GetGlobalServices().Bar);
                    //              ^ Warning: use value of '_barService' field
                  }
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.PathReferenceAttribute">
                <summary>
                Indicates that a parameter is a path to a file or a folder within a web project.
                Path can be relative or absolute, starting from web root (~).
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.SourceTemplateAttribute">
                <summary>
                An extension method marked with this attribute is processed by ReSharper code completion
                as a 'Source Template'. When extension method is completed over some expression, it's source code
                is automatically expanded like a template at call site.
                </summary>
                <remarks>
                Template method body can contain valid source code and/or special comments starting with '$'.
                Text inside these comments is added as source code when the template is applied. Template parameters
                can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
                Use the <see cref="T:JetBrains.Annotations.MacroAttribute"/> attribute to specify macros for parameters.
                </remarks>
                <example>
                In this example, the 'forEach' method is a source template available over all values
                of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
                <code>
                [SourceTemplate]
                public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
                  foreach (var x in xs) {
                     //$ $END$
                  }
                }
                </code>
                </example>
            </member>
            <member name="T:JetBrains.Annotations.MacroAttribute">
                <summary>
                Allows specifying a macro for a parameter of a <see cref="T:JetBrains.Annotations.SourceTemplateAttribute">source template</see>.
                </summary>
                <remarks>
                You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
                is defined in the <see cref="P:JetBrains.Annotations.MacroAttribute.Expression"/> property. When applied on a method, the target
                template parameter is defined in the <see cref="P:JetBrains.Annotations.MacroAttribute.Target"/> property. To apply the macro silently
                for the parameter, set the <see cref="P:JetBrains.Annotations.MacroAttribute.Editable"/> property value = -1.
                </remarks>
                <example>
                Applying the attribute on a source template method:
                <code>
                [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
                public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
                  foreach (var item in collection) {
                    //$ $END$
                  }
                }
                </code>
                Applying the attribute on a template method parameter:
                <code>
                [SourceTemplate]
                public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
                  /*$ var $x$Id = "$newguid$" + x.ToString();
                  x.DoSomething($x$Id); */
                }
                </code>
                </example>
            </member>
            <member name="P:JetBrains.Annotations.MacroAttribute.Expression">
                <summary>
                Allows specifying a macro that will be executed for a <see cref="T:JetBrains.Annotations.SourceTemplateAttribute">source template</see>
                parameter when the template is expanded.
                </summary>
            </member>
            <member name="P:JetBrains.Annotations.MacroAttribute.Editable">
                <summary>
                Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
                </summary>
                <remarks>
                If the target parameter is used several times in the template, only one occurrence becomes editable;
                other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
                use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
                </remarks>>
            </member>
            <member name="P:JetBrains.Annotations.MacroAttribute.Target">
                <summary>
                Identifies the target parameter of a <see cref="T:JetBrains.Annotations.SourceTemplateAttribute">source template</see> if the
                <see cref="T:JetBrains.Annotations.MacroAttribute"/> is applied on a template method.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcActionAttribute">
                <summary>
                ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
                is an MVC action. If applied to a method, the MVC action name is calculated
                implicitly from the context. Use this attribute for custom wrappers similar to
                <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcAreaAttribute">
                <summary>
                ASP.NET MVC attribute. Indicates that a parameter is an MVC area.
                Use this attribute for custom wrappers similar to
                <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcControllerAttribute">
                <summary>
                ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is
                an MVC controller. If applied to a method, the MVC controller name is calculated
                implicitly from the context. Use this attribute for custom wrappers similar to
                <c>System.Web.Mvc.Html.ChildActionExtensions.RenderAction(HtmlHelper, String, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcMasterAttribute">
                <summary>
                ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. Use this attribute
                for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcModelTypeAttribute">
                <summary>
                ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. Use this attribute
                for custom wrappers similar to <c>System.Web.Mvc.Controller.View(String, Object)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcPartialViewAttribute">
                <summary>
                ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC
                partial view. If applied to a method, the MVC partial view name is calculated implicitly
                from the context. Use this attribute for custom wrappers similar to
                <c>System.Web.Mvc.Html.RenderPartialExtensions.RenderPartial(HtmlHelper, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcSuppressViewErrorAttribute">
                <summary>
                ASP.NET MVC attribute. Allows disabling inspections for MVC views within a class or a method.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcDisplayTemplateAttribute">
                <summary>
                ASP.NET MVC attribute. Indicates that a parameter is an MVC display template.
                Use this attribute for custom wrappers similar to 
                <c>System.Web.Mvc.Html.DisplayExtensions.DisplayForModel(HtmlHelper, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcEditorTemplateAttribute">
                <summary>
                ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template.
                Use this attribute for custom wrappers similar to
                <c>System.Web.Mvc.Html.EditorExtensions.EditorForModel(HtmlHelper, String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcTemplateAttribute">
                <summary>
                ASP.NET MVC attribute. Indicates that a parameter is an MVC template.
                Use this attribute for custom wrappers similar to
                <c>System.ComponentModel.DataAnnotations.UIHintAttribute(System.String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcViewAttribute">
                <summary>
                ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
                is an MVC view component. If applied to a method, the MVC view name is calculated implicitly
                from the context. Use this attribute for custom wrappers similar to
                <c>System.Web.Mvc.Controller.View(Object)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcViewComponentAttribute">
                <summary>
                ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
                is an MVC view component name.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcViewComponentViewAttribute">
                <summary>
                ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter
                is an MVC view component view. If applied to a method, the MVC view component view name is default.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AspMvcActionSelectorAttribute">
                <summary>
                ASP.NET MVC attribute. When applied to a parameter of an attribute,
                indicates that this parameter is an MVC action name.
                </summary>
                <example><code>
                [ActionName("Foo")]
                public ActionResult Login(string returnUrl) {
                  ViewBag.ReturnUrl = Url.Action("Foo"); // OK
                  return RedirectToAction("Bar"); // Error: Cannot resolve action
                }
                </code></example>
            </member>
            <member name="T:JetBrains.Annotations.RazorSectionAttribute">
                <summary>
                Razor attribute. Indicates that a parameter or a method is a Razor section.
                Use this attribute for custom wrappers similar to 
                <c>System.Web.WebPages.WebPageBase.RenderSection(String)</c>.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.CollectionAccessAttribute">
                <summary>
                Indicates how method, constructor invocation or property access
                over collection type affects content of the collection.
                </summary>
            </member>
            <member name="F:JetBrains.Annotations.CollectionAccessType.None">
                <summary>Method does not use or modify content of the collection.</summary>
            </member>
            <member name="F:JetBrains.Annotations.CollectionAccessType.Read">
                <summary>Method only reads content of the collection but does not modify it.</summary>
            </member>
            <member name="F:JetBrains.Annotations.CollectionAccessType.ModifyExistingContent">
                <summary>Method can change content of the collection but does not add new elements.</summary>
            </member>
            <member name="F:JetBrains.Annotations.CollectionAccessType.UpdatedContent">
                <summary>Method can add new elements to the collection.</summary>
            </member>
            <member name="T:JetBrains.Annotations.AssertionMethodAttribute">
                <summary>
                Indicates that the marked method is assertion method, i.e. it halts control flow if
                one of the conditions is satisfied. To set the condition, mark one of the parameters with 
                <see cref="T:JetBrains.Annotations.AssertionConditionAttribute"/> attribute.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AssertionConditionAttribute">
                <summary>
                Indicates the condition parameter of the assertion method. The method itself should be
                marked by <see cref="T:JetBrains.Annotations.AssertionMethodAttribute"/> attribute. The mandatory argument of
                the attribute is the assertion type.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.AssertionConditionType">
                <summary>
                Specifies assertion type. If the assertion method argument satisfies the condition,
                then the execution continues. Otherwise, execution is assumed to be halted.
                </summary>
            </member>
            <member name="F:JetBrains.Annotations.AssertionConditionType.IS_TRUE">
                <summary>Marked parameter should be evaluated to true.</summary>
            </member>
            <member name="F:JetBrains.Annotations.AssertionConditionType.IS_FALSE">
                <summary>Marked parameter should be evaluated to false.</summary>
            </member>
            <member name="F:JetBrains.Annotations.AssertionConditionType.IS_NULL">
                <summary>Marked parameter should be evaluated to null value.</summary>
            </member>
            <member name="F:JetBrains.Annotations.AssertionConditionType.IS_NOT_NULL">
                <summary>Marked parameter should be evaluated to not null value.</summary>
            </member>
            <member name="T:JetBrains.Annotations.TerminatesProgramAttribute">
                <summary>
                Indicates that the marked method unconditionally terminates control flow execution.
                For example, it could unconditionally throw exception.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.LinqTunnelAttribute">
                <summary>
                Indicates that method is pure LINQ method, with postponed enumeration (like Enumerable.Select,
                .Where). This annotation allows inference of [InstantHandle] annotation for parameters
                of delegate type by analyzing LINQ method chains.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.NoEnumerationAttribute">
                <summary>
                Indicates that IEnumerable, passed as parameter, is not enumerated.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.RegexPatternAttribute">
                <summary>
                Indicates that parameter is regular expression pattern.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.NoReorderAttribute">
                <summary>
                Prevents the Member Reordering feature from tossing members of the marked class.
                </summary>
                <remarks>
                The attribute must be mentioned in your member reordering patterns
                </remarks>
            </member>
            <member name="T:JetBrains.Annotations.XamlItemsControlAttribute">
                <summary>
                XAML attribute. Indicates the type that has <c>ItemsSource</c> property and should be treated
                as <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolve.
                </summary>
            </member>
            <member name="T:JetBrains.Annotations.XamlItemBindingOfItemsControlAttribute">
                <summary>
                XAML attribute. Indicates the property of some <c>BindingBase</c>-derived type, that
                is used to bind some item of <c>ItemsControl</c>-derived type. This annotation will
                enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
                </summary>
                <remarks>
                Property should have the tree ancestor of the <c>ItemsControl</c> type or
                marked with the <see cref="T:JetBrains.Annotations.XamlItemsControlAttribute"/> attribute.
                </remarks>
            </member>
            <member name="T:NLog.Common.AsyncContinuation">
                <summary>
                Asynchronous continuation delegate - function invoked at the end of asynchronous
                processing.
                </summary>
                <param name="exception">Exception during asynchronous processing or null if no exception
                was thrown.</param>
            </member>
            <member name="T:NLog.Common.AsyncHelpers">
                <summary>
                Helpers for asynchronous operations.
                </summary>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.ForEachItemSequentially``1(System.Collections.Generic.IEnumerable{``0},NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction{``0})">
                <summary>
                Iterates over all items in the given collection and runs the specified action
                in sequence (each action executes only after the preceding one has completed without an error).
                </summary>
                <typeparam name="T">Type of each item.</typeparam>
                <param name="items">The items to iterate.</param>
                <param name="asyncContinuation">The asynchronous continuation to invoke once all items
                have been iterated.</param>
                <param name="action">The action to invoke for each item.</param>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.Repeat(System.Int32,NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction)">
                <summary>
                Repeats the specified asynchronous action multiple times and invokes asynchronous continuation at the end.
                </summary>
                <param name="repeatCount">The repeat count.</param>
                <param name="asyncContinuation">The asynchronous continuation to invoke at the end.</param>
                <param name="action">The action to invoke.</param>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.PrecededBy(NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction)">
                <summary>
                Modifies the continuation by pre-pending given action to execute just before it.
                </summary>
                <param name="asyncContinuation">The async continuation.</param>
                <param name="action">The action to pre-pend.</param>
                <returns>Continuation which will execute the given action before forwarding to the actual continuation.</returns>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.WithTimeout(NLog.Common.AsyncContinuation,System.TimeSpan)">
                <summary>
                Attaches a timeout to a continuation which will invoke the continuation when the specified
                timeout has elapsed.
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
                <param name="timeout">The timeout.</param>
                <returns>Wrapped continuation.</returns>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.ForEachItemInParallel``1(System.Collections.Generic.IEnumerable{``0},NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction{``0})">
                <summary>
                Iterates over all items in the given collection and runs the specified action
                in parallel (each action executes on a thread from thread pool).
                </summary>
                <typeparam name="T">Type of each item.</typeparam>
                <param name="values">The items to iterate.</param>
                <param name="asyncContinuation">The asynchronous continuation to invoke once all items
                have been iterated.</param>
                <param name="action">The action to invoke for each item.</param>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.RunSynchronously(NLog.Common.AsynchronousAction)">
                <summary>
                Runs the specified asynchronous action synchronously (blocks until the continuation has
                been invoked).
                </summary>
                <param name="action">The action.</param>
                <remarks>
                Using this method is not recommended because it will block the calling thread.
                </remarks>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.PreventMultipleCalls(NLog.Common.AsyncContinuation)">
                <summary>
                Wraps the continuation with a guard which will only make sure that the continuation function
                is invoked only once.
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
                <returns>Wrapped asynchronous continuation.</returns>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.GetCombinedException(System.Collections.Generic.IList{System.Exception})">
                <summary>
                Gets the combined exception from all exceptions in the list.
                </summary>
                <param name="exceptions">The exceptions.</param>
                <returns>Combined exception or null if no exception was thrown.</returns>
            </member>
            <member name="M:NLog.Common.AsyncHelpers.WaitForDispose(System.Threading.Timer,System.TimeSpan)">
                <summary>
                Disposes the Timer, and waits for it to leave the Timer-callback-method
                </summary>
                <param name="timer">The Timer object to dispose</param>
                <param name="timeout">Timeout to wait (TimeSpan.Zero means dispose without wating)</param>
                <returns>Timer disposed within timeout (true/false)</returns>
            </member>
            <member name="T:NLog.Common.AsynchronousAction">
                <summary>
                Asynchronous action.
                </summary>
                <param name="asyncContinuation">Continuation to be invoked at the end of action.</param>
            </member>
            <member name="T:NLog.Common.AsynchronousAction`1">
                <summary>
                Asynchronous action with one argument.
                </summary>
                <typeparam name="T">Type of the argument.</typeparam>
                <param name="argument">Argument to the action.</param>
                <param name="asyncContinuation">Continuation to be invoked at the end of action.</param>
            </member>
            <member name="T:NLog.Common.AsyncLogEventInfo">
                <summary>
                Represents the logging event with asynchronous continuation.
                </summary>
            </member>
            <member name="M:NLog.Common.AsyncLogEventInfo.#ctor(NLog.LogEventInfo,NLog.Common.AsyncContinuation)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Common.AsyncLogEventInfo"/> struct.
                </summary>
                <param name="logEvent">The log event.</param>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="P:NLog.Common.AsyncLogEventInfo.LogEvent">
                <summary>
                Gets the log event.
                </summary>
            </member>
            <member name="P:NLog.Common.AsyncLogEventInfo.Continuation">
                <summary>
                Gets the continuation.
                </summary>
            </member>
            <member name="M:NLog.Common.AsyncLogEventInfo.op_Equality(NLog.Common.AsyncLogEventInfo,NLog.Common.AsyncLogEventInfo)">
                <summary>
                Implements the operator ==.
                </summary>
                <param name="eventInfo1">The event info1.</param>
                <param name="eventInfo2">The event info2.</param>
                <returns>The result of the operator.</returns>
            </member>
            <member name="M:NLog.Common.AsyncLogEventInfo.op_Inequality(NLog.Common.AsyncLogEventInfo,NLog.Common.AsyncLogEventInfo)">
                <summary>
                Implements the operator ==.
                </summary>
                <param name="eventInfo1">The event info1.</param>
                <param name="eventInfo2">The event info2.</param>
                <returns>The result of the operator.</returns>
            </member>
            <member name="M:NLog.Common.AsyncLogEventInfo.Equals(System.Object)">
                <summary>
                Determines whether the specified <see cref="T:System.Object"/> is equal to this instance.
                </summary>
                <param name="obj">The <see cref="T:System.Object"/> to compare with this instance.</param>
                <returns>
                A value of <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>.
                </returns>
            </member>
            <member name="M:NLog.Common.AsyncLogEventInfo.GetHashCode">
                <summary>
                Returns a hash code for this instance.
                </summary>
                <returns>
                A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
                </returns>
            </member>
            <member name="T:NLog.Common.ConversionHelpers">
                <summary>
                String Conversion Helpers
                </summary>
            </member>
            <member name="M:NLog.Common.ConversionHelpers.TryParseEnum``1(System.String,``[email protected],``0)">
                <summary>
                Converts input string value into <see cref="T:System.Enum"/>
                </summary>
                <param name="inputValue">Input value</param>
                <param name="resultValue">Output value</param>
                <param name="defaultValue">Default value</param>
                <returns>Returns failure if the input value could not be parsed</returns>
            </member>
            <member name="M:NLog.Common.ConversionHelpers.TryParse``1(System.String,``[email protected])">
                <summary>
                Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. A parameter specifies whether the operation is case-sensitive. The return value indicates whether the conversion succeeded.
                </summary>
                <typeparam name="TEnum">The enumeration type to which to convert value.</typeparam>
                <param name="value">The string representation of the enumeration name or underlying value to convert.</param>
                <param name="result">When this method returns, result contains an object of type TEnum whose value is represented by value if the parse operation succeeds. If the parse operation fails, result contains the default value of the underlying type of TEnum. Note that this value need not be a member of the TEnum enumeration. This parameter is passed uninitialized.</param>
                <returns><c>true</c> if the value parameter was converted successfully; otherwise, <c>false</c>.</returns>
                <remarks>Wrapper because Enum.TryParse is not present in .net 3.5</remarks>
            </member>
            <member name="M:NLog.Common.ConversionHelpers.TryParse``1(System.String,System.Boolean,``[email protected])">
                <summary>
                Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. A parameter specifies whether the operation is case-sensitive. The return value indicates whether the conversion succeeded.
                </summary>
                <typeparam name="TEnum">The enumeration type to which to convert value.</typeparam>
                <param name="value">The string representation of the enumeration name or underlying value to convert.</param>
                <param name="ignoreCase"><c>true</c> to ignore case; <c>false</c> to consider case.</param>
                <param name="result">When this method returns, result contains an object of type TEnum whose value is represented by value if the parse operation succeeds. If the parse operation fails, result contains the default value of the underlying type of TEnum. Note that this value need not be a member of the TEnum enumeration. This parameter is passed uninitialized.</param>
                <returns><c>true</c> if the value parameter was converted successfully; otherwise, <c>false</c>.</returns>
                <remarks>Wrapper because Enum.TryParse is not present in .net 3.5</remarks>
            </member>
            <member name="M:NLog.Common.ConversionHelpers.TryParseEnum_net3``1(System.String,System.Boolean,``[email protected])">
                <summary>
                Enum.TryParse implementation for .net 3.5 
                
                </summary>
                <returns></returns>
                <remarks>Don't uses reflection</remarks>
            </member>
            <member name="T:NLog.Common.InternalLogger">
                <summary>
                NLog internal logger.
                
                Writes to file, console or custom textwriter (see <see cref="P:NLog.Common.InternalLogger.LogWriter"/>)
                </summary>
                <remarks>
                Don't use <see cref="M:NLog.Internal.ExceptionHelper.MustBeRethrown(System.Exception)"/> as that can lead to recursive calls - stackoverflows
                </remarks>
            </member>
            <member name="P:NLog.Common.InternalLogger.IsTraceEnabled">
                <summary>
                Gets a value indicating whether internal log includes Trace messages.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.IsDebugEnabled">
                <summary>
                Gets a value indicating whether internal log includes Debug messages.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.IsInfoEnabled">
                <summary>
                Gets a value indicating whether internal log includes Info messages.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.IsWarnEnabled">
                <summary>
                Gets a value indicating whether internal log includes Warn messages.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.IsErrorEnabled">
                <summary>
                Gets a value indicating whether internal log includes Error messages.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.IsFatalEnabled">
                <summary>
                Gets a value indicating whether internal log includes Fatal messages.
                </summary>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace(System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace(System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace(System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Trace.
                </summary>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace(System.Exception,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace``1(System.String,``0)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace``2(System.String,``0,``1)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace``3(System.String,``0,``1,``2)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
                <param name="arg2">Argument {2} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace(System.Exception,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Trace(System.Exception,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Trace level.
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Trace.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug(System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Debug level.
                </summary>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug(System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Debug level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug(System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Debug level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Debug.
                </summary>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug(System.Exception,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Debug level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug``1(System.String,``0)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug``2(System.String,``0,``1)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug``3(System.String,``0,``1,``2)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
                <param name="arg2">Argument {2} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug(System.Exception,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Debug level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Debug(System.Exception,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Debug level.
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Debug.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info(System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Info level.
                </summary>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info(System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Info level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info(System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Info level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Info.
                </summary>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info(System.Exception,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Info level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info``1(System.String,``0)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info``2(System.String,``0,``1)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info``3(System.String,``0,``1,``2)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
                <param name="arg2">Argument {2} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info(System.Exception,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Info level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Info(System.Exception,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Info level.
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Info.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn(System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Warn level.
                </summary>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn(System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Warn level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn(System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Warn level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Warn.
                </summary>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn(System.Exception,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Warn level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn``1(System.String,``0)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn``2(System.String,``0,``1)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn``3(System.String,``0,``1,``2)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
                <param name="arg2">Argument {2} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn(System.Exception,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Warn level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Warn(System.Exception,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Warn level.
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Warn.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error(System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Error level.
                </summary>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error(System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Error level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error(System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Error level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Error.
                </summary>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error(System.Exception,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Error level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error``1(System.String,``0)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error``2(System.String,``0,``1)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error``3(System.String,``0,``1,``2)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
                <param name="arg2">Argument {2} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error(System.Exception,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Error level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Error(System.Exception,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Error level.
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Error.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal(System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Fatal level.
                </summary>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal(System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Fatal level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal(System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Fatal level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Fatal.
                </summary>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal(System.Exception,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Fatal level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal``1(System.String,``0)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal``2(System.String,``0,``1)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal``3(System.String,``0,``1,``2)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">Message which may include positional parameters.</param>
                <param name="arg0">Argument {0} to the message.</param>
                <param name="arg1">Argument {1} to the message.</param>
                <param name="arg2">Argument {2} to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal(System.Exception,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Fatal level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Fatal(System.Exception,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the Fatal level.
                <paramref name="messageFunc"/> will be only called when logging is enabled for level  Fatal.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.#cctor">
                <summary>
                Initializes static members of the InternalLogger class.
                </summary>
            </member>
            <member name="M:NLog.Common.InternalLogger.Reset">
                <summary>
                Set the config of the InternalLogger with defaults and config.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.LogLevel">
                <summary>
                Gets or sets the minimal internal log level. 
                </summary>
                <example>If set to <see cref="F:NLog.LogLevel.Info"/>, then messages of the levels <see cref="F:NLog.LogLevel.Info"/>, <see cref="F:NLog.LogLevel.Error"/> and <see cref="F:NLog.LogLevel.Fatal"/> will be written.</example>
            </member>
            <member name="P:NLog.Common.InternalLogger.LogToConsole">
                <summary>
                Gets or sets a value indicating whether internal messages should be written to the console output stream.
                </summary>
                <remarks>Your application must be a console application.</remarks>
            </member>
            <member name="P:NLog.Common.InternalLogger.LogToConsoleError">
                <summary>
                Gets or sets a value indicating whether internal messages should be written to the console error stream.
                </summary>
                <remarks>Your application must be a console application.</remarks>
            </member>
            <member name="P:NLog.Common.InternalLogger.LogToTrace">
                <summary>
                Gets or sets a value indicating whether internal messages should be written to the <see cref="N:System.Diagnostics"/>.Trace
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.LogFile">
                <summary>
                Gets or sets the file path of the internal log file.
                </summary>
                <remarks>A value of <see langword="null" /> value disables internal logging to a file.</remarks>
            </member>
            <member name="P:NLog.Common.InternalLogger.LogWriter">
                <summary>
                Gets or sets the text writer that will receive internal logs.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.IncludeTimestamp">
                <summary>
                Gets or sets a value indicating whether timestamp should be included in internal log output.
                </summary>
            </member>
            <member name="P:NLog.Common.InternalLogger.ExceptionThrowWhenWriting">
                <summary>
                Is there an <see cref="T:System.Exception"/> thrown when writing the message?
                </summary>
            </member>
            <member name="M:NLog.Common.InternalLogger.Log(NLog.LogLevel,System.String,System.Object[])">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the specified level.
                </summary>
                <param name="level">Log level.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Log(NLog.LogLevel,System.String)">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the specified level.
                </summary>
                <param name="level">Log level.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Log(NLog.LogLevel,System.Func{System.String})">
                <summary>
                Logs the specified message without an <see cref="T:System.Exception"/> at the specified level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level <paramref name="level"/>.
                </summary>
                <param name="level">Log level.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Log(System.Exception,NLog.LogLevel,System.Func{System.String})">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the specified level. 
                <paramref name="messageFunc"/> will be only called when logging is enabled for level <paramref name="level"/>.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="level">Log level.</param>
                <param name="messageFunc">Function that returns the log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Log(System.Exception,NLog.LogLevel,System.String,System.Object[])">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the specified level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="level">Log level.</param>
                <param name="message">Message which may include positional parameters.</param>
                <param name="args">Arguments to the message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Log(System.Exception,NLog.LogLevel,System.String)">
                <summary>
                Logs the specified message with an <see cref="T:System.Exception"/> at the specified level.
                </summary>
                <param name="ex">Exception to be logged.</param>
                <param name="level">Log level.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.Common.InternalLogger.Write(System.Exception,NLog.LogLevel,System.String,System.Object[])">
                <summary>
                Write to internallogger.
                </summary>
                <param name="ex">optional exception to be logged.</param>
                <param name="level">level</param>
                <param name="message">message</param>
                <param name="args">optional args for <paramref name="message"/></param>
            </member>
            <member name="M:NLog.Common.InternalLogger.IsSeriousException(System.Exception)">
                <summary>
                Determine if logging should be avoided because of exception type. 
                </summary>
                <param name="exception">The exception to check.</param>
                <returns><c>true</c> if logging should be avoided; otherwise, <c>false</c>.</returns>
            </member>
            <member name="M:NLog.Common.InternalLogger.IsLogLevelDisabled(NLog.LogLevel)">
                <summary>
                Determine if logging is enabled for given LogLevel
                </summary>
                <param name="logLevel">The <see cref="P:NLog.Common.InternalLogger.LogLevel"/> for the log event.</param>
                <returns><c>true</c> if logging is enabled; otherwise, <c>false</c>.</returns>
            </member>
            <member name="M:NLog.Common.InternalLogger.HasActiveLoggers">
                <summary>
                Determine if logging is enabled.
                </summary>
                <returns><c>true</c> if logging is enabled; otherwise, <c>false</c>.</returns>
            </member>
            <member name="M:NLog.Common.InternalLogger.WriteToLogFile(System.String)">
                <summary>
                Write internal messages to the log file defined in <see cref="P:NLog.Common.InternalLogger.LogFile"/>.
                </summary>
                <param name="message">Message to write.</param>
                <remarks>
                Message will be logged only when the property <see cref="P:NLog.Common.InternalLogger.LogFile"/> is not <c>null</c>, otherwise the
                method has no effect.
                </remarks>
            </member>
            <member name="M:NLog.Common.InternalLogger.WriteToTextWriter(System.String)">
                <summary>
                Write internal messages to the <see cref="T:System.IO.TextWriter"/> defined in <see cref="P:NLog.Common.InternalLogger.LogWriter"/>.
                </summary>
                <param name="message">Message to write.</param>
                <remarks>
                Message will be logged only when the property <see cref="P:NLog.Common.InternalLogger.LogWriter"/> is not <c>null</c>, otherwise the
                method has no effect.
                </remarks>
            </member>
            <member name="M:NLog.Common.InternalLogger.WriteToConsole(System.String)">
                <summary>
                Write internal messages to the <see cref="T:System.Console"/>.
                </summary>
                <param name="message">Message to write.</param>
                <remarks>
                Message will be logged only when the property <see cref="P:NLog.Common.InternalLogger.LogToConsole"/> is <c>true</c>, otherwise the 
                method has no effect.
                </remarks>
            </member>
            <member name="M:NLog.Common.InternalLogger.WriteToErrorConsole(System.String)">
                <summary>
                Write internal messages to the <see cref="P:System.Console.Error"/>.
                </summary>
                <param name="message">Message to write.</param>
                <remarks>
                Message will be logged when the property <see cref="P:NLog.Common.InternalLogger.LogToConsoleError"/> is <c>true</c>, otherwise the 
                method has no effect.
                </remarks>
            </member>
            <member name="M:NLog.Common.InternalLogger.WriteToTrace(System.String)">
                <summary>
                Write internal messages to the <see cref="T:System.Diagnostics.Trace"/>.
                </summary>
                <param name="message">A message to write.</param>
                <remarks>
                Works when property <see cref="P:NLog.Common.InternalLogger.LogToTrace"/> set to true.
                The <see cref="T:System.Diagnostics.Trace"/> is used in Debug and Relese configuration. 
                The <see cref="T:System.Diagnostics.Debug"/> works only in Debug configuration and this is reason why is replaced by <see cref="T:System.Diagnostics.Trace"/>.
                in DEBUG 
                </remarks>
            </member>
            <member name="M:NLog.Common.InternalLogger.LogAssemblyVersion(System.Reflection.Assembly)">
                <summary>
                Logs the assembly version and file version of the given Assembly.
                </summary>
                <param name="assembly">The assembly to log.</param>
            </member>
            <member name="T:NLog.Common.LogEventInfoBuffer">
                <summary>
                A cyclic buffer of <see cref="T:NLog.LogEventInfo"/> object.
                </summary>
            </member>
            <member name="M:NLog.Common.LogEventInfoBuffer.#ctor(System.Int32,System.Boolean,System.Int32)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Common.LogEventInfoBuffer" /> class.
                </summary>
                <param name="size">Buffer size.</param>
                <param name="growAsNeeded">Whether buffer should grow as it becomes full.</param>
                <param name="growLimit">The maximum number of items that the buffer can grow to.</param>
            </member>
            <member name="P:NLog.Common.LogEventInfoBuffer.Size">
                <summary>
                Gets the number of items in the array.
                </summary>
            </member>
            <member name="M:NLog.Common.LogEventInfoBuffer.Append(NLog.Common.AsyncLogEventInfo)">
                <summary>
                Adds the specified log event to the buffer.
                </summary>
                <param name="eventInfo">Log event.</param>
                <returns>The number of items in the buffer.</returns>
            </member>
            <member name="M:NLog.Common.LogEventInfoBuffer.GetEventsAndClear">
                <summary>
                Gets the array of events accumulated in the buffer and clears the buffer as one atomic operation.
                </summary>
                <returns>Events in the buffer.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionAndExpression">
                <summary>
                Condition <b>and</b> expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionAndExpression.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionAndExpression" /> class.
                </summary>
                <param name="left">Left hand side of the AND expression.</param>
                <param name="right">Right hand side of the AND expression.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionAndExpression.Left">
                <summary>
                Gets the left hand side of the AND expression.
                </summary>
            </member>
            <member name="P:NLog.Conditions.ConditionAndExpression.Right">
                <summary>
                Gets the right hand side of the AND expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionAndExpression.ToString">
                <summary>
                Returns a string representation of this expression.
                </summary>
                <returns>A concatenated '(Left) and (Right)' string.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionAndExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression by evaluating <see cref="P:NLog.Conditions.ConditionAndExpression.Left"/> and <see cref="P:NLog.Conditions.ConditionAndExpression.Right"/> recursively.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>The value of the conjunction operator.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionEvaluationException">
                <summary>
                Exception during evaluation of condition expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
                </summary>
                <param name="message">The message.</param>
            </member>
            <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor(System.String,System.Exception)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
                </summary>
                <param name="message">The message.</param>
                <param name="innerException">The inner exception.</param>
            </member>
            <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
                </summary>
                <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
                <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
                <exception cref="T:System.ArgumentNullException">
                The <paramref name="info"/> parameter is null.
                </exception>
                <exception cref="T:System.Runtime.Serialization.SerializationException">
                The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
                </exception>
            </member>
            <member name="T:NLog.Conditions.ConditionExpression">
                <summary>
                Base class for representing nodes in condition expression trees.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionExpression.op_Implicit(System.String)~NLog.Conditions.ConditionExpression">
                <summary>
                Converts condition text to a condition expression tree.
                </summary>
                <param name="conditionExpressionText">Condition text to be converted.</param>
                <returns>Condition expression tree.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionExpression.Evaluate(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>Expression result.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents the condition expression.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>Expression result.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionLayoutExpression">
                <summary>
                Condition layout expression (represented by a string literal
                with embedded ${}).
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionLayoutExpression.#ctor(NLog.Layouts.Layout)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionLayoutExpression" /> class.
                </summary>
                <param name="layout">The layout.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionLayoutExpression.Layout">
                <summary>
                Gets the layout.
                </summary>
                <value>The layout.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionLayoutExpression.ToString">
                <summary>
                Returns a string representation of this expression.
                </summary>
                <returns>String literal in single quotes.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionLayoutExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression by calculating the value
                of the layout in the specified evaluation context.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>The value of the layout.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionLevelExpression">
                <summary>
                Condition level expression (represented by the <b>level</b> keyword).
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionLevelExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>The '<b>level</b>' string.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionLevelExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates to the current log level.
                </summary>
                <param name="context">Evaluation context. Ignored.</param>
                <returns>The <see cref="T:NLog.LogLevel"/> object representing current log level.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionLiteralExpression">
                <summary>
                Condition literal expression (numeric, <b>LogLevel.XXX</b>, <b>true</b> or <b>false</b>).
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionLiteralExpression.#ctor(System.Object)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionLiteralExpression" /> class.
                </summary>
                <param name="literalValue">Literal value.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionLiteralExpression.LiteralValue">
                <summary>
                Gets the literal value.
                </summary>
                <value>The literal value.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionLiteralExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>The literal value.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionLiteralExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>The literal value as passed in the constructor.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionLoggerNameExpression">
                <summary>
                Condition logger name expression (represented by the <b>logger</b> keyword).
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionLoggerNameExpression.ToString">
                <summary>
                Returns a string representation of this expression.
                </summary>
                <returns>A <b>logger</b> string.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionLoggerNameExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates to the logger name.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>The logger name.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionMessageExpression">
                <summary>
                Condition message expression (represented by the <b>message</b> keyword).
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionMessageExpression.ToString">
                <summary>
                Returns a string representation of this expression.
                </summary>
                <returns>The '<b>message</b>' string.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMessageExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates to the logger message.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>The logger message.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionMethodAttribute">
                <summary>
                Marks class as a log event Condition and assigns a name to it.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionMethodAttribute.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionMethodAttribute" /> class.
                </summary>
                <param name="name">Condition method name.</param>
            </member>
            <member name="T:NLog.Conditions.ConditionMethodExpression">
                <summary>
                Condition method invocation expression (represented by <b>method(p1,p2,p3)</b> syntax).
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionMethodExpression.#ctor(System.String,System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{NLog.Conditions.ConditionExpression})">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionMethodExpression" /> class.
                </summary>
                <param name="conditionMethodName">Name of the condition method.</param>
                <param name="methodInfo"><see cref="P:NLog.Conditions.ConditionMethodExpression.MethodInfo"/> of the condition method.</param>
                <param name="methodParameters">The method parameters.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionMethodExpression.MethodInfo">
                <summary>
                Gets the method info.
                </summary>
            </member>
            <member name="P:NLog.Conditions.ConditionMethodExpression.MethodParameters">
                <summary>
                Gets the method parameters.
                </summary>
                <value>The method parameters.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionMethodExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents the condition expression.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethodExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>Expression result.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionMethods">
                <summary>
                A bunch of utility methods (mostly predicates) which can be used in
                condition expressions. Partially inspired by XPath 1.0.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.Equals2(System.Object,System.Object)">
                <summary>
                Compares two values for equality.
                </summary>
                <param name="firstValue">The first value.</param>
                <param name="secondValue">The second value.</param>
                <returns><b>true</b> when two objects are equal, <b>false</b> otherwise.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.Equals2(System.String,System.String,System.Boolean)">
                <summary>
                Compares two strings for equality.
                </summary>
                <param name="firstValue">The first string.</param>
                <param name="secondValue">The second string.</param>
                <param name="ignoreCase">Optional. If <c>true</c>, case is ignored; if <c>false</c> (default), case is significant.</param>
                <returns><b>true</b> when two strings are equal, <b>false</b> otherwise.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.Contains(System.String,System.String,System.Boolean)">
                <summary>
                Gets or sets a value indicating whether the second string is a substring of the first one.
                </summary>
                <param name="haystack">The first string.</param>
                <param name="needle">The second string.</param>
                <param name="ignoreCase">Optional. If <c>true</c> (default), case is ignored; if <c>false</c>, case is significant.</param>
                <returns><b>true</b> when the second string is a substring of the first string, <b>false</b> otherwise.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.StartsWith(System.String,System.String,System.Boolean)">
                <summary>
                Gets or sets a value indicating whether the second string is a prefix of the first one.
                </summary>
                <param name="haystack">The first string.</param>
                <param name="needle">The second string.</param>
                <param name="ignoreCase">Optional. If <c>true</c> (default), case is ignored; if <c>false</c>, case is significant.</param>
                <returns><b>true</b> when the second string is a prefix of the first string, <b>false</b> otherwise.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.EndsWith(System.String,System.String,System.Boolean)">
                <summary>
                Gets or sets a value indicating whether the second string is a suffix of the first one.
                </summary>
                <param name="haystack">The first string.</param>
                <param name="needle">The second string.</param>
                <param name="ignoreCase">Optional. If <c>true</c> (default), case is ignored; if <c>false</c>, case is significant.</param>
                <returns><b>true</b> when the second string is a prefix of the first string, <b>false</b> otherwise.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.Length(System.String)">
                <summary>
                Returns the length of a string.
                </summary>
                <param name="text">A string whose lengths is to be evaluated.</param>
                <returns>The length of the string.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.RegexMatches(System.String,System.String,System.String)">
                <summary>
                Indicates whether the specified regular expression finds a match in the specified input string.
                </summary>
                <param name="input">The string to search for a match.</param>
                <param name="pattern">The regular expression pattern to match.</param>
                <param name="options">A string consisting of the desired options for the test. The possible values are those of the <see cref="T:System.Text.RegularExpressions.RegexOptions"/> separated by commas.</param>
                <returns>true if the regular expression finds a match; otherwise, false.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionMethods.ParseRegexOptions(System.String)">
                <summary>
                
                </summary>
                <param name="options"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.Conditions.ConditionMethodsAttribute">
                <summary>
                Marks the class as containing condition methods.
                </summary>
            </member>
            <member name="T:NLog.Conditions.ConditionNotExpression">
                <summary>
                Condition <b>not</b> expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionNotExpression.#ctor(NLog.Conditions.ConditionExpression)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionNotExpression" /> class.
                </summary>
                <param name="expression">The expression.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionNotExpression.Expression">
                <summary>
                Gets the expression to be negated.
                </summary>
                <value>The expression.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionNotExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents the condition expression.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionNotExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>Expression result.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionOrExpression">
                <summary>
                Condition <b>or</b> expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionOrExpression.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionOrExpression" /> class.
                </summary>
                <param name="left">Left hand side of the OR expression.</param>
                <param name="right">Right hand side of the OR expression.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionOrExpression.LeftExpression">
                <summary>
                Gets the left expression.
                </summary>
                <value>The left expression.</value>
            </member>
            <member name="P:NLog.Conditions.ConditionOrExpression.RightExpression">
                <summary>
                Gets the right expression.
                </summary>
                <value>The right expression.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionOrExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents the condition expression.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionOrExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression by evaluating <see cref="P:NLog.Conditions.ConditionOrExpression.LeftExpression"/> and <see cref="P:NLog.Conditions.ConditionOrExpression.RightExpression"/> recursively.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>The value of the alternative operator.</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionParseException">
                <summary>
                Exception during parsing of condition expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionParseException.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionParseException.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
                </summary>
                <param name="message">The message.</param>
            </member>
            <member name="M:NLog.Conditions.ConditionParseException.#ctor(System.String,System.Exception)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
                </summary>
                <param name="message">The message.</param>
                <param name="innerException">The inner exception.</param>
            </member>
            <member name="M:NLog.Conditions.ConditionParseException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
                </summary>
                <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
                <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
                <exception cref="T:System.ArgumentNullException">
                The <paramref name="info"/> parameter is null.
                </exception>
                <exception cref="T:System.Runtime.Serialization.SerializationException">
                The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
                </exception>
            </member>
            <member name="T:NLog.Conditions.ConditionParser">
                <summary>
                Condition parser. Turns a string representation of condition expression
                into an expression tree.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionParser.#ctor(NLog.Internal.SimpleStringReader,NLog.Config.ConfigurationItemFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParser"/> class.
                </summary>
                <param name="stringReader">The string reader.</param>
                <param name="configurationItemFactory">Instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/> used to resolve references to condition methods and layout renderers.</param>
            </member>
            <member name="M:NLog.Conditions.ConditionParser.ParseExpression(System.String)">
                <summary>
                Parses the specified condition string and turns it into
                <see cref="T:NLog.Conditions.ConditionExpression"/> tree.
                </summary>
                <param name="expressionText">The expression to be parsed.</param>
                <returns>The root of the expression syntax tree which can be used to get the value of the condition in a specified context.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionParser.ParseExpression(System.String,NLog.Config.ConfigurationItemFactory)">
                <summary>
                Parses the specified condition string and turns it into
                <see cref="T:NLog.Conditions.ConditionExpression"/> tree.
                </summary>
                <param name="expressionText">The expression to be parsed.</param>
                <param name="configurationItemFactories">Instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/> used to resolve references to condition methods and layout renderers.</param>
                <returns>The root of the expression syntax tree which can be used to get the value of the condition in a specified context.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionParser.ParseExpression(NLog.Internal.SimpleStringReader,NLog.Config.ConfigurationItemFactory)">
                <summary>
                Parses the specified condition string and turns it into
                <see cref="T:NLog.Conditions.ConditionExpression"/> tree.
                </summary>
                <param name="stringReader">The string reader.</param>
                <param name="configurationItemFactories">Instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/> used to resolve references to condition methods and layout renderers.</param>
                <returns>
                The root of the expression syntax tree which can be used to get the value of the condition in a specified context.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionParser.TryPlainKeywordToExpression(System.String,[email protected])">
                <summary>
                Try stringed keyword to <see cref="T:NLog.Conditions.ConditionExpression"/>
                </summary>
                <param name="keyword"></param>
                <param name="expression"></param>
                <returns>success?</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionParser.ParseNumber(System.Boolean)">
                <summary>
                Parse number
                </summary>
                <param name="negative">negative number? minus should be parsed first.</param>
                <returns></returns>
            </member>
            <member name="T:NLog.Conditions.ConditionRelationalExpression">
                <summary>
                Condition relational (<b>==</b>, <b>!=</b>, <b>&lt;</b>, <b>&lt;=</b>,
                <b>&gt;</b> or <b>&gt;=</b>) expression.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionRelationalOperator)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionRelationalExpression" /> class.
                </summary>
                <param name="leftExpression">The left expression.</param>
                <param name="rightExpression">The right expression.</param>
                <param name="relationalOperator">The relational operator.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionRelationalExpression.LeftExpression">
                <summary>
                Gets the left expression.
                </summary>
                <value>The left expression.</value>
            </member>
            <member name="P:NLog.Conditions.ConditionRelationalExpression.RightExpression">
                <summary>
                Gets the right expression.
                </summary>
                <value>The right expression.</value>
            </member>
            <member name="P:NLog.Conditions.ConditionRelationalExpression.RelationalOperator">
                <summary>
                Gets the relational operator.
                </summary>
                <value>The operator.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.ToString">
                <summary>
                Returns a string representation of the expression.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents the condition expression.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.EvaluateNode(NLog.LogEventInfo)">
                <summary>
                Evaluates the expression.
                </summary>
                <param name="context">Evaluation context.</param>
                <returns>Expression result.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.Compare(System.Object,System.Object,NLog.Conditions.ConditionRelationalOperator)">
                <summary>
                Compares the specified values using specified relational operator.
                </summary>
                <param name="leftValue">The first value.</param>
                <param name="rightValue">The second value.</param>
                <param name="relationalOperator">The relational operator.</param>
                <returns>Result of the given relational operator.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.PromoteTypes([email protected],[email protected])">
                <summary>
                Promote values to the type needed for the comparision, e.g. parse a string to int.
                </summary>
                <param name="leftValue"></param>
                <param name="rightValue"></param>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.TryPromoteType([email protected],System.Type)">
                <summary>
                Promoto <paramref name="val"/> to type
                </summary>
                <param name="val"></param>
                <param name="type1"></param>
                <returns>success?</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.TryPromoteTypes([email protected],System.Type,[email protected],System.Type)">
                <summary>
                Try to promote both values. First try to promote <paramref name="val1"/> to <paramref name="type1"/>,
                 when failed, try <paramref name="val2"/> to <paramref name="type2"/>.
                </summary>
                <returns></returns>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.GetOrder(System.Type)">
                <summary>
                Get the order for the type for comparision.
                </summary>
                <param name="type1"></param>
                <returns>index, 0 to maxint. Lower is first</returns>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalExpression.TypePromoteOrder">
                <summary>
                Dictionary from type to index. Lower index should be tested first.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.BuildTypeOrderDictionary">
                <summary>
                Build the dictionary needed for the order of the types.
                </summary>
                <returns></returns>
            </member>
            <member name="M:NLog.Conditions.ConditionRelationalExpression.GetOperatorString">
                <summary>
                Get the string representing the current <see cref="T:NLog.Conditions.ConditionRelationalOperator"/>
                </summary>
                <returns></returns>
            </member>
            <member name="T:NLog.Conditions.ConditionRelationalOperator">
                <summary>
                Relational operators used in conditions.
                </summary>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalOperator.Equal">
                <summary>
                Equality (==).
                </summary>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalOperator.NotEqual">
                <summary>
                Inequality (!=).
                </summary>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalOperator.Less">
                <summary>
                Less than (&lt;).
                </summary>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalOperator.Greater">
                <summary>
                Greater than (&gt;).
                </summary>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalOperator.LessOrEqual">
                <summary>
                Less than or equal (&lt;=).
                </summary>
            </member>
            <member name="F:NLog.Conditions.ConditionRelationalOperator.GreaterOrEqual">
                <summary>
                Greater than or equal (&gt;=).
                </summary>
            </member>
            <member name="T:NLog.Conditions.ConditionTokenizer">
                <summary>
                Hand-written tokenizer for conditions.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.#ctor(NLog.Internal.SimpleStringReader)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionTokenizer"/> class.
                </summary>
                <param name="stringReader">The string reader.</param>
            </member>
            <member name="P:NLog.Conditions.ConditionTokenizer.TokenType">
                <summary>
                Gets the type of the token.
                </summary>
                <value>The type of the token.</value>
            </member>
            <member name="P:NLog.Conditions.ConditionTokenizer.TokenValue">
                <summary>
                Gets the token value.
                </summary>
                <value>The token value.</value>
            </member>
            <member name="P:NLog.Conditions.ConditionTokenizer.StringTokenValue">
                <summary>
                Gets the value of a string token.
                </summary>
                <value>The string token value.</value>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.Expect(NLog.Conditions.ConditionTokenType)">
                <summary>
                Asserts current token type and advances to the next token.
                </summary>
                <param name="tokenType">Expected token type.</param>
                <remarks>If token type doesn't match, an exception is thrown.</remarks>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.EatKeyword">
                <summary>
                Asserts that current token is a keyword and returns its value and advances to the next token.
                </summary>
                <returns>Keyword value.</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.IsKeyword(System.String)">
                <summary>
                Gets or sets a value indicating whether current keyword is equal to the specified value.
                </summary>
                <param name="keyword">The keyword.</param>
                <returns>
                A value of <c>true</c> if current keyword is equal to the specified value; otherwise, <c>false</c>.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.IsEOF">
                <summary>
                Gets or sets a value indicating whether the tokenizer has reached the end of the token stream.
                </summary>
                <returns>
                A value of <c>true</c> if the tokenizer has reached the end of the token stream; otherwise, <c>false</c>.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.IsNumber">
                <summary>
                Gets or sets a value indicating whether current token is a number.
                </summary>
                <returns>
                A value of <c>true</c> if current token is a number; otherwise, <c>false</c>.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.IsToken(NLog.Conditions.ConditionTokenType)">
                <summary>
                Gets or sets a value indicating whether the specified token is of specified type.
                </summary>
                <param name="tokenType">The token type.</param>
                <returns>
                A value of <c>true</c> if current token is of specified type; otherwise, <c>false</c>.
                </returns>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.GetNextToken">
                <summary>
                Gets the next token and sets <see cref="P:NLog.Conditions.ConditionTokenizer.TokenType"/> and <see cref="P:NLog.Conditions.ConditionTokenizer.TokenValue"/> properties.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.TryGetComparisonToken(System.Char)">
                <summary>
                Try the comparison tokens (greater, smaller, greater-equals, smaller-equals)
                </summary>
                <param name="ch">current char</param>
                <returns>is match</returns>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.TryGetLogicalToken(System.Char)">
                <summary>
                Try the logical tokens (and, or, not, equals)
                </summary>
                <param name="ch">current char</param>
                <returns>is match</returns>
            </member>
            <member name="T:NLog.Conditions.ConditionTokenizer.CharToTokenType">
                <summary>
                Mapping between characters and token types for punctuations.
                </summary>
            </member>
            <member name="M:NLog.Conditions.ConditionTokenizer.CharToTokenType.#ctor(System.Char,NLog.Conditions.ConditionTokenType)">
                <summary>
                Initializes a new instance of the CharToTokenType struct.
                </summary>
                <param name="character">The character.</param>
                <param name="tokenType">Type of the token.</param>
            </member>
            <member name="T:NLog.Conditions.ConditionTokenType">
                <summary>
                Token types for condition expressions.
                </summary>
            </member>
            <member name="T:NLog.Config.AdvancedAttribute">
                <summary>
                Marks the class or a member as advanced. Advanced classes and members are hidden by 
                default in generated documentation.
                </summary>
            </member>
            <member name="M:NLog.Config.AdvancedAttribute.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.AdvancedAttribute" /> class.
                </summary>
            </member>
            <member name="T:NLog.Config.AppDomainFixedOutputAttribute">
                <summary>
                Identifies that the output of layout or layout render does not change for the lifetime of the current appdomain.
                </summary>
                <remarks>
                A layout(renderer) could be converted to a literal when:
                 - The layout and all layout properies are SimpleLayout or [AppDomainFixedOutput]
                
                Recommendation: Apply this attribute to a layout or layout-renderer which have the result only changes by properties of type Layout.
                </remarks>
            </member>
            <member name="T:NLog.Config.ArrayParameterAttribute">
                <summary>
                Used to mark configurable parameters which are arrays. 
                Specifies the mapping between XML elements and .NET types.
                </summary>
            </member>
            <member name="M:NLog.Config.ArrayParameterAttribute.#ctor(System.Type,System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.ArrayParameterAttribute" /> class.
                </summary>
                <param name="itemType">The type of the array item.</param>
                <param name="elementName">The XML element name that represents the item.</param>
            </member>
            <member name="P:NLog.Config.ArrayParameterAttribute.ItemType">
                <summary>
                Gets the .NET type of the array item.
                </summary>
            </member>
            <member name="P:NLog.Config.ArrayParameterAttribute.ElementName">
                <summary>
                Gets the XML element name.
                </summary>
            </member>
            <member name="T:NLog.Config.AssemblyLoadingEventArgs">
                <summary>
                An assembly is trying to load. 
                </summary>
            </member>
            <member name="M:NLog.Config.AssemblyLoadingEventArgs.#ctor(System.Reflection.Assembly)">
                <summary>
                New event args
                </summary>
                <param name="assembly"></param>
            </member>
            <member name="P:NLog.Config.AssemblyLoadingEventArgs.Assembly">
                <summary>
                The assembly that is trying to load.
                </summary>
            </member>
            <member name="T:NLog.Config.ConfigSectionHandler">
                <summary>
                NLog configuration section handler class for configuring NLog from App.config.
                </summary>
            </member>
            <member name="M:NLog.Config.ConfigSectionHandler.System#Configuration#IConfigurationSectionHandler#Create(System.Object,System.Object,System.Xml.XmlNode)">
                <summary>
                Creates a configuration section handler.
                </summary>
                <param name="parent">Parent object.</param>
                <param name="configContext">Configuration context object.</param>
                <param name="section">Section XML node.</param>
                <returns>The created section handler object.</returns>
            </member>
            <member name="T:NLog.Config.ConfigurationItemCreator">
                <summary>
                Constructs a new instance the configuration item (target, layout, layout renderer, etc.) given its type.
                </summary>
                <param name="itemType">Type of the item.</param>
                <returns>Created object of the specified type.</returns>
            </member>
            <member name="T:NLog.Config.ConfigurationItemFactory">
                <summary>
                Provides registration information for named items (targets, layouts, layout renderers, etc.) managed by NLog.
                
                Everything of an assembly could be loaded by <see cref="M:NLog.Config.ConfigurationItemFactory.RegisterItemsFromAssembly(System.Reflection.Assembly)"/>
                </summary>
            </member>
            <member name="E:NLog.Config.ConfigurationItemFactory.AssemblyLoading">
                <summary>
                Called before the assembly will be loaded.
                </summary>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.#ctor(System.Reflection.Assembly[])">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.ConfigurationItemFactory"/> class.
                </summary>
                <param name="assemblies">The assemblies to scan for named items.</param>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.Default">
                <summary>
                Gets or sets default singleton instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/>.
                </summary>
                <remarks>
                This property implements lazy instantiation so that the <see cref="T:NLog.Config.ConfigurationItemFactory"/> is not built before 
                the internal logger is configured.
                </remarks>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.CreateInstance">
                <summary>
                Gets or sets the creator delegate used to instantiate configuration objects.
                </summary>
                <remarks>
                By overriding this property, one can enable dependency injection or interception for created objects.
                </remarks>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.Targets">
                <summary>
                Gets the <see cref="T:NLog.Targets.Target"/> factory.
                </summary>
                <value>The target factory.</value>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.Filters">
                <summary>
                Gets the <see cref="T:NLog.Filters.Filter"/> factory.
                </summary>
                <value>The filter factory.</value>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.GetLayoutRenderers">
                <summary>
                gets the <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> factory
                </summary>
                <remarks>not using <see cref="F:NLog.Config.ConfigurationItemFactory._layoutRenderers"/> due to backwardscomp.</remarks>
                <returns></returns>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.LayoutRenderers">
                <summary>
                Gets the <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> factory.
                </summary>
                <value>The layout renderer factory.</value>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.Layouts">
                <summary>
                Gets the <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> factory.
                </summary>
                <value>The layout factory.</value>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.AmbientProperties">
                <summary>
                Gets the ambient property factory.
                </summary>
                <value>The ambient property factory.</value>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.JsonSerializer">
                <summary>
                Legacy interface, no longer used by the NLog engine
                </summary>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.JsonConverter">
                <summary>
                Gets or sets the JSON serializer to use with <see cref="T:NLog.Targets.WebServiceTarget"/> or <see cref="T:NLog.Layouts.JsonLayout"/>
                </summary>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.ValueFormatter">
                <summary>
                Gets or sets the string serializer to use with <see cref="P:NLog.LogEventInfo.MessageTemplateParameters"/>
                </summary>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.PropertyTypeConverter">
                <summary>
                Gets or sets the parameter converter to use with <see cref="T:NLog.Targets.DatabaseTarget"/>, <see cref="T:NLog.Targets.WebServiceTarget"/> or <see cref="T:NLog.Targets.TargetWithContext"/>
                </summary>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.ParseMessageTemplates">
                <summary>
                Perform mesage template parsing and formatting of LogEvent messages (True = Always, False = Never, Null = Auto Detect)
                </summary>
                <remarks>
                - Null (Auto Detect) : NLog-parser checks <see cref="P:NLog.LogEventInfo.Message"/> for positional parameters, and will then fallback to string.Format-rendering.
                - True: Always performs the parsing of <see cref="P:NLog.LogEventInfo.Message"/> and rendering of <see cref="P:NLog.LogEventInfo.FormattedMessage"/> using the NLog-parser (Allows custom formatting with <see cref="P:NLog.Config.ConfigurationItemFactory.ValueFormatter"/>)
                - False: Always performs parsing and rendering using string.Format (Fastest if not using structured logging)
                </remarks>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.TimeSources">
                <summary>
                Gets the time source factory.
                </summary>
                <value>The time source factory.</value>
            </member>
            <member name="P:NLog.Config.ConfigurationItemFactory.ConditionMethods">
                <summary>
                Gets the condition method factory.
                </summary>
                <value>The condition method factory.</value>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.RegisterItemsFromAssembly(System.Reflection.Assembly)">
                <summary>
                Registers named items from the assembly.
                </summary>
                <param name="assembly">The assembly.</param>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.RegisterItemsFromAssembly(System.Reflection.Assembly,System.String)">
                <summary>
                Registers named items from the assembly.
                </summary>
                <param name="assembly">The assembly.</param>
                <param name="itemNamePrefix">Item name prefix.</param>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.PreloadAssembly(System.Type[])">
                <summary>
                Call Preload for NLogPackageLoader
                </summary>
                <remarks>
                Every package could implement a class "NLogPackageLoader" (namespace not important) with the public static method "Preload" (no arguments)
                This method will be called just before registering all items in the assembly.
                </remarks>
                <param name="typesToScan"></param>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.CallPreload(System.Type)">
                <summary>
                Call the Preload method for <paramref name="type"/>. The Preload method must be static.
                </summary>
                <param name="type"></param>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.Clear">
                <summary>
                Clears the contents of all factories.
                </summary>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.RegisterType(System.Type,System.String)">
                <summary>
                Registers the type.
                </summary>
                <param name="type">The type to register.</param>
                <param name="itemNamePrefix">The item name prefix.</param>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.BuildDefaultFactory">
                <summary>
                Builds the default configuration item factory.
                </summary>
                <returns>Default factory.</returns>
            </member>
            <member name="M:NLog.Config.ConfigurationItemFactory.RegisterExtendedItems">
                <summary>
                Registers items in NLog.Extended.dll using late-bound types, so that we don't need a reference to NLog.Extended.dll.
                </summary>
            </member>
            <member name="T:NLog.Config.DefaultParameterAttribute">
                <summary>
                Attribute used to mark the default parameters for layout renderers.
                </summary>
            </member>
            <member name="M:NLog.Config.DefaultParameterAttribute.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.DefaultParameterAttribute" /> class.
                </summary>
            </member>
            <member name="T:NLog.Config.ExceptionRenderingFormat">
                <summary>
                Format of the excpetion output to the specific target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.Message">
                <summary>
                Appends the Message of an Exception to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.Type">
                <summary>
                Appends the type of an Exception to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.ShortType">
                <summary>
                Appends the short type of an Exception to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.ToString">
                <summary>
                Appends the result of calling ToString() on an Exception to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.Method">
                <summary>
                Appends the method name from Exception's stack trace to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.StackTrace">
                <summary>
                Appends the stack trace from an Exception to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.Data">
                <summary>
                Appends the contents of an Exception's Data property to the specified target.
                </summary>
            </member>
            <member name="F:NLog.Config.ExceptionRenderingFormat.Serialize">
                <summary>
                Destructure the exception (usually into JSON)
                </summary>
            </member>
            <member name="T:NLog.Config.Factory`2">
                <summary>
                Factory for class-based items.
                </summary>
                <typeparam name="TBaseType">The base type of each item.</typeparam>
                <typeparam name="TAttributeType">The type of the attribute used to annotate items.</typeparam>
            </member>
            <member name="M:NLog.Config.Factory`2.ScanTypes(System.Type[],System.String)">
                <summary>
                Scans the assembly.
                </summary>
                <param name="types">The types to scan.</param>
                <param name="prefix">The prefix.</param>
            </member>
            <member name="M:NLog.Config.Factory`2.RegisterType(System.Type,System.String)">
                <summary>
                Registers the type.
                </summary>
                <param name="type">The type to register.</param>
                <param name="itemNamePrefix">The item name prefix.</param>
            </member>
            <member name="M:NLog.Config.Factory`2.RegisterNamedType(System.String,System.String)">
                <summary>
                Registers the item based on a type name.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="typeName">Name of the type.</param>
            </member>
            <member name="M:NLog.Config.Factory`2.Clear">
                <summary>
                Clears the contents of the factory.
                </summary>
            </member>
            <member name="M:NLog.Config.Factory`2.RegisterDefinition(System.String,System.Type)">
                <summary>
                Registers a single type definition.
                </summary>
                <param name="itemName">The item name.</param>
                <param name="itemDefinition">The type of the item.</param>
            </member>
            <member name="M:NLog.Config.Factory`2.TryGetDefinition(System.String,[email protected])">
                <summary>
                Tries to get registered item definition.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="result">Reference to a variable which will store the item definition.</param>
                <returns>Item definition.</returns>
            </member>
            <member name="M:NLog.Config.Factory`2.TryCreateInstance(System.String,`[email protected])">
                <summary>
                Tries to create an item instance.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="result">The result.</param>
                <returns>True if instance was created successfully, false otherwise.</returns>
            </member>
            <member name="M:NLog.Config.Factory`2.CreateInstance(System.String)">
                <summary>
                Creates an item instance.
                </summary>
                <param name="itemName">The name of the item.</param>
                <returns>Created item.</returns>
            </member>
            <member name="T:NLog.Config.LayoutRendererFactory">
                <summary>
                Factory specialized for <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s. 
                </summary>
            </member>
            <member name="M:NLog.Config.LayoutRendererFactory.ClearFuncLayouts">
                <summary>
                Clear all func layouts
                </summary>
            </member>
            <member name="M:NLog.Config.LayoutRendererFactory.RegisterFuncLayout(System.String,NLog.LayoutRenderers.FuncLayoutRenderer)">
                <summary>
                Register a layout renderer with a callback function.
                </summary>
                <param name="name">Name of the layoutrenderer, without ${}.</param>
                <param name="renderer">the renderer that renders the value.</param>
            </member>
            <member name="M:NLog.Config.LayoutRendererFactory.TryCreateInstance(System.String,[email protected])">
                <summary>
                Tries to create an item instance.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="result">The result.</param>
                <returns>True if instance was created successfully, false otherwise.</returns>
            </member>
            <member name="T:NLog.Config.IFactory">
                <summary>
                Provides means to populate factories of named items (such as targets, layouts, layout renderers, etc.).
                </summary>
            </member>
            <member name="T:NLog.Config.IInstallable">
                <summary>
                Implemented by objects which support installation and uninstallation.
                </summary>
            </member>
            <member name="M:NLog.Config.IInstallable.Install(NLog.Config.InstallationContext)">
                <summary>
                Performs installation which requires administrative permissions.
                </summary>
                <param name="installationContext">The installation context.</param>
            </member>
            <member name="M:NLog.Config.IInstallable.Uninstall(NLog.Config.InstallationContext)">
                <summary>
                Performs uninstallation which requires administrative permissions.
                </summary>
                <param name="installationContext">The installation context.</param>
            </member>
            <member name="M:NLog.Config.IInstallable.IsInstalled(NLog.Config.InstallationContext)">
                <summary>
                Determines whether the item is installed.
                </summary>
                <param name="installationContext">The installation context.</param>
                <returns>
                Value indicating whether the item is installed or null if it is not possible to determine.
                </returns>
            </member>
            <member name="T:NLog.Config.ILoggingConfigurationElement">
                <summary>
                Interface for accessing configuration details
                </summary>
            </member>
            <member name="P:NLog.Config.ILoggingConfigurationElement.Name">
                <summary>
                Name of the config section
                </summary>
            </member>
            <member name="P:NLog.Config.ILoggingConfigurationElement.Values">
                <summary>
                Configuration Key/Value Pairs
                </summary>
            </member>
            <member name="P:NLog.Config.ILoggingConfigurationElement.Children">
                <summary>
                Child config sections
                </summary>
            </member>
            <member name="T:NLog.Config.ILoggingConfigurationLoader">
                <summary>
                Interface for loading NLog <see cref="T:NLog.Config.LoggingConfiguration"/>
                </summary>
            </member>
            <member name="M:NLog.Config.ILoggingConfigurationLoader.Load(NLog.LogFactory)">
                <summary>
                Finds and loads the NLog configuration
                </summary>
                <param name="logFactory">LogFactory that owns the NLog configuration</param>
                <returns>NLog configuration (or null if none found)</returns>
            </member>
            <member name="M:NLog.Config.ILoggingConfigurationLoader.Activated(NLog.LogFactory,NLog.Config.LoggingConfiguration)">
                <summary>
                Notifies when LoggingConfiguration has been successfully applied
                </summary>
                <param name="logFactory">LogFactory that owns the NLog configuration</param>
                <param name="config">NLog Config</param>
            </member>
            <member name="M:NLog.Config.ILoggingConfigurationLoader.GetDefaultCandidateConfigFilePaths">
                <summary>
                Get file paths (including filename) for the possible NLog config files. 
                </summary>
                <returns>The filepaths to the possible config file</returns>
            </member>
            <member name="T:NLog.Config.INamedItemFactory`2">
                <summary>
                Represents a factory of named items (such as targets, layouts, layout renderers, etc.).
                </summary>
                <typeparam name="TInstanceType">Base type for each item instance.</typeparam>
                <typeparam name="TDefinitionType">Item definition type (typically <see cref="T:System.Type"/> or <see cref="T:System.Reflection.MethodInfo"/>).</typeparam>
            </member>
            <member name="M:NLog.Config.INamedItemFactory`2.RegisterDefinition(System.String,`1)">
                <summary>
                Registers new item definition.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="itemDefinition">Item definition.</param>
            </member>
            <member name="M:NLog.Config.INamedItemFactory`2.TryGetDefinition(System.String,`[email protected])">
                <summary>
                Tries to get registered item definition.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="result">Reference to a variable which will store the item definition.</param>
                <returns>Item definition.</returns>
            </member>
            <member name="M:NLog.Config.INamedItemFactory`2.CreateInstance(System.String)">
                <summary>
                Creates item instance.
                </summary>
                <param name="itemName">Name of the item.</param>
                <returns>Newly created item instance.</returns>
            </member>
            <member name="M:NLog.Config.INamedItemFactory`2.TryCreateInstance(System.String,`[email protected])">
                <summary>
                Tries to create an item instance.
                </summary>
                <param name="itemName">Name of the item.</param>
                <param name="result">The result.</param>
                <returns>True if instance was created successfully, false otherwise.</returns>
            </member>
            <member name="T:NLog.Config.InstallationContext">
                <summary>
                Provides context for install/uninstall operations.
                </summary>
            </member>
            <member name="F:NLog.Config.InstallationContext.LogLevel2ConsoleColor">
                <summary>
                Mapping between log levels and console output colors.
                </summary>
            </member>
            <member name="M:NLog.Config.InstallationContext.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.InstallationContext"/> class.
                </summary>
            </member>
            <member name="M:NLog.Config.InstallationContext.#ctor(System.IO.TextWriter)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.InstallationContext"/> class.
                </summary>
                <param name="logOutput">The log output.</param>
            </member>
            <member name="P:NLog.Config.InstallationContext.LogLevel">
                <summary>
                Gets or sets the installation log level.
                </summary>
            </member>
            <member name="P:NLog.Config.InstallationContext.IgnoreFailures">
                <summary>
                Gets or sets a value indicating whether to ignore failures during installation.
                </summary>
            </member>
            <member name="P:NLog.Config.InstallationContext.ThrowExceptions">
                <summary>
                Whether installation exceptions should be rethrown. If IgnoreFailures is set to true,
                this property has no effect (there are no exceptions to rethrow).
                </summary>
            </member>
            <member name="P:NLog.Config.InstallationContext.Parameters">
                <summary>
                Gets the installation parameters.
                </summary>
            </member>
            <member name="P:NLog.Config.InstallationContext.LogOutput">
                <summary>
                Gets or sets the log output.
                </summary>
            </member>
            <member name="M:NLog.Config.InstallationContext.Trace(System.String,System.Object[])">
                <summary>
                Logs the specified trace message.
                </summary>
                <param name="message">The message.</param>
                <param name="arguments">The arguments.</param>
            </member>
            <member name="M:NLog.Config.InstallationContext.Debug(System.String,System.Object[])">
                <summary>
                Logs the specified debug message.
                </summary>
                <param name="message">The message.</param>
                <param name="arguments">The arguments.</param>
            </member>
            <member name="M:NLog.Config.InstallationContext.Info(System.String,System.Object[])">
                <summary>
                Logs the specified informational message.
                </summary>
                <param name="message">The message.</param>
                <param name="arguments">The arguments.</param>
            </member>
            <member name="M:NLog.Config.InstallationContext.Warning(System.String,System.Object[])">
                <summary>
                Logs the specified warning message.
                </summary>
                <param name="message">The message.</param>
                <param name="arguments">The arguments.</param>
            </member>
            <member name="M:NLog.Config.InstallationContext.Error(System.String,System.Object[])">
                <summary>
                Logs the specified error message.
                </summary>
                <param name="message">The message.</param>
                <param name="arguments">The arguments.</param>
            </member>
            <member name="M:NLog.Config.InstallationContext.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.Config.InstallationContext.CreateLogEvent">
                <summary>
                Creates the log event which can be used to render layouts during installation/uninstallations.
                </summary>
                <returns>Log event info object.</returns>
            </member>
            <member name="T:NLog.Config.IPropertyTypeConverter">
                <summary>
                Convert object-value into specified type
                </summary>
            </member>
            <member name="M:NLog.Config.IPropertyTypeConverter.Convert(System.Object,System.Type,System.String,System.IFormatProvider)">
                <summary>
                Parses the input value and converts into the wanted type
                </summary>
                <param name="propertyValue">Input Value</param>
                <param name="propertyType">Wanted Type</param>
                <param name="format">Format to use when parsing</param>
                <param name="formatProvider">Culture to use when parsing</param>
                <returns>Output value with wanted type</returns>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher">
                <summary>
                Encapsulates <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/> and the logic to match the actual logger name
                All subclasses defines immutable objects.
                Concrete subclasses defines various matching rules through <see cref="M:NLog.Config.LoggerNameMatcher.NameMatches(System.String)"/>
                </summary>
            </member>
            <member name="M:NLog.Config.LoggerNameMatcher.Create(System.String)">
                <summary>
                Creates a concrete <see cref="T:NLog.Config.LoggerNameMatcher"/> based on <paramref name="loggerNamePattern"/>.
                </summary>
                <remarks>
                Rules used to select the concrete implementation returned:
                <list type="number">
                <item>if <paramref name="loggerNamePattern"/> is null => returns <see cref="T:NLog.Config.LoggerNameMatcher.NoneLoggerNameMatcher"/> (never matches)</item>
                <item>if <paramref name="loggerNamePattern"/> doesn't contains any '*' nor '?' => returns <see cref="T:NLog.Config.LoggerNameMatcher.EqualsLoggerNameMatcher"/> (matches only on case sensitive equals)</item>
                <item>if <paramref name="loggerNamePattern"/> == '*' => returns <see cref="T:NLog.Config.LoggerNameMatcher.AllLoggerNameMatcher"/> (always matches)</item>
                <item>if <paramref name="loggerNamePattern"/> doesn't contain '?'
                <list type="number">
                    <item>if <paramref name="loggerNamePattern"/> contains exactly 2 '*' one at the beginning and one at the end (i.e. "*foobar*) => returns <see cref="T:NLog.Config.LoggerNameMatcher.ContainsLoggerNameMatcher"/></item>
                    <item>if <paramref name="loggerNamePattern"/> contains exactly 1 '*' at the beginning (i.e. "*foobar") => returns <see cref="T:NLog.Config.LoggerNameMatcher.EndsWithLoggerNameMatcher"/></item>
                    <item>if <paramref name="loggerNamePattern"/> contains exactly 1 '*' at the end (i.e. "foobar*") => returns <see cref="T:NLog.Config.LoggerNameMatcher.StartsWithLoggerNameMatcher"/></item>
                </list>
                </item>
                <item>returns <see cref="T:NLog.Config.LoggerNameMatcher.MultiplePatternLoggerNameMatcher"/></item>
                </list>
                </remarks>
                <param name="loggerNamePattern">
                It may include one or more '*' or '?' wildcards at any position.
                <list type="bullet">
                <item>'*' means zero or more occurrecnces of any character</item>
                <item>'?' means exactly one occurrence of any character</item>
                </list>
                </param>
                <returns>A concrete <see cref="T:NLog.Config.LoggerNameMatcher"/></returns>
            </member>
            <member name="P:NLog.Config.LoggerNameMatcher.Pattern">
                <summary>
                Returns the argument passed to <see cref="M:NLog.Config.LoggerNameMatcher.Create(System.String)"/>
                </summary>
            </member>
            <member name="M:NLog.Config.LoggerNameMatcher.NameMatches(System.String)">
                <summary>
                Checks whether given name matches the logger name pattern.
                </summary>
                <param name="loggerName">String to be matched.</param>
                <returns>A value of <see langword="true"/> when the name matches, <see langword="false" /> otherwise.</returns>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.NoneLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that never matches.
                Used when pattern is null
                </summary>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.AllLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that always matches.
                Used when pattern is '*'
                </summary>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.EqualsLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive Equals
                Used when pattern is a string without wildcards '?' '*'
                </summary>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.StartsWithLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive StartsWith
                Used when pattern is a string like "*foobar"
                </summary>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.EndsWithLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive EndsWith
                Used when pattern is a string like "foobar*"
                </summary>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.ContainsLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive Contains
                Used when pattern is a string like "*foobar*"
                </summary>
            </member>
            <member name="T:NLog.Config.LoggerNameMatcher.MultiplePatternLoggerNameMatcher">
                <summary>
                Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a complex wildcards combinations:
                <list type="bullet">
                <item>'*' means zero or more occurrecnces of any character</item>
                <item>'?' means exactly one occurrence of any character</item>
                </list>
                used when pattern is a string containing any number of '?' or '*' in any position
                i.e. "*Server[*].Connection[?]"
                </summary>
            </member>
            <member name="T:NLog.Config.LoggingConfiguration">
                 <summary>
                 Keeps logging configuration and provides simple API
                 to modify it.
                 </summary>
                <remarks>This class is thread-safe.<c>.ToList()</c> is used for that purpose.</remarks>
            </member>
            <member name="F:NLog.Config.LoggingConfiguration._variables">
                <summary>
                Variables defined in xml or in API. name is case case insensitive. 
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.LogFactory">
                <summary>
                Gets the factory that will be configured
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfiguration" /> class.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.#ctor(NLog.LogFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfiguration" /> class.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.ExceptionLoggingOldStyle">
                <summary>
                Use the old exception log handling of NLog 3.0? 
                </summary>
                <remarks>This method was marked as obsolete on NLog 4.1 and it may be removed in a future release.</remarks>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.Variables">
                <summary>
                Gets the variables defined in the configuration.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.ConfiguredNamedTargets">
                <summary>
                Gets a collection of named targets specified in the configuration.
                </summary>
                <returns>
                A list of named targets.
                </returns>
                <remarks>
                Unnamed targets (such as those wrapped by other targets) are not returned.
                </remarks>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.FileNamesToWatch">
                <summary>
                Gets the collection of file names which should be watched for changes by NLog.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.LoggingRules">
                <summary>
                Gets the collection of logging rules.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo">
                <summary>
                Gets or sets the default culture info to use as <see cref="P:NLog.LogEventInfo.FormatProvider"/>.
                </summary>
                <value>
                Specific culture info or null to use <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/>
                </value>
            </member>
            <member name="P:NLog.Config.LoggingConfiguration.AllTargets">
                <summary>
                Gets all targets.
                </summary>
            </member>
            <member name="F:NLog.Config.LoggingConfiguration.TargetNameComparer">
                <summary>
                Compare <see cref="T:NLog.Targets.Target"/> objects based on their name.
                </summary>
                <remarks>This property is use to cache the comparer object.</remarks>
            </member>
            <member name="T:NLog.Config.LoggingConfiguration.TargetNameEqualityComparer">
                <summary>
                Defines methods to support the comparison of <see cref="T:NLog.Targets.Target"/> objects for equality based on their name.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddTarget(NLog.Targets.Target)">
                <summary>
                Registers the specified target object. The name of the target is read from <see cref="P:NLog.Targets.Target.Name"/>.
                </summary>
                <param name="target">
                The target object with a non <see langword="null"/> <see cref="P:NLog.Targets.Target.Name"/>
                </param>
                <exception cref="T:System.ArgumentNullException">when <paramref name="target"/> is <see langword="null"/></exception>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddTarget(System.String,NLog.Targets.Target)">
                <summary>
                Registers the specified target object under a given name.
                </summary>
                <param name="name">Name of the target.</param>
                <param name="target">The target object.</param>
                <exception cref="T:System.ArgumentException">when <paramref name="name"/> is <see langword="null"/></exception>
                <exception cref="T:System.ArgumentNullException">when <paramref name="target"/> is <see langword="null"/></exception>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.FindTargetByName(System.String)">
                <summary>
                Finds the target with the specified name.
                </summary>
                <param name="name">
                The name of the target to be found.
                </param>
                <returns>
                Found target or <see langword="null"/> when the target is not found.
                </returns>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.FindTargetByName``1(System.String)">
                <summary>
                Finds the target with the specified name and specified type.
                </summary>
                <param name="name">
                The name of the target to be found.
                </param>
                <typeparam name="TTarget">Type of the target</typeparam>
                <returns>
                Found target or <see langword="null"/> when the target is not found of not of type <typeparamref name="TTarget"/>
                </returns>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.LogLevel,NLog.LogLevel,System.String,System.String)">
                <summary>
                Add a rule with min- and maxLevel.
                </summary>
                <param name="minLevel">Minimum log level needed to trigger this rule.</param>
                <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
                <param name="targetName">Name of the target to be written when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.LogLevel,NLog.LogLevel,NLog.Targets.Target,System.String)">
                <summary>
                Add a rule with min- and maxLevel.
                </summary>
                <param name="minLevel">Minimum log level needed to trigger this rule.</param>
                <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
                <param name="target">Target to be written to when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.LogLevel,NLog.LogLevel,NLog.Targets.Target,System.String,System.Boolean)">
                <summary>
                Add a rule with min- and maxLevel.
                </summary>
                <param name="minLevel">Minimum log level needed to trigger this rule.</param>
                <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
                <param name="target">Target to be written to when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
                <param name="final">Gets or sets a value indicating whether to quit processing any further rule when this one matches.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRuleForOneLevel(NLog.LogLevel,System.String,System.String)">
                <summary>
                Add a rule for one loglevel.
                </summary>
                <param name="level">log level needed to trigger this rule. </param>
                <param name="targetName">Name of the target to be written when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRuleForOneLevel(NLog.LogLevel,NLog.Targets.Target,System.String)">
                <summary>
                Add a rule for one loglevel.
                </summary>
                <param name="level">log level needed to trigger this rule. </param>
                <param name="target">Target to be written to when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRuleForOneLevel(NLog.LogLevel,NLog.Targets.Target,System.String,System.Boolean)">
                <summary>
                Add a rule for one loglevel.
                </summary>
                <param name="level">log level needed to trigger this rule. </param>
                <param name="target">Target to be written to when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
                <param name="final">Gets or sets a value indicating whether to quit processing any further rule when this one matches.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRuleForAllLevels(System.String,System.String)">
                <summary>
                Add a rule for alle loglevels.
                </summary>
                <param name="targetName">Name of the target to be written when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRuleForAllLevels(NLog.Targets.Target,System.String)">
                <summary>
                Add a rule for alle loglevels.
                </summary>
                <param name="target">Target to be written to when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.AddRuleForAllLevels(NLog.Targets.Target,System.String,System.Boolean)">
                <summary>
                Add a rule for alle loglevels.
                </summary>
                <param name="target">Target to be written to when the rule matches.</param>
                <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
                <param name="final">Gets or sets a value indicating whether to quit processing any further rule when this one matches.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.FindRuleByName(System.String)">
                <summary>
                Finds the logging rule with the specified name.
                </summary>
                <param name="ruleName">The name of the logging rule to be found.</param>
                <returns>Found logging rule or <see langword="null"/> when not found.</returns>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.RemoveRuleByName(System.String)">
                <summary>
                Removes the specified named logging rule.
                </summary>
                <param name="ruleName">The name of the logging rule to be removed.</param>
                <returns>Found one or more logging rule to remove, or <see langword="false"/> when not found.</returns>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.Reload">
                <summary>
                Called by LogManager when one of the log configuration files changes.
                </summary>
                <returns>
                A new instance of <see cref="T:NLog.Config.LoggingConfiguration"/> that represents the updated configuration.
                </returns>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.RemoveTarget(System.String)">
                <summary>
                Removes the specified named target.
                </summary>
                <param name="name">Name of the target.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.Install(NLog.Config.InstallationContext)">
                <summary>
                Installs target-specific objects on current system.
                </summary>
                <param name="installationContext">The installation context.</param>
                <remarks>
                Installation typically runs with administrative permissions.
                </remarks>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.Uninstall(NLog.Config.InstallationContext)">
                <summary>
                Uninstalls target-specific objects from current system.
                </summary>
                <param name="installationContext">The installation context.</param>
                <remarks>
                Uninstallation typically runs with administrative permissions.
                </remarks>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.Close">
                <summary>
                Closes all targets and releases any unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.Dump">
                <summary>
                Log to the internal (NLog) logger the information about the <see cref="T:NLog.Targets.Target"/> and <see
                cref="T:NLog.Config.LoggingRule"/> associated with this <see cref="T:NLog.Config.LoggingConfiguration"/> instance.
                </summary>
                <remarks>
                The information are only recorded in the internal logger if Debug level is enabled, otherwise nothing is 
                recorded.
                </remarks>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.FlushAllTargets(NLog.Common.AsyncContinuation)">
                <summary>
                Flushes any pending log messages on all appenders.
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.ValidateConfig">
                <summary>
                Validates the configuration.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.CopyVariables(System.Collections.Generic.IDictionary{System.String,NLog.Layouts.SimpleLayout})">
                <summary>
                Copies all variables from provided dictionary into current configuration variables. 
                </summary>
                <param name="masterVariables">Master variables dictionary</param>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.ExpandSimpleVariables(System.String)">
                <summary>
                Replace a simple variable with a value. The orginal value is removed and thus we cannot redo this in a later stage.
                </summary>
                <param name="input"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Config.LoggingConfiguration.CheckUnusedTargets">
                <summary>
                Checks whether unused targets exist. If found any, just write an internal log at Warn level.
                <remarks>If initializing not started or failed, then checking process will be canceled</remarks>
                </summary>
            </member>
            <member name="T:NLog.Config.LoggingConfigurationChangedEventArgs">
                <summary>
                Arguments for <see cref="E:NLog.LogFactory.ConfigurationChanged"/> events.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationChangedEventArgs.#ctor(NLog.Config.LoggingConfiguration,NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfigurationChangedEventArgs" /> class.
                </summary>
                <param name="activatedConfiguration">The new configuration.</param>
                <param name="deactivatedConfiguration">The old configuration.</param>
            </member>
            <member name="P:NLog.Config.LoggingConfigurationChangedEventArgs.DeactivatedConfiguration">
                <summary>
                Gets the old configuration.
                </summary>
                <value>The old configuration.</value>
            </member>
            <member name="P:NLog.Config.LoggingConfigurationChangedEventArgs.ActivatedConfiguration">
                <summary>
                Gets the new configuration.
                </summary>
                <value>The new configuration.</value>
            </member>
            <member name="P:NLog.Config.LoggingConfigurationChangedEventArgs.OldConfiguration">
                <summary>
                Gets the new configuration
                </summary>
                <value>The new configuration.</value>
            </member>
            <member name="P:NLog.Config.LoggingConfigurationChangedEventArgs.NewConfiguration">
                <summary>
                Gets the old configuration
                </summary>
                <value>The old configuration.</value>
            </member>
            <member name="T:NLog.Config.LoggingConfigurationFileLoader">
                <summary>
                Enables loading of NLog configuration from a file
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationFileLoader.GetDefaultCandidateConfigFilePaths">
                <inheritdoc/>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationFileLoader.GetDefaultCandidateConfigFilePaths(System.String)">
                <summary>
                Get default file paths (including filename) for possible NLog config files. 
                </summary>
            </member>
            <member name="T:NLog.Config.LoggingConfigurationParser">
                <summary>
                Loads NLog configuration from <see cref="T:NLog.Config.ILoggingConfigurationElement"/>
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.#ctor(NLog.LogFactory)">
                <summary>
                Constructor
                </summary>
                <param name="logFactory"></param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.LoadConfig(NLog.Config.ILoggingConfigurationElement,System.String)">
                <summary>
                Loads NLog configuration from provided config section
                </summary>
                <param name="nlogConfig"></param>
                <param name="basePath"></param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.SetInternalLogLevel(System.Collections.Generic.IDictionary{System.String,System.String})">
                <summary>
                Set <see cref="P:NLog.Common.InternalLogger.LogLevel"/> and return internalLoggerEnabled
                </summary>
                <param name="dict"></param>
                <returns>internalLoggerEnabled?</returns>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.SetThrowConfigExceptions(System.Collections.Generic.IDictionary{System.String,System.String})">
                <summary>
                Set <see cref="P:NLog.LogFactory.ThrowConfigExceptions"/>
                </summary>
                <param name="dict"></param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.SetThrowExceptions(System.Collections.Generic.IDictionary{System.String,System.String})">
                <summary>
                Set <see cref="P:NLog.LogFactory.ThrowExceptions"/>
                </summary>
                <param name="dict"></param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.CreateNLogConfigDictionary(NLog.Config.ILoggingConfigurationElement)">
                <summary>
                build dictionary, use last value of duplicates
                </summary>
                <param name="nlogConfig"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.ParseLogLevelSafe(System.String,System.String,NLog.LogLevel)">
                <summary>
                Parse loglevel, but don't throw if exception throwing is disabled
                </summary>
                <param name="attributeName">Name of attribute for logging.</param>
                <param name="attributeValue">Value of parse.</param>
                <param name="default">Used if there is an exception</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.ParseNLogSection(NLog.Config.ILoggingConfigurationElement)">
                <summary>
                Parses a single config section within the NLog-config
                </summary>
                <param name="configSection"></param>
                <returns>Section was recognized</returns>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.ParseRulesElement(NLog.Config.ILoggingConfigurationElement,System.Collections.Generic.IList{NLog.Config.LoggingRule})">
                <summary>
                Parse {Rules} xml element
                </summary>
                <param name="rulesElement"></param>
                <param name="rulesCollection">Rules are added to this parameter.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.ParseRuleElement(NLog.Config.ILoggingConfigurationElement)">
                <summary>
                Parse {Logger} xml element
                </summary>
                <param name="loggerElement"></param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.ParseBooleanValue(System.String,System.String,System.Boolean)">
                <summary>
                Parse boolean
                </summary>
                <param name="propertyName">Name of the property for logging.</param>
                <param name="value">value to parse</param>
                <param name="defaultValue">Default value to return if the parse failed</param>
                <returns>Boolean attribute value or default.</returns>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.StripOptionalNamespacePrefix(System.String)">
                <summary>
                Remove the namespace (before :)
                </summary>
                <example>
                x:a, will be a
                </example>
                <param name="attributeValue"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationParser.CleanSpaces(System.String)">
                <summary>
                Remove all spaces, also in between text. 
                </summary>
                <param name="s">text</param>
                <returns>text without spaces</returns>
                <remarks>Tabs and other whitespace is not removed!</remarks>
            </member>
            <member name="M:NLog.Config.ILoggingConfigurationSectionExtensions.GetOptionalBooleanValue(NLog.Config.ILoggingConfigurationElement,System.String,System.Boolean)">
                <summary>
                Gets the optional boolean attribute value.
                </summary>
                <param name="section"></param>
                <param name="attributeName">Name of the attribute.</param>
                <param name="defaultValue">Default value to return if the attribute is not found or if there is a parse error</param>
                <returns>Boolean attribute value or default.</returns>
            </member>
            <member name="T:NLog.Config.LoggingConfigurationReloadedEventArgs">
                <summary>
                Arguments for <see cref="E:NLog.LogFactory.ConfigurationReloaded"/>.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationReloadedEventArgs.#ctor(System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfigurationReloadedEventArgs" /> class.
                </summary>
                <param name="succeeded">Whether configuration reload has succeeded.</param>
            </member>
            <member name="M:NLog.Config.LoggingConfigurationReloadedEventArgs.#ctor(System.Boolean,System.Exception)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfigurationReloadedEventArgs" /> class.
                </summary>
                <param name="succeeded">Whether configuration reload has succeeded.</param>
                <param name="exception">The exception during configuration reload.</param>
            </member>
            <member name="P:NLog.Config.LoggingConfigurationReloadedEventArgs.Succeeded">
                <summary>
                Gets a value indicating whether configuration reload has succeeded.
                </summary>
                <value>A value of <c>true</c> if succeeded; otherwise, <c>false</c>.</value>
            </member>
            <member name="P:NLog.Config.LoggingConfigurationReloadedEventArgs.Exception">
                <summary>
                Gets the exception which occurred during configuration reload.
                </summary>
                <value>The exception.</value>
            </member>
            <member name="T:NLog.Config.LoggingConfigurationWatchableFileLoader">
                <summary>
                Enables FileWatcher for the currently loaded NLog Configuration File,
                and supports automatic reload on file modification.
                </summary>
            </member>
            <member name="T:NLog.Config.LoggingRule">
                <summary>
                Represents a logging rule. An equivalent of &lt;logger /&gt; configuration element.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingRule.#ctor">
                <summary>
                Create an empty <see cref="T:NLog.Config.LoggingRule" />.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingRule.#ctor(System.String)">
                <summary>
                Create an empty <see cref="T:NLog.Config.LoggingRule" />.
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingRule.#ctor(System.String,NLog.LogLevel,NLog.LogLevel,NLog.Targets.Target)">
                <summary>
                Create a new <see cref="T:NLog.Config.LoggingRule" /> with a <paramref name="minLevel"/> and  <paramref name="maxLevel"/> which writes to <paramref name="target"/>.
                </summary>
                <param name="loggerNamePattern">Logger name pattern used for <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>. It may include one or more '*' or '?' wildcards at any position.</param>
                <param name="minLevel">Minimum log level needed to trigger this rule.</param>
                <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
                <param name="target">Target to be written to when the rule matches.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.#ctor(System.String,NLog.LogLevel,NLog.Targets.Target)">
                <summary>
                Create a new <see cref="T:NLog.Config.LoggingRule" /> with a <paramref name="minLevel"/> which writes to <paramref name="target"/>.
                </summary>
                <param name="loggerNamePattern">Logger name pattern used for <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>. It may include one or more '*' or '?' wildcards at any position.</param>
                <param name="minLevel">Minimum log level needed to trigger this rule.</param>
                <param name="target">Target to be written to when the rule matches.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.#ctor(System.String,NLog.Targets.Target)">
                <summary>
                Create a (disabled) <see cref="T:NLog.Config.LoggingRule" />. You should call <see cref="M:NLog.Config.LoggingRule.EnableLoggingForLevel(NLog.LogLevel)"/> or see cref="EnableLoggingForLevels"/> to enable logging.
                </summary>
                <param name="loggerNamePattern">Logger name pattern used for <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>. It may include one or more '*' or '?' wildcards at any position.</param>
                <param name="target">Target to be written to when the rule matches.</param>
            </member>
            <member name="P:NLog.Config.LoggingRule.RuleName">
                <summary>
                Rule identifier to allow rule lookup
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingRule.Targets">
                <summary>
                Gets a collection of targets that should be written to when this rule matches.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingRule.ChildRules">
                <summary>
                Gets a collection of child rules to be evaluated when this rule matches.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingRule.Filters">
                <summary>
                Gets a collection of filters to be checked before writing to targets.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingRule.Final">
                <summary>
                Gets or sets a value indicating whether to quit processing any further rule when this one matches.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingRule.LoggerNamePattern">
                <summary>
                Gets or sets logger name pattern.
                </summary>
                <remarks>
                Logger name pattern used by <see cref="M:NLog.Config.LoggingRule.NameMatches(System.String)"/> to check if a logger name matches this rule.
                It may include one or more '*' or '?' wildcards at any position.
                <list type="bullet">
                <item>'*' means zero or more occurrecnces of any character</item>
                <item>'?' means exactly one occurrence of any character</item>
                </list>
                </remarks>
            </member>
            <member name="P:NLog.Config.LoggingRule.Levels">
                <summary>
                Gets the collection of log levels enabled by this rule.
                </summary>
            </member>
            <member name="P:NLog.Config.LoggingRule.DefaultFilterResult">
                <summary>
                Default action if all filters won't match
                </summary>
            </member>
            <member name="M:NLog.Config.LoggingRule.EnableLoggingForLevel(NLog.LogLevel)">
                <summary>
                Enables logging for a particular level.
                </summary>
                <param name="level">Level to be enabled.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.EnableLoggingForLevels(NLog.LogLevel,NLog.LogLevel)">
                <summary>
                Enables logging for a particular levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>.
                </summary>
                <param name="minLevel">Minimum log level needed to trigger this rule.</param>
                <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.DisableLoggingForLevel(NLog.LogLevel)">
                <summary>
                Disables logging for a particular level.
                </summary>
                <param name="level">Level to be disabled.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.DisableLoggingForLevels(NLog.LogLevel,NLog.LogLevel)">
                <summary>
                Disables logging for particular levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>.
                </summary>
                <param name="minLevel">Minimum log level to be disables.</param>
                <param name="maxLevel">Maximum log level to de disabled.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.SetLoggingLevels(NLog.LogLevel,NLog.LogLevel)">
                <summary>
                Enables logging the levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>. All the other levels will be disabled.
                </summary>
                <param name="minLevel">>Minimum log level needed to trigger this rule.</param>
                <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
            </member>
            <member name="M:NLog.Config.LoggingRule.ToString">
                <summary>
                Returns a string representation of <see cref="T:NLog.Config.LoggingRule"/>. Used for debugging.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents the current <see cref="T:System.Object"/>.
                </returns>
            </member>
            <member name="M:NLog.Config.LoggingRule.IsLoggingEnabledForLevel(NLog.LogLevel)">
                <summary>
                Checks whether te particular log level is enabled for this rule.
                </summary>
                <param name="level">Level to be checked.</param>
                <returns>A value of <see langword="true"/> when the log level is enabled, <see langword="false" /> otherwise.</returns>
            </member>
            <member name="M:NLog.Config.LoggingRule.NameMatches(System.String)">
                <summary>
                Checks whether given name matches the <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>.
                </summary>
                <param name="loggerName">String to be matched.</param>
                <returns>A value of <see langword="true"/> when the name matches, <see langword="false" /> otherwise.</returns>
            </member>
            <member name="T:NLog.Config.MethodFactory`2">
                <summary>
                Factory for locating methods.
                </summary>
                <typeparam name="TClassAttributeType">The type of the class marker attribute.</typeparam>
                <typeparam name="TMethodAttributeType">The type of the method marker attribute.</typeparam>
            </member>
            <member name="P:NLog.Config.MethodFactory`2.AllRegisteredItems">
                <summary>
                Gets a collection of all registered items in the factory.
                </summary>
                <returns>
                Sequence of key/value pairs where each key represents the name
                of the item and value is the <see cref="T:System.Reflection.MethodInfo"/> of
                the item.
                </returns>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.ScanTypes(System.Type[],System.String)">
                <summary>
                Scans the assembly for classes marked with <typeparamref name="TClassAttributeType"/>
                and methods marked with <typeparamref name="TMethodAttributeType"/> and adds them 
                to the factory.
                </summary>
                <param name="types">The types to scan.</param>
                <param name="prefix">The prefix to use for names.</param>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.RegisterType(System.Type,System.String)">
                <summary>
                Registers the type.
                </summary>
                <param name="type">The type to register.</param>
                <param name="itemNamePrefix">The item name prefix.</param>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.Clear">
                <summary>
                Clears contents of the factory.
                </summary>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.RegisterDefinition(System.String,System.Reflection.MethodInfo)">
                <summary>
                Registers the definition of a single method.
                </summary>
                <param name="itemName">The method name.</param>
                <param name="itemDefinition">The method info.</param>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.TryCreateInstance(System.String,[email protected])">
                <summary>
                Tries to retrieve method by name.
                </summary>
                <param name="itemName">The method name.</param>
                <param name="result">The result.</param>
                <returns>A value of <c>true</c> if the method was found, <c>false</c> otherwise.</returns>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.CreateInstance(System.String)">
                <summary>
                Retrieves method by name.
                </summary>
                <param name="itemName">Method name.</param>
                <returns>MethodInfo object.</returns>
            </member>
            <member name="M:NLog.Config.MethodFactory`2.TryGetDefinition(System.String,[email protected])">
                <summary>
                Tries to get method definition.
                </summary>
                <param name="itemName">The method name.</param>
                <param name="result">The result.</param>
                <returns>A value of <c>true</c> if the method was found, <c>false</c> otherwise.</returns>
            </member>
            <member name="T:NLog.Config.MutableUnsafeAttribute">
                <summary>
                Marks the layout or layout renderer depends on mutable objects from the LogEvent
                
                This can be <see cref="P:NLog.LogEventInfo.Properties"/> or <see cref="P:NLog.LogEventInfo.Exception"/>
                </summary>
            </member>
            <member name="T:NLog.Config.NameBaseAttribute">
                <summary>
                Attaches a simple name to an item (such as <see cref="T:NLog.Targets.Target"/>, 
                <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>, <see cref="T:NLog.Layouts.Layout"/>, etc.).
                </summary>
            </member>
            <member name="M:NLog.Config.NameBaseAttribute.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.NameBaseAttribute" /> class.
                </summary>
                <param name="name">The name of the item.</param>
            </member>
            <member name="P:NLog.Config.NameBaseAttribute.Name">
                <summary>
                Gets the name of the item.
                </summary>
                <value>The name of the item.</value>
            </member>
            <member name="T:NLog.Config.NLogConfigurationIgnorePropertyAttribute">
                <summary>
                Indicates NLog should not scan this property during configuration.
                </summary>
            </member>
            <member name="M:NLog.Config.NLogConfigurationIgnorePropertyAttribute.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.NLogConfigurationIgnorePropertyAttribute"/> class.
                </summary>
            </member>
            <member name="T:NLog.Config.NLogConfigurationItemAttribute">
                <summary>
                Marks the object as configuration item for NLog.
                </summary>
            </member>
            <member name="M:NLog.Config.NLogConfigurationItemAttribute.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.NLogConfigurationItemAttribute"/> class.
                </summary>
            </member>
            <member name="T:NLog.Config.NLogXmlElement">
                <summary>
                Represents simple XML element with case-insensitive attribute semantics.
                </summary>
            </member>
            <member name="M:NLog.Config.NLogXmlElement.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.NLogXmlElement"/> class.
                </summary>
                <param name="inputUri">The input URI.</param>
            </member>
            <member name="M:NLog.Config.NLogXmlElement.#ctor(System.Xml.XmlReader)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.NLogXmlElement"/> class.
                </summary>
                <param name="reader">The reader to initialize element from.</param>
            </member>
            <member name="M:NLog.Config.NLogXmlElement.#ctor">
                <summary>
                Prevents a default instance of the <see cref="T:NLog.Config.NLogXmlElement"/> class from being created.
                </summary>
            </member>
            <member name="P:NLog.Config.NLogXmlElement.LocalName">
                <summary>
                Gets the element name.
                </summary>
            </member>
            <member name="P:NLog.Config.NLogXmlElement.AttributeValues">
                <summary>
                Gets the dictionary of attribute values.
                </summary>
            </member>
            <member name="P:NLog.Config.NLogXmlElement.Children">
                <summary>
                Gets the collection of child elements.
                </summary>
            </member>
            <member name="P:NLog.Config.NLogXmlElement.Value">
                <summary>
                Gets the value of the element.
                </summary>
            </member>
            <member name="F:NLog.Config.NLogXmlElement._parsingErrors">
                <summary>
                Last error occured during configuration read
                </summary>
            </member>
            <member name="M:NLog.Config.NLogXmlElement.Elements(System.String)">
                <summary>
                Returns children elements with the specified element name.
                </summary>
                <param name="elementName">Name of the element.</param>
                <returns>Children elements with the specified element name.</returns>
            </member>
            <member name="M:NLog.Config.NLogXmlElement.AssertName(System.String[])">
                <summary>
                Asserts that the name of the element is among specified element names.
                </summary>
                <param name="allowedNames">The allowed names.</param>
            </member>
            <member name="M:NLog.Config.NLogXmlElement.GetParsingErrors">
                <summary>
                Returns all parsing errors from current and all child elements.
                </summary>
            </member>
            <member name="T:NLog.Config.PropertyTypeConverter">
                <summary>
                Default implementation of <see cref="T:NLog.Config.IPropertyTypeConverter"/>
                </summary>
            </member>
            <member name="M:NLog.Config.PropertyTypeConverter.Convert(System.Object,System.Type,System.String,System.IFormatProvider)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.Config.RequiredParameterAttribute">
                <summary>
                Attribute used to mark the required parameters for targets,
                layout targets and filters.
                </summary>
            </member>
            <member name="T:NLog.Config.SimpleConfigurator">
                <summary>
                Provides simple programmatic configuration API used for trivial logging cases.
                
                Warning, these methods will overwrite the current config.
                </summary>
            </member>
            <member name="M:NLog.Config.SimpleConfigurator.ConfigureForConsoleLogging">
                <summary>
                Configures NLog for console logging so that all messages above and including
                the <see cref="F:NLog.LogLevel.Info"/> level are output to the console.
                </summary>
            </member>
            <member name="M:NLog.Config.SimpleConfigurator.ConfigureForConsoleLogging(NLog.LogLevel)">
                <summary>
                Configures NLog for console logging so that all messages above and including
                the specified level are output to the console.
                </summary>
                <param name="minLevel">The minimal logging level.</param>
            </member>
            <member name="M:NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(NLog.Targets.Target)">
                <summary>
                Configures NLog for to log to the specified target so that all messages 
                above and including the <see cref="F:NLog.LogLevel.Info"/> level are output.
                </summary>
                <param name="target">The target to log all messages to.</param>
            </member>
            <member name="M:NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(NLog.Targets.Target,NLog.LogLevel)">
                <summary>
                Configures NLog for to log to the specified target so that all messages 
                above and including the specified level are output.
                </summary>
                <param name="target">The target to log all messages to.</param>
                <param name="minLevel">The minimal logging level.</param>
            </member>
            <member name="M:NLog.Config.SimpleConfigurator.ConfigureForFileLogging(System.String)">
                <summary>
                Configures NLog for file logging so that all messages above and including
                the <see cref="F:NLog.LogLevel.Info"/> level are written to the specified file.
                </summary>
                <param name="fileName">Log file name.</param>
            </member>
            <member name="M:NLog.Config.SimpleConfigurator.ConfigureForFileLogging(System.String,NLog.LogLevel)">
                <summary>
                Configures NLog for file logging so that all messages above and including
                the specified level are written to the specified file.
                </summary>
                <param name="fileName">Log file name.</param>
                <param name="minLevel">The minimal logging level.</param>
            </member>
            <member name="T:NLog.Config.StackTraceUsage">
                <summary>
                Value indicating how stack trace should be captured when processing the log event.
                </summary>
            </member>
            <member name="F:NLog.Config.StackTraceUsage.None">
                <summary>
                Stack trace should not be captured.
                </summary>
            </member>
            <member name="F:NLog.Config.StackTraceUsage.WithoutSource">
                <summary>
                Stack trace should be captured without source-level information.
                </summary>
            </member>
            <member name="F:NLog.Config.StackTraceUsage.WithSource">
                <summary>
                Stack trace should be captured including source-level information such as line numbers.
                </summary>
            </member>
            <member name="F:NLog.Config.StackTraceUsage.Max">
                <summary>
                Capture maximum amount of the stack trace information supported on the platform.
                </summary>
            </member>
            <member name="T:NLog.Config.ThreadAgnosticAttribute">
                 <summary>
                 Marks the layout or layout renderer as thread independent - it producing correct results 
                 regardless of the thread it's running on. 
                
                 Without this attribute everything is rendered on the main thread.
                 </summary>
                 <remarks>
                 If this attribute is set on a layout, it could be rendered on the another thread. 
                 This could be more efficient as it's skipped when not needed.
                 
                 If context like <c>HttpContext.Current</c> is needed, which is only available on the main thread, this attribute should not be applied.
                
                 See the AsyncTargetWrapper and BufferTargetWrapper with the <see cref="M:NLog.Targets.Target.PrecalculateVolatileLayouts(NLog.LogEventInfo)"/> , using <see cref="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)"/>
                 
                 Apply this attribute when:
                 - The result can we rendered in another thread. Delaying this could be more efficient. And/Or,
                 - The result should not be precalculated, for example the target sends some extra context information. 
                 </remarks>
            </member>
            <member name="T:NLog.Config.ThreadSafeAttribute">
                 <summary>
                 Marks the layout or layout renderer as thread safe - it producing correct results 
                 regardless of the number of threads it's running on. 
                
                 Without this attribute then the target concurrency will be reduced
                 </summary>
            </member>
            <member name="T:NLog.Config.XmlLoggingConfiguration">
                 <summary>
                 A class for configuring NLog through an XML configuration file 
                 (App.config style or App.nlog style).
                 
                 Parsing of the XML file is also implemented in this class.
                 </summary>
                <remarks>
                 - This class is thread-safe.<c>.ToList()</c> is used for that purpose.
                 - Update TemplateXSD.xml for changes outside targets
                 </remarks>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="fileName">Configuration file to be read.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,NLog.LogFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="fileName">Configuration file to be read.</param>
                <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="fileName">Configuration file to be read.</param>
                <param name="ignoreErrors">Ignore any errors during configuration.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,System.Boolean,NLog.LogFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="fileName">Configuration file to be read.</param>
                <param name="ignoreErrors">Ignore any errors during configuration.</param>
                <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.CreateFileReader(System.String)">
                <summary>
                Create XML reader for (xml config) file.
                </summary>
                <param name="fileName">filepath</param>
                <returns>reader or <c>null</c> if filename is empty.</returns>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
                <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,NLog.LogFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
                <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
                <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
                <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
                <param name="ignoreErrors">Ignore any errors during configuration.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,System.Boolean,NLog.LogFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
                <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
                <param name="ignoreErrors">Ignore any errors during configuration.</param>
                <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlElement,System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="element">The XML element.</param>
                <param name="fileName">Name of the XML file.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlElement,System.String,System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="element">The XML element.</param>
                <param name="fileName">Name of the XML file.</param>
                <param name="ignoreErrors">If set to <c>true</c> errors will be ignored during file processing.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,System.String,System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
                </summary>
                <param name="xmlContents">The XML contents.</param>
                <param name="fileName">Name of the XML file.</param>
                <param name="ignoreErrors">If set to <c>true</c> errors will be ignored during file processing.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.CreateFromXmlString(System.String)">
                <summary>
                Parse XML string as NLog configuration
                </summary>
                <param name="xml">NLog configuration</param>
                <returns></returns>
            </member>
            <member name="P:NLog.Config.XmlLoggingConfiguration.AppConfig">
                <summary>
                Gets the default <see cref="T:NLog.Config.LoggingConfiguration" /> object by parsing 
                the application configuration file (<c>app.exe.config</c>).
                </summary>
            </member>
            <member name="P:NLog.Config.XmlLoggingConfiguration.InitializeSucceeded">
                <summary>
                Did the <see cref="M:NLog.Config.XmlLoggingConfiguration.Initialize(System.Xml.XmlReader,System.String,System.Boolean)"/> Succeeded? <c>true</c>= success, <c>false</c>= error, <c>null</c> = initialize not started yet.
                </summary>
            </member>
            <member name="P:NLog.Config.XmlLoggingConfiguration.AutoReload">
                <summary>
                Gets or sets a value indicating whether all of the configuration files
                should be watched for changes and reloaded automatically when changed.
                </summary>
            </member>
            <member name="P:NLog.Config.XmlLoggingConfiguration.FileNamesToWatch">
                <summary>
                Gets the collection of file names which should be watched for changes by NLog.
                This is the list of configuration files processed.
                If the <c>autoReload</c> attribute is not set it returns empty collection.
                </summary>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.Reload">
                <summary>
                Re-reads the original configuration file and returns the new <see cref="T:NLog.Config.LoggingConfiguration" /> object.
                </summary>
                <returns>The new <see cref="T:NLog.Config.XmlLoggingConfiguration" /> object.</returns>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.GetCandidateConfigFilePaths">
                <summary>
                Get file paths (including filename) for the possible NLog config files. 
                </summary>
                <returns>The filepaths to the possible config file</returns>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.SetCandidateConfigFilePaths(System.Collections.Generic.IEnumerable{System.String})">
                <summary>
                Overwrite the paths (including filename) for the possible NLog config files.
                </summary>
                <param name="filePaths">The filepaths to the possible config file</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ResetCandidateConfigFilePath">
                <summary>
                Clear the candidate file paths and return to the defaults.
                </summary>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.Initialize(System.Xml.XmlReader,System.String,System.Boolean)">
                <summary>
                Initializes the configuration.
                </summary>
                <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
                <param name="fileName">Name of the file that contains the element (to be used as a base for including other files).</param>
                <param name="ignoreErrors">Ignore any errors during configuration.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.CheckParsingErrors(NLog.Config.NLogXmlElement)">
                <summary>
                Checks whether any error during XML configuration parsing has occured.
                If there are any and <c>ThrowConfigExceptions</c> or <c>ThrowExceptions</c>
                setting is enabled - throws <c>NLogConfigurationException</c>, otherwise
                just write an internal log at Warn level.
                </summary>
                <param name="rootContentElement">Root NLog configuration xml element</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ConfigureFromFile(System.String,System.Boolean)">
                <summary>
                Add a file with configuration. Check if not already included.
                </summary>
                <param name="fileName"></param>
                <param name="autoReloadDefault"></param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ParseTopLevel(NLog.Config.NLogXmlElement,System.String,System.Boolean)">
                <summary>
                Parse the root
                </summary>
                <param name="content"></param>
                <param name="filePath">path to config file.</param>
                <param name="autoReloadDefault">The default value for the autoReload option.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ParseConfigurationElement(NLog.Config.NLogXmlElement,System.String,System.Boolean)">
                <summary>
                Parse {configuration} xml element.
                </summary>
                <param name="configurationElement"></param>
                <param name="filePath">path to config file.</param>
                <param name="autoReloadDefault">The default value for the autoReload option.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ParseNLogElement(NLog.Config.ILoggingConfigurationElement,System.String,System.Boolean)">
                <summary>
                Parse {NLog} xml element.
                </summary>
                <param name="nlogElement"></param>
                <param name="filePath">path to config file.</param>
                <param name="autoReloadDefault">The default value for the autoReload option.</param>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ParseNLogSection(NLog.Config.ILoggingConfigurationElement)">
                <summary>
                Parses a single config section within the NLog-config
                </summary>
                <param name="configSection"></param>
                <returns>Section was recognized</returns>
            </member>
            <member name="M:NLog.Config.XmlLoggingConfiguration.ConfigureFromFilesByMask(System.String,System.String,System.Boolean)">
                <summary>
                Include (multiple) files by filemask, e.g. *.nlog
                </summary>
                <param name="baseDirectory">base directory in case if <paramref name="fileMask"/> is relative</param>
                <param name="fileMask">relative or absolute fileMask</param>
                <param name="autoReloadDefault"></param>
            </member>
            <member name="T:NLog.Filters.ConditionBasedFilter">
                <summary>
                Matches when the specified condition is met.
                </summary>
                <remarks>
                Conditions are expressed using a simple language 
                described <a href="conditions.html">here</a>.
                </remarks>
            </member>
            <member name="P:NLog.Filters.ConditionBasedFilter.Condition">
                <summary>
                Gets or sets the condition expression.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="M:NLog.Filters.ConditionBasedFilter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="T:NLog.Filters.Filter">
                <summary>
                An abstract filter class. Provides a way to eliminate log messages
                based on properties other than logger name and log level.
                </summary>
            </member>
            <member name="M:NLog.Filters.Filter.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Filters.Filter" /> class.
                </summary>
            </member>
            <member name="P:NLog.Filters.Filter.Action">
                <summary>
                Gets or sets the action to be taken when filter matches.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="M:NLog.Filters.Filter.GetFilterResult(NLog.LogEventInfo)">
                <summary>
                Gets the result of evaluating filter against given log event.
                </summary>
                <param name="logEvent">The log event.</param>
                <returns>Filter result.</returns>
            </member>
            <member name="M:NLog.Filters.Filter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="T:NLog.Filters.FilterAttribute">
                <summary>
                Marks class as a layout renderer and assigns a name to it.
                </summary>
            </member>
            <member name="M:NLog.Filters.FilterAttribute.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Filters.FilterAttribute" /> class.
                </summary>
                <param name="name">Name of the filter.</param>
            </member>
            <member name="T:NLog.Filters.FilterResult">
                <summary>
                Filter result.
                </summary>
            </member>
            <member name="F:NLog.Filters.FilterResult.Neutral">
                <summary>
                The filter doesn't want to decide whether to log or discard the message.
                </summary>
            </member>
            <member name="F:NLog.Filters.FilterResult.Log">
                <summary>
                The message should be logged.
                </summary>
            </member>
            <member name="F:NLog.Filters.FilterResult.Ignore">
                <summary>
                The message should not be logged.
                </summary>
            </member>
            <member name="F:NLog.Filters.FilterResult.LogFinal">
                <summary>
                The message should be logged and processing should be finished.
                </summary>
            </member>
            <member name="F:NLog.Filters.FilterResult.IgnoreFinal">
                <summary>
                The message should not be logged and processing should be finished.
                </summary>
            </member>
            <member name="T:NLog.Filters.LayoutBasedFilter">
                <summary>
                A base class for filters that are based on comparing a value to a layout.
                </summary>
            </member>
            <member name="M:NLog.Filters.LayoutBasedFilter.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Filters.LayoutBasedFilter" /> class.
                </summary>
            </member>
            <member name="P:NLog.Filters.LayoutBasedFilter.Layout">
                <summary>
                Gets or sets the layout to be used to filter log messages.
                </summary>
                <value>The layout.</value>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="T:NLog.Filters.WhenContainsFilter">
                <summary>
                Matches when the calculated layout contains the specified substring. 
                This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="conditions.html">conditions</a>.
                </summary>
            </member>
            <member name="P:NLog.Filters.WhenContainsFilter.IgnoreCase">
                <summary>
                Gets or sets a value indicating whether to ignore case when comparing strings.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenContainsFilter.Substring">
                <summary>
                Gets or sets the substring to be matched.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="M:NLog.Filters.WhenContainsFilter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="T:NLog.Filters.WhenEqualFilter">
                <summary>
                Matches when the calculated layout is equal to the specified substring.
                This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="conditions.html">conditions</a>.
                </summary>
            </member>
            <member name="P:NLog.Filters.WhenEqualFilter.IgnoreCase">
                <summary>
                Gets or sets a value indicating whether to ignore case when comparing strings.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenEqualFilter.CompareTo">
                <summary>
                Gets or sets a string to compare the layout to.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="M:NLog.Filters.WhenEqualFilter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="T:NLog.Filters.WhenNotContainsFilter">
                <summary>
                Matches when the calculated layout does NOT contain the specified substring.
                This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="conditions.html">conditions</a>.
                </summary>
            </member>
            <member name="P:NLog.Filters.WhenNotContainsFilter.Substring">
                <summary>
                Gets or sets the substring to be matched.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenNotContainsFilter.IgnoreCase">
                <summary>
                Gets or sets a value indicating whether to ignore case when comparing strings.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="M:NLog.Filters.WhenNotContainsFilter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="T:NLog.Filters.WhenNotEqualFilter">
                <summary>
                Matches when the calculated layout is NOT equal to the specified substring.
                This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="conditions.html">conditions</a>.
                </summary>
            </member>
            <member name="M:NLog.Filters.WhenNotEqualFilter.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Filters.WhenNotEqualFilter" /> class.
                </summary>
            </member>
            <member name="P:NLog.Filters.WhenNotEqualFilter.CompareTo">
                <summary>
                Gets or sets a string to compare the layout to.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenNotEqualFilter.IgnoreCase">
                <summary>
                Gets or sets a value indicating whether to ignore case when comparing strings.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="M:NLog.Filters.WhenNotEqualFilter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="T:NLog.Filters.WhenRepeatedFilter">
                <summary>
                Matches when the result of the calculated layout has been repeated a moment ago
                </summary>
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.TimeoutSeconds">
                <summary>
                How long before a filter expires, and logging is accepted again
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.MaxLength">
                <summary>
                Max length of filter values, will truncate if above limit
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.IncludeFirst">
                <summary>
                Applies the configured action to the initial logevent that starts the timeout period.
                Used to configure that it should ignore all events until timeout.
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.MaxFilterCacheSize">
                <summary>
                Max number of unique filter values to expect simultaneously
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.DefaultFilterCacheSize">
                <summary>
                Default number of unique filter values to expect, will automatically increase if needed
                </summary>
                <docgen category='Filtering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.FilterCountPropertyName">
                <summary>
                Insert FilterCount value into <see cref="P:NLog.LogEventInfo.Properties"/> when an event is no longer filtered
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.FilterCountMessageAppendFormat">
                <summary>
                Append FilterCount to the <see cref="P:NLog.LogEventInfo.Message"/> when an event is no longer filtered
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.OptimizeBufferReuse">
                <summary>
                Reuse internal buffers, and doesn't have to constantly allocate new buffers
                </summary>
                <docgen category='Performance Options' order='10' />
            </member>
            <member name="P:NLog.Filters.WhenRepeatedFilter.OptimizeBufferDefaultLength">
                <summary>
                Default buffer size for the internal buffers
                </summary>
                <docgen category='Performance Options' order='10' />
            </member>
            <member name="F:NLog.Filters.WhenRepeatedFilter.ReusableLayoutBuilder">
                <summary>
                Can be used if <see cref="P:NLog.Filters.WhenRepeatedFilter.OptimizeBufferReuse"/> has been enabled.
                </summary>
            </member>
            <member name="M:NLog.Filters.WhenRepeatedFilter.#ctor">
                <summary>
                Constructor
                </summary>
            </member>
            <member name="M:NLog.Filters.WhenRepeatedFilter.Check(NLog.LogEventInfo)">
                <summary>
                Checks whether log event should be logged or not. In case the LogEvent has just been repeated.
                </summary>
                <param name="logEvent">Log event.</param>
                <returns>
                <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
                <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
                <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
                .</returns>
            </member>
            <member name="M:NLog.Filters.WhenRepeatedFilter.CreateFilterInfo(NLog.LogEventInfo)">
                <summary>
                Uses object pooling, and prunes stale filter items when the pool runs dry
                </summary>
            </member>
            <member name="M:NLog.Filters.WhenRepeatedFilter.PruneFilterCache(NLog.LogEventInfo,System.Int32)">
                <summary>
                Remove stale filter-value from the cache, and fill them into the pool for reuse
                </summary>
            </member>
            <member name="M:NLog.Filters.WhenRepeatedFilter.RenderFilterInfoKey(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the Log Event into a filter value, that is used for checking if just repeated
                </summary>
            </member>
            <member name="M:NLog.Filters.WhenRepeatedFilter.RefreshFilterInfo(NLog.LogEventInfo,NLog.Filters.WhenRepeatedFilter.FilterInfo)">
                <summary>
                Repeated LogEvent detected. Checks if it should activate filter-action
                </summary>
            </member>
            <member name="T:NLog.Filters.WhenRepeatedFilter.FilterInfo">
                <summary>
                Filter Value State (mutable)
                </summary>
            </member>
            <member name="T:NLog.Filters.WhenRepeatedFilter.FilterInfoKey">
                <summary>
                Filter Lookup Key (immutable)
                </summary>
            </member>
            <member name="T:NLog.Fluent.Log">
                <summary>
                A global logging class using caller info to find the logger.
                </summary>
            </member>
            <member name="M:NLog.Fluent.Log.Level(NLog.LogLevel,System.String)">
                <summary>
                Starts building a log event with the specified <see cref="T:NLog.LogLevel" />.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="M:NLog.Fluent.Log.Trace(System.String)">
                <summary>
                Starts building a log event at the <c>Trace</c> level.
                </summary>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="M:NLog.Fluent.Log.Debug(System.String)">
                <summary>
                Starts building a log event at the <c>Debug</c> level.
                </summary>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="M:NLog.Fluent.Log.Info(System.String)">
                <summary>
                Starts building a log event at the <c>Info</c> level.
                </summary>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="M:NLog.Fluent.Log.Warn(System.String)">
                <summary>
                Starts building a log event at the <c>Warn</c> level.
                </summary>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="M:NLog.Fluent.Log.Error(System.String)">
                <summary>
                Starts building a log event at the <c>Error</c> level.
                </summary>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="M:NLog.Fluent.Log.Fatal(System.String)">
                <summary>
                Starts building a log event at the <c>Fatal</c> level.
                </summary>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
                <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
            </member>
            <member name="T:NLog.Fluent.LogBuilder">
                <summary>
                A fluent class to build log events for NLog.
                </summary>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.#ctor(NLog.ILogger)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Fluent.LogBuilder"/> class.
                </summary>
                <param name="logger">The <see cref="T:NLog.Logger"/> to send the log event.</param>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.#ctor(NLog.ILogger,NLog.LogLevel)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Fluent.LogBuilder"/> class.
                </summary>
                <param name="logger">The <see cref="T:NLog.Logger"/> to send the log event.</param>
                <param name="logLevel">The <see cref="T:NLog.LogLevel"/> for the log event.</param>
            </member>
            <member name="P:NLog.Fluent.LogBuilder.LogEventInfo">
                <summary>
                Gets the <see cref="P:NLog.Fluent.LogBuilder.LogEventInfo"/> created by the builder.
                </summary>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Exception(System.Exception)">
                <summary>
                Sets the <paramref name="exception"/> information of the logging event.
                </summary>
                <param name="exception">The exception information of the logging event.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Level(NLog.LogLevel)">
                <summary>
                Sets the level of the logging event.
                </summary>
                <param name="logLevel">The level of the logging event.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.LoggerName(System.String)">
                <summary>
                Sets the logger name of the logging event.
                </summary>
                <param name="loggerName">The logger name of the logging event.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.String)">
                <summary>
                Sets the log message on the logging event.
                </summary>
                <param name="message">The log message for the logging event.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object)">
                <summary>
                Sets the log message and parameters for formatting on the logging event.
                </summary>
                <param name="format">A composite format string.</param>
                <param name="arg0">The object to format.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object,System.Object)">
                <summary>
                Sets the log message and parameters for formatting on the logging event.
                </summary>
                <param name="format">A composite format string.</param>
                <param name="arg0">The first object to format.</param>
                <param name="arg1">The second object to format.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Sets the log message and parameters for formatting on the logging event.
                </summary>
                <param name="format">A composite format string.</param>
                <param name="arg0">The first object to format.</param>
                <param name="arg1">The second object to format.</param>
                <param name="arg2">The third object to format.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object,System.Object,System.Object,System.Object)">
                <summary>
                Sets the log message and parameters for formatting on the logging event.
                </summary>
                <param name="format">A composite format string.</param>
                <param name="arg0">The first object to format.</param>
                <param name="arg1">The second object to format.</param>
                <param name="arg2">The third object to format.</param>
                <param name="arg3">The fourth object to format.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object[])">
                <summary>
                Sets the log message and parameters for formatting on the logging event.
                </summary>
                <param name="format">A composite format string.</param>
                <param name="args">An object array that contains zero or more objects to format.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Message(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Sets the log message and parameters for formatting on the logging event.
                </summary>
                <param name="provider">An object that supplies culture-specific formatting information.</param>
                <param name="format">A composite format string.</param>
                <param name="args">An object array that contains zero or more objects to format.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Property(System.Object,System.Object)">
                <summary>
                Sets a per-event context property on the logging event.
                </summary>
                <param name="name">The name of the context property.</param>
                <param name="value">The value of the context property.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Properties(System.Collections.IDictionary)">
                <summary>
                Sets multiple per-event context properties on the logging event.
                </summary>
                <param name="properties">The properties to set.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.TimeStamp(System.DateTime)">
                <summary>
                Sets the timestamp of the logging event.
                </summary>
                <param name="timeStamp">The timestamp of the logging event.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.StackTrace(System.Diagnostics.StackTrace,System.Int32)">
                <summary>
                Sets the stack trace for the event info.
                </summary>
                <param name="stackTrace">The stack trace.</param>
                <param name="userStackFrame">Index of the first user stack frame within the stack trace.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.Write(System.String,System.String,System.Int32)">
                <summary>
                Writes the log event to the underlying logger.
                </summary>
                <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
                <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.WriteIf(System.Func{System.Boolean},System.String,System.String,System.Int32)">
                <summary>
                Writes the log event to the underlying logger if the condition delegate is true.
                </summary>
                <param name="condition">If condition is true, write log event; otherwise ignore event.</param>
                <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
                <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
            </member>
            <member name="M:NLog.Fluent.LogBuilder.WriteIf(System.Boolean,System.String,System.String,System.Int32)">
                <summary>
                Writes the log event to the underlying logger if the condition is true.
                </summary>
                <param name="condition">If condition is true, write log event; otherwise ignore event.</param>
                <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
                <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
                <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
            </member>
            <member name="T:NLog.Fluent.LoggerExtensions">
                <summary>
                Extension methods for NLog <see cref="T:NLog.Logger"/>.
                </summary>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Log(NLog.ILogger,NLog.LogLevel)">
                <summary>
                Starts building a log event with the specified <see cref="T:NLog.LogLevel"/>.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <param name="logLevel">The log level.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Trace(NLog.ILogger)">
                <summary>
                Starts building a log event at the <c>Trace</c> level.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Debug(NLog.ILogger)">
                <summary>
                Starts building a log event at the <c>Debug</c> level.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Info(NLog.ILogger)">
                <summary>
                Starts building a log event at the <c>Info</c> level.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Warn(NLog.ILogger)">
                <summary>
                Starts building a log event at the <c>Warn</c> level.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Error(NLog.ILogger)">
                <summary>
                Starts building a log event at the <c>Error</c> level.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="M:NLog.Fluent.LoggerExtensions.Fatal(NLog.ILogger)">
                <summary>
                Starts building a log event at the <c>Fatal</c> level.
                </summary>
                <param name="logger">The logger to write the log event to.</param>
                <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
            </member>
            <member name="T:NLog.GDC">
                <summary>
                Global Diagnostics Context - used for log4net compatibility.
                </summary>
                <remarks>This class was marked as obsolete on NLog 2.0 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.GDC.Set(System.String,System.String)">
                <summary>
                Sets the Global Diagnostics Context item to the specified value.
                </summary>
                <param name="item">Item name.</param>
                <param name="value">Item value.</param>
            </member>
            <member name="M:NLog.GDC.Get(System.String)">
                <summary>
                Gets the Global Diagnostics Context named item.
                </summary>
                <param name="item">Item name.</param>
                <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
                <remarks>If the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
            </member>
            <member name="M:NLog.GDC.Get(System.String,System.IFormatProvider)">
                <summary>
                Gets the Global Diagnostics Context item.
                </summary>
                <param name="item">Item name.</param>
                <param name="formatProvider"><see cref="T:System.IFormatProvider"/> to use when converting the item's value to a string.</param>
                <returns>The value of <paramref name="item"/> as a string, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
                <remarks>If <paramref name="formatProvider"/> is <c>null</c> and the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
            </member>
            <member name="M:NLog.GDC.GetObject(System.String)">
                <summary>
                Gets the Global Diagnostics Context named item.
                </summary>
                <param name="item">Item name.</param>
                <returns>The value of <paramref name="item"/>, if defined; otherwise <c>null</c>.</returns>
            </member>
            <member name="M:NLog.GDC.Contains(System.String)">
                <summary>
                Checks whether the specified item exists in the Global Diagnostics Context.
                </summary>
                <param name="item">Item name.</param>
                <returns>A boolean indicating whether the specified item exists in current thread GDC.</returns>
            </member>
            <member name="M:NLog.GDC.Remove(System.String)">
                <summary>
                Removes the specified item from the Global Diagnostics Context.
                </summary>
                <param name="item">Item name.</param>
            </member>
            <member name="M:NLog.GDC.Clear">
                <summary>
                Clears the content of the GDC.
                </summary>
            </member>
            <member name="T:NLog.GlobalDiagnosticsContext">
                <summary>
                Global Diagnostics Context - a dictionary structure to hold per-application-instance values.
                </summary>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Set(System.String,System.String)">
                <summary>
                Sets the Global Diagnostics Context item to the specified value.
                </summary>
                <param name="item">Item name.</param>
                <param name="value">Item value.</param>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Set(System.String,System.Object)">
                <summary>
                Sets the Global Diagnostics Context item to the specified value.
                </summary>
                <param name="item">Item name.</param>
                <param name="value">Item value.</param>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Get(System.String)">
                <summary>
                Gets the Global Diagnostics Context named item.
                </summary>
                <param name="item">Item name.</param>
                <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
                <remarks>If the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Get(System.String,System.IFormatProvider)">
                <summary>
                Gets the Global Diagnostics Context item.
                </summary>
                <param name="item">Item name.</param>
                <param name="formatProvider"><see cref="T:System.IFormatProvider"/> to use when converting the item's value to a string.</param>
                <returns>The value of <paramref name="item"/> as a string, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
                <remarks>If <paramref name="formatProvider"/> is <c>null</c> and the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.GetObject(System.String)">
                <summary>
                Gets the Global Diagnostics Context named item.
                </summary>
                <param name="item">Item name.</param>
                <returns>The item value, if defined; otherwise <c>null</c>.</returns>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.GetNames">
                <summary>
                Returns all item names
                </summary>
                <returns>A collection of the names of all items in the Global Diagnostics Context.</returns>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Contains(System.String)">
                <summary>
                Checks whether the specified item exists in the Global Diagnostics Context.
                </summary>
                <param name="item">Item name.</param>
                <returns>A boolean indicating whether the specified item exists in current thread GDC.</returns>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Remove(System.String)">
                <summary>
                Removes the specified item from the Global Diagnostics Context.
                </summary>
                <param name="item">Item name.</param>
            </member>
            <member name="M:NLog.GlobalDiagnosticsContext.Clear">
                <summary>
                Clears the content of the GDC.
                </summary>
            </member>
            <member name="T:NLog.IIncludeContext">
                <summary>
                Include context properties
                </summary>
            </member>
            <member name="P:NLog.IIncludeContext.IncludeMdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.IIncludeContext.IncludeNdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsContext"/> stack.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.IIncludeContext.IncludeAllProperties">
                <summary>
                Gets or sets the option to include all properties from the log events
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.IIncludeContext.IncludeMdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.IIncludeContext.IncludeNdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> stack.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="T:NLog.IJsonConverter">
                <summary>
                Interface for serialization of object values into JSON format
                </summary>
            </member>
            <member name="M:NLog.IJsonConverter.SerializeObject(System.Object,System.Text.StringBuilder)">
                <summary>
                Serialization of an object into JSON format.
                </summary>
                <param name="value">The object to serialize to JSON.</param>
                <param name="builder">Output destination.</param>
                <returns>Serialize succeeded (true/false)</returns>
            </member>
            <member name="T:NLog.ILogger">
                <content>
                Auto-generated Logger members for binary compatibility with NLog 1.0.
                </content>
                <summary>
                Provides logging interface and utility functions.
                </summary>
            </member>
            <member name="M:NLog.ILogger.Trace(System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level.
                </summary>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>s
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level.
                </summary>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level.
                </summary>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level.
                </summary>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level.
                </summary>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level.
                </summary>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.String)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
                </summary>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="P:NLog.ILogger.IsTraceEnabled">
                <summary>
                Gets a value indicating whether logging is enabled for the <c>Trace</c> level.
                </summary>
                <returns>A value of <see langword="true" /> if logging is enabled for the <c>Trace</c> level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="P:NLog.ILogger.IsDebugEnabled">
                <summary>
                Gets a value indicating whether logging is enabled for the <c>Debug</c> level.
                </summary>
                <returns>A value of <see langword="true" /> if logging is enabled for the <c>Debug</c> level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="P:NLog.ILogger.IsInfoEnabled">
                <summary>
                Gets a value indicating whether logging is enabled for the <c>Info</c> level.
                </summary>
                <returns>A value of <see langword="true" /> if logging is enabled for the <c>Info</c> level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="P:NLog.ILogger.IsWarnEnabled">
                <summary>
                Gets a value indicating whether logging is enabled for the <c>Warn</c> level.
                </summary>
                <returns>A value of <see langword="true" /> if logging is enabled for the <c>Warn</c> level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="P:NLog.ILogger.IsErrorEnabled">
                <summary>
                Gets a value indicating whether logging is enabled for the <c>Error</c> level.
                </summary>
                <returns>A value of <see langword="true" /> if logging is enabled for the <c>Error</c> level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="P:NLog.ILogger.IsFatalEnabled">
                <summary>
                Gets a value indicating whether logging is enabled for the <c>Fatal</c> level.
                </summary>
                <returns>A value of <see langword="true" /> if logging is enabled for the <c>Fatal</c> level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="M:NLog.ILogger.Trace``1(``0)">
                <overloads>
                Writes the diagnostic message at the <c>Trace</c> level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Trace``1(System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level.
                </summary>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILogger.TraceException(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Trace</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Trace(System.Exception,System.String)">
                <summary>
                Writes the diagnostic message and exception at the <c>Trace</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Trace</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Trace</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Trace</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Trace``1(System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace``1(System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace``2(System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace``2(System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace``3(System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Trace``3(System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``1(``0)">
                <overloads>
                Writes the diagnostic message at the <c>Debug</c> level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``1(System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level.
                </summary>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILogger.DebugException(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Debug</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Debug(System.Exception,System.String)">
                <summary>
                Writes the diagnostic message and exception at the <c>Debug</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Debug</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Debug</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Debug</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Debug``1(System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``1(System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``2(System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``2(System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``3(System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Debug``3(System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info``1(``0)">
                <overloads>
                Writes the diagnostic message at the <c>Info</c> level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the <c>Info</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Info``1(System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Info(NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level.
                </summary>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILogger.InfoException(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Info</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Info(System.Exception,System.String)">
                <summary>
                Writes the diagnostic message and exception at the <c>Info</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Info</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Info</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Info</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Info``1(System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info``1(System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info``2(System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info``2(System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info``3(System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Info``3(System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``1(``0)">
                <overloads>
                Writes the diagnostic message at the <c>Warn</c> level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``1(System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level.
                </summary>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILogger.WarnException(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Warn</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Warn(System.Exception,System.String)">
                <summary>
                Writes the diagnostic message and exception at the <c>Warn</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Warn</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Warn</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Warn</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Warn``1(System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``1(System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``2(System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``2(System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``3(System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Warn``3(System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error``1(``0)">
                <overloads>
                Writes the diagnostic message at the <c>Error</c> level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the <c>Error</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Error``1(System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Error(NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level.
                </summary>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILogger.ErrorException(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Error</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Error(System.Exception,System.String)">
                <summary>
                Writes the diagnostic message and exception at the <c>Error</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Error</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Error</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Error</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Error``1(System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error``1(System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error``2(System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error``2(System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error``3(System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Error``3(System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``1(``0)">
                <overloads>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``1(System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level.
                </summary>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILogger.FatalException(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Fatal</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.Exception,System.String)">
                <summary>
                Writes the diagnostic message and exception at the <c>Fatal</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Fatal</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the <c>Fatal</c> level.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level.
                </summary>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
                </summary>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal(System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the <c>Fatal</c> level.
                </summary>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILogger.Fatal``1(System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``1(System.String,``0)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``2(System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``2(System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``3(System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILogger.Fatal``3(System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="T:NLog.ILoggerBase">
                <content>
                Auto-generated Logger members for binary compatibility with NLog 1.0.
                </content>
                <summary>
                Logger with only generic methods (passing 'LogLevel' to methods) and core properties.
                </summary>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Object)">
                <summary>
                Writes the diagnostic message at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.Object)">
                <summary>
                Writes the diagnostic message at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">A <see langword="object" /> to be written.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameters.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object,System.Object,System.Object)">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameters.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="arg1">First argument to format.</param>
                <param name="arg2">Second argument to format.</param>
                <param name="arg3">Third argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Boolean)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Char)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Byte)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.String)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Int32)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Int64)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Single)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Double)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Decimal)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.SByte)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>    
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>        
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.UInt32)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.UInt64)">
                <summary>
                Writes the diagnostic message at the specified level using the specified value as a parameter.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="E:NLog.ILoggerBase.LoggerReconfigured">
                <summary>
                Occurs when logger configuration changes.
                </summary>
            </member>
            <member name="P:NLog.ILoggerBase.Name">
                <summary>
                Gets the name of the logger.
                </summary>
            </member>
            <member name="P:NLog.ILoggerBase.Factory">
                <summary>
                Gets the factory that created this logger.
                </summary>
            </member>
            <member name="M:NLog.ILoggerBase.IsEnabled(NLog.LogLevel)">
                <summary>
                Gets a value indicating whether logging is enabled for the specified level.
                </summary>
                <param name="level">Log level to be checked.</param>
                <returns>A value of <see langword="true" /> if logging is enabled for the specified level, otherwise it returns <see langword="false" />.</returns>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogEventInfo)">
                <summary>
                Writes the specified diagnostic message.
                </summary>
                <param name="logEvent">Log event.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(System.Type,NLog.LogEventInfo)">
                <summary>
                Writes the specified diagnostic message.
                </summary>
                <param name="wrapperType">The name of the type that wraps Logger.</param>
                <param name="logEvent">Log event.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,``0)">
                <overloads>
                Writes the diagnostic message at the specified level using the specified format provider and format parameters.
                </overloads>
                <summary>
                Writes the diagnostic message at the specified level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="level">The log level.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,System.IFormatProvider,``0)">
                <summary>
                Writes the diagnostic message at the specified level.
                </summary>
                <typeparam name="T">Type of the value.</typeparam>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="value">The value to be written.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerBase.LogException(NLog.LogLevel,System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Exception,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="args">Arguments to format.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message and exception at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="args">Arguments to format.</param>
                <param name="exception">An exception to be logged.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameters and formatting them with the supplied format provider.
                </summary>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String)">
                <summary>
                Writes the diagnostic message at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">Log message.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object[])">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameters.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing format items.</param>
                <param name="args">Arguments to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Exception)">
                <summary>
                Writes the diagnostic message and exception at the specified level.
                </summary>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> to be written.</param>
                <param name="exception">An exception to be logged.</param>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,System.IFormatProvider,System.String,``0)">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameter and formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,System.String,``0)">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameter.
                </summary>
                <typeparam name="TArgument">The type of the argument.</typeparam>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument">The argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``2(NLog.LogLevel,System.IFormatProvider,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the specified level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``2(NLog.LogLevel,System.String,``0,``1)">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``3(NLog.LogLevel,System.IFormatProvider,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the specified level using the specified arguments formatting it with the supplied format provider.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="level">The log level.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="M:NLog.ILoggerBase.Log``3(NLog.LogLevel,System.String,``0,``1,``2)">
                <summary>
                Writes the diagnostic message at the specified level using the specified parameters.
                </summary>
                <typeparam name="TArgument1">The type of the first argument.</typeparam>
                <typeparam name="TArgument2">The type of the second argument.</typeparam>
                <typeparam name="TArgument3">The type of the third argument.</typeparam>
                <param name="level">The log level.</param>
                <param name="message">A <see langword="string" /> containing one format item.</param>
                <param name="argument1">The first argument to format.</param>
                <param name="argument2">The second argument to format.</param>
                <param name="argument3">The third argument to format.</param>
            </member>
            <member name="T:NLog.ILoggerExtensions">
                <summary>
                Extensions for NLog <see cref="T:NLog.ILogger"/>.
                </summary>
            </member>
            <member name="M:NLog.ILoggerExtensions.Log(NLog.ILogger,NLog.LogLevel,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the specified level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="level">The log level.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerExtensions.Trace(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the <c>Trace</c> level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerExtensions.Debug(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the <c>Debug</c> level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerExtensions.Info(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the <c>Info</c> level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerExtensions.Warn(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the <c>Warn</c> level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerExtensions.Error(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the <c>Error</c> level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="M:NLog.ILoggerExtensions.Fatal(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
                <summary>
                Writes the diagnostic message and exception at the <c>Fatal</c> level.
                </summary>
                <param name="logger">A logger implementation that will handle the message.</param>
                <param name="exception">An exception to be logged.</param>
                <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
            </member>
            <member name="T:NLog.Internal.AppendBuilderCreator">
                <summary>
                Allocates new builder and appends to the provided target builder on dispose
                </summary>
            </member>
            <member name="P:NLog.Internal.AppendBuilderCreator.Builder">
                <summary>
                Access the new builder allocated
                </summary>
            </member>
            <member name="T:NLog.Internal.AssemblyHelpers">
                <summary>
                Helpers for <see cref="T:System.Reflection.Assembly"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.AssemblyHelpers.LoadFromPath(System.String,System.String)">
                <summary>
                Load from url
                </summary>
                <param name="assemblyFileName">file or path, including .dll</param>
                <param name="baseDirectory">basepath, optional</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.AssemblyHelpers.LoadFromName(System.String)">
                <summary>
                Load from url
                </summary>
                <param name="assemblyName">name without .dll</param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.AsyncOperationCounter">
                <summary>
                Keeps track of pending operation count, and can notify when pending operation count reaches zero
                </summary>
            </member>
            <member name="M:NLog.Internal.AsyncOperationCounter.BeginOperation">
                <summary>
                Mark operation has started
                </summary>
            </member>
            <member name="M:NLog.Internal.AsyncOperationCounter.CompleteOperation(System.Exception)">
                <summary>
                Mark operation has completed
                </summary>
                <param name="exception">Exception coming from the completed operation [optional]</param>
            </member>
            <member name="M:NLog.Internal.AsyncOperationCounter.RegisterCompletionNotification(NLog.Common.AsyncContinuation)">
                <summary>
                Registers an AsyncContinuation to be called when all pending operations have completed
                </summary>
                <param name="asyncContinuation">Invoked on completion</param>
                <returns>AsyncContinuation operation</returns>
            </member>
            <member name="M:NLog.Internal.AsyncOperationCounter.Clear">
                <summary>
                Clear o
                </summary>
            </member>
            <member name="M:NLog.Internal.CallSiteInformation.SetStackTrace(System.Diagnostics.StackTrace,System.Int32,System.Nullable{System.Int32})">
                <summary>
                Sets the stack trace for the event info.
                </summary>
                <param name="stackTrace">The stack trace.</param>
                <param name="userStackFrame">Index of the first user stack frame within the stack trace.</param>
                <param name="userStackFrameLegacy">Index of the first user stack frame within the stack trace.</param>
            </member>
            <member name="M:NLog.Internal.CallSiteInformation.SetCallerInfo(System.String,System.String,System.String,System.Int32)">
                <summary>
                Sets the details retrieved from the Caller Information Attributes
                </summary>
                <param name="callerClassName"></param>
                <param name="callerMemberName"></param>
                <param name="callerFilePath"></param>
                <param name="callerLineNumber"></param>
            </member>
            <member name="P:NLog.Internal.CallSiteInformation.UserStackFrame">
                <summary>
                Gets the stack frame of the method that did the logging.
                </summary>
            </member>
            <member name="P:NLog.Internal.CallSiteInformation.UserStackFrameNumber">
                <summary>
                Gets the number index of the stack frame that represents the user
                code (not the NLog code).
                </summary>
            </member>
            <member name="P:NLog.Internal.CallSiteInformation.UserStackFrameNumberLegacy">
                <summary>
                Legacy attempt to skip async MoveNext, but caused source file line number to be lost
                </summary>
            </member>
            <member name="P:NLog.Internal.CallSiteInformation.StackTrace">
                <summary>
                Gets the entire stack trace.
                </summary>
            </member>
            <member name="T:NLog.Internal.ConfigurationManager">
                <summary>
                Internal configuration manager used to read .NET configuration files.
                Just a wrapper around the BCL ConfigurationManager, but used to enable
                unit testing.
                </summary>
            </member>
            <member name="P:NLog.Internal.ConfigurationManager.AppSettings">
                <summary>
                Gets the wrapper around ConfigurationManager.AppSettings.
                </summary>
            </member>
            <member name="T:NLog.Internal.DictionaryAdapter`2">
                <summary>
                Provides untyped IDictionary interface on top of generic IDictionary.
                </summary>
                <typeparam name="TKey">The type of the key.</typeparam>
                <typeparam name="TValue">The type of the value.</typeparam>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.#ctor(System.Collections.Generic.IDictionary{`0,`1})">
                <summary>
                Initializes a new instance of the DictionaryAdapter class.
                </summary>
                <param name="implementation">The implementation.</param>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.Values">
                <summary>
                Gets an <see cref="T:System.Collections.ICollection"/> object containing the values in the <see cref="T:System.Collections.IDictionary"/> object.
                </summary>
                <value></value>
                <returns>
                An <see cref="T:System.Collections.ICollection"/> object containing the values in the <see cref="T:System.Collections.IDictionary"/> object.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.Count">
                <summary>
                Gets the number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
                </summary>
                <value></value>
                <returns>
                The number of elements contained in the <see cref="T:System.Collections.ICollection"/>.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.IsSynchronized">
                <summary>
                Gets a value indicating whether access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread safe).
                </summary>
                <value></value>
                <returns>true if access to the <see cref="T:System.Collections.ICollection"/> is synchronized (thread safe); otherwise, false.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.SyncRoot">
                <summary>
                Gets an object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
                </summary>
                <value></value>
                <returns>
                An object that can be used to synchronize access to the <see cref="T:System.Collections.ICollection"/>.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.IsFixedSize">
                <summary>
                Gets a value indicating whether the <see cref="T:System.Collections.IDictionary"/> object has a fixed size.
                </summary>
                <value></value>
                <returns>true if the <see cref="T:System.Collections.IDictionary"/> object has a fixed size; otherwise, false.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.IsReadOnly">
                <summary>
                Gets a value indicating whether the <see cref="T:System.Collections.IDictionary"/> object is read-only.
                </summary>
                <value></value>
                <returns>true if the <see cref="T:System.Collections.IDictionary"/> object is read-only; otherwise, false.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.Keys">
                <summary>
                Gets an <see cref="T:System.Collections.ICollection"/> object containing the keys of the <see cref="T:System.Collections.IDictionary"/> object.
                </summary>
                <value></value>
                <returns>
                An <see cref="T:System.Collections.ICollection"/> object containing the keys of the <see cref="T:System.Collections.IDictionary"/> object.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.Item(System.Object)">
                <summary>
                Gets or sets the <see cref="T:System.Object"/> with the specified key.
                </summary>
                <param name="key">Dictionary key.</param>
                <returns>Value corresponding to key or null if not found</returns>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.Add(System.Object,System.Object)">
                <summary>
                Adds an element with the provided key and value to the <see cref="T:System.Collections.IDictionary"/> object.
                </summary>
                <param name="key">The <see cref="T:System.Object"/> to use as the key of the element to add.</param>
                <param name="value">The <see cref="T:System.Object"/> to use as the value of the element to add.</param>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.Clear">
                <summary>
                Removes all elements from the <see cref="T:System.Collections.IDictionary"/> object.
                </summary>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.Contains(System.Object)">
                <summary>
                Determines whether the <see cref="T:System.Collections.IDictionary"/> object contains an element with the specified key.
                </summary>
                <param name="key">The key to locate in the <see cref="T:System.Collections.IDictionary"/> object.</param>
                <returns>
                True if the <see cref="T:System.Collections.IDictionary"/> contains an element with the key; otherwise, false.
                </returns>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.GetEnumerator">
                <summary>
                Returns an <see cref="T:System.Collections.IDictionaryEnumerator"/> object for the <see cref="T:System.Collections.IDictionary"/> object.
                </summary>
                <returns>
                An <see cref="T:System.Collections.IDictionaryEnumerator"/> object for the <see cref="T:System.Collections.IDictionary"/> object.
                </returns>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.Remove(System.Object)">
                <summary>
                Removes the element with the specified key from the <see cref="T:System.Collections.IDictionary"/> object.
                </summary>
                <param name="key">The key of the element to remove.</param>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.CopyTo(System.Array,System.Int32)">
                <summary>
                Copies the elements of the <see cref="T:System.Collections.ICollection"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index.
                </summary>
                <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.ICollection"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param>
                <param name="index">The zero-based index in <paramref name="array"/> at which copying begins.</param>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.System#Collections#IEnumerable#GetEnumerator">
                <summary>
                Returns an enumerator that iterates through a collection.
                </summary>
                <returns>
                An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
                </returns>
            </member>
            <member name="T:NLog.Internal.DictionaryAdapter`2.MyEnumerator">
                <summary>
                Wrapper IDictionaryEnumerator.
                </summary>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.MyEnumerator.#ctor(System.Collections.Generic.IEnumerator{System.Collections.Generic.KeyValuePair{`0,`1}})">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.DictionaryAdapter`2.MyEnumerator" /> class.
                </summary>
                <param name="wrapped">The wrapped.</param>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.MyEnumerator.Entry">
                <summary>
                Gets both the key and the value of the current dictionary entry.
                </summary>
                <value></value>
                <returns>
                A <see cref="T:System.Collections.DictionaryEntry"/> containing both the key and the value of the current dictionary entry.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.MyEnumerator.Key">
                <summary>
                Gets the key of the current dictionary entry.
                </summary>
                <value></value>
                <returns>
                The key of the current element of the enumeration.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.MyEnumerator.Value">
                <summary>
                Gets the value of the current dictionary entry.
                </summary>
                <value></value>
                <returns>
                The value of the current element of the enumeration.
                </returns>
            </member>
            <member name="P:NLog.Internal.DictionaryAdapter`2.MyEnumerator.Current">
                <summary>
                Gets the current element in the collection.
                </summary>
                <value></value>
                <returns>
                The current element in the collection.
                </returns>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.MyEnumerator.MoveNext">
                <summary>
                Advances the enumerator to the next element of the collection.
                </summary>
                <returns>
                True if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the collection.
                </returns>
            </member>
            <member name="M:NLog.Internal.DictionaryAdapter`2.MyEnumerator.Reset">
                <summary>
                Sets the enumerator to its initial position, which is before the first element in the collection.
                </summary>
            </member>
            <member name="T:NLog.Internal.DictionaryEntryEnumerable">
                <summary>
                Ensures that IDictionary.GetEnumerator returns DictionaryEntry values
                </summary>
            </member>
            <member name="F:NLog.Internal.EncodingHelpers.Utf8BOM">
                <summary>
                UTF-8 BOM 239, 187, 191
                </summary>
            </member>
            <member name="T:NLog.Internal.EnvironmentHelper">
                <summary>
                Safe way to get environment variables.
                </summary>
            </member>
            <member name="T:NLog.Internal.ExceptionHelper">
                <summary>
                Helper class for dealing with exceptions.
                </summary>
            </member>
            <member name="M:NLog.Internal.ExceptionHelper.MarkAsLoggedToInternalLogger(System.Exception)">
                <summary>
                Mark this exception as logged to the <see cref="T:NLog.Common.InternalLogger"/>.
                </summary>
                <param name="exception"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.ExceptionHelper.IsLoggedToInternalLogger(System.Exception)">
                <summary>
                Is this exception logged to the <see cref="T:NLog.Common.InternalLogger"/>? 
                </summary>
                <param name="exception"></param>
                <returns><c>true</c>if the <paramref name="exception"/> has been logged to the <see cref="T:NLog.Common.InternalLogger"/>.</returns>
            </member>
            <member name="M:NLog.Internal.ExceptionHelper.MustBeRethrown(System.Exception)">
                <summary>
                Determines whether the exception must be rethrown and logs the error to the <see cref="T:NLog.Common.InternalLogger"/> if <see cref="M:NLog.Internal.ExceptionHelper.IsLoggedToInternalLogger(System.Exception)"/> is <c>false</c>.
                
                Advised to log first the error to the <see cref="T:NLog.Common.InternalLogger"/> before calling this method.
                </summary>
                <param name="exception">The exception to check.</param>
                <returns><c>true</c>if the <paramref name="exception"/> must be rethrown, <c>false</c> otherwise.</returns>
            </member>
            <member name="M:NLog.Internal.ExceptionHelper.MustBeRethrownImmediately(System.Exception)">
                <summary>
                Determines whether the exception must be rethrown immediately, without logging the error to the <see cref="T:NLog.Common.InternalLogger"/>.
                
                Only used this method in special cases.
                </summary>
                <param name="exception">The exception to check.</param>
                <returns><c>true</c>if the <paramref name="exception"/> must be rethrown, <c>false</c> otherwise.</returns>
            </member>
            <member name="T:NLog.Internal.FactoryHelper">
                <summary>
                Object construction helper.
                </summary>
            </member>
            <member name="T:NLog.Internal.Fakeables.AppDomainWrapper">
                <summary>
                Adapter for <see cref="T:System.AppDomain"/> to <see cref="T:NLog.Internal.Fakeables.IAppDomain"/>
                </summary>
            </member>
            <member name="M:NLog.Internal.Fakeables.AppDomainWrapper.#ctor(System.AppDomain)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.Fakeables.AppDomainWrapper"/> class.
                </summary>
                <param name="appDomain">The <see cref="T:System.AppDomain"/> to wrap.</param>
            </member>
            <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.CurrentDomain">
                <summary>
                Creates an AppDomainWrapper for the current <see cref="T:System.AppDomain"/>
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.BaseDirectory">
                <summary>
                Gets or sets the base directory that the assembly resolver uses to probe for assemblies.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.ConfigurationFile">
                <summary>
                Gets or sets the name of the configuration file for an application domain.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.PrivateBinPath">
                <summary>
                Gets or sets the list of directories under the application base directory that are probed for private assemblies.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.FriendlyName">
                <summary>
                Gets or set the friendly name.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.Id">
                <summary>
                Gets an integer that uniquely identifies the application domain within the process. 
                </summary>
            </member>
            <member name="M:NLog.Internal.Fakeables.AppDomainWrapper.GetAssemblies">
                <summary>
                Gets the assemblies that have been loaded into the execution context of this application domain.
                </summary>
                <returns>A list of assemblies in this application domain.</returns>
            </member>
            <member name="E:NLog.Internal.Fakeables.AppDomainWrapper.ProcessExit">
                <summary>
                Process exit event.
                </summary>
            </member>
            <member name="E:NLog.Internal.Fakeables.AppDomainWrapper.DomainUnload">
                <summary>
                Domain unloaded event.
                </summary>
            </member>
            <member name="M:NLog.Internal.Fakeables.FileWrapper.Exists(System.String)">
                <inheritdoc />
            </member>
            <member name="T:NLog.Internal.Fakeables.IAppDomain">
                <summary>
                Interface for fakeable the current <see cref="P:NLog.LogFactory.CurrentAppDomain"/>. Not fully implemented, please methods/properties as necessary.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.IAppDomain.BaseDirectory">
                <summary>
                Gets or sets the base directory that the assembly resolver uses to probe for assemblies.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.IAppDomain.ConfigurationFile">
                <summary>
                Gets or sets the name of the configuration file for an application domain.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.IAppDomain.PrivateBinPath">
                <summary>
                Gets or sets the list of directories under the application base directory that are probed for private assemblies.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.IAppDomain.FriendlyName">
                <summary>
                Gets or set the friendly name.
                </summary>
            </member>
            <member name="P:NLog.Internal.Fakeables.IAppDomain.Id">
                <summary>
                Gets an integer that uniquely identifies the application domain within the process. 
                </summary>
            </member>
            <member name="M:NLog.Internal.Fakeables.IAppDomain.GetAssemblies">
                <summary>
                Gets the assemblies that have been loaded into the execution context of this application domain.
                </summary>
                <returns>A list of assemblies in this application domain.</returns>
            </member>
            <member name="E:NLog.Internal.Fakeables.IAppDomain.ProcessExit">
                <summary>
                Process exit event.
                </summary>
            </member>
            <member name="E:NLog.Internal.Fakeables.IAppDomain.DomainUnload">
                <summary>
                Domain unloaded event.
                </summary>
            </member>
            <member name="T:NLog.Internal.Fakeables.IFile">
                <summary>
                Abstract calls to File
                </summary>
            </member>
            <member name="M:NLog.Internal.Fakeables.IFile.Exists(System.String)">
                <summary>Determines whether the specified file exists.</summary>
                <param name="path">The file to check. </param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.BaseFileAppender">
                <summary>
                Base class for optimized file appenders.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="createParameters">The create parameters.</param>
            </member>
            <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.FileName">
                <summary>
                Gets the path of the file, including file extension.
                </summary>
                <value>The name of the file.</value>
            </member>
            <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.CreationTimeUtc">
                <summary>
                Gets or sets the creation time for a file associated with the appender. The time returned is in Coordinated  
                Universal Time [UTC] standard.
                </summary>
                <returns>The creation time of the file.</returns>
            </member>
            <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.CreationTimeSource">
                <summary>
                Gets or sets the creation time for a file associated with the appender. Synchronized by <see cref="P:NLog.Internal.FileAppenders.BaseFileAppender.CreationTimeUtc"/>
                The time format is based on <see cref="T:NLog.Time.TimeSource" />
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.OpenTimeUtc">
                <summary>
                Gets the last time the file associated with the appeander is opened. The time returned is in Coordinated 
                Universal Time [UTC] standard.
                </summary>
                <returns>The time the file was last opened.</returns>
            </member>
            <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.CreateFileParameters">
                <summary>
                Gets the file creation parameters.
                </summary>
                <value>The file creation parameters.</value>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Write(System.Byte[])">
                <summary>
                Writes the specified bytes.
                </summary>
                <param name="bytes">The bytes.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Flush">
                <summary>
                Flushes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.GetFileCreationTimeUtc">
                <summary>
                Gets the creation time for a file associated with the appender. The time returned is in Coordinated Universal 
                Time [UTC] standard.
                </summary>
                <returns>The file creation time.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.GetFileLength">
                <summary>
                Gets the length in bytes of the file associated with the appeander.
                </summary>
                <returns>A long value representing the length of the file in bytes.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Dispose(System.Boolean)">
                <summary>
                Releases unmanaged and - optionally - managed resources.
                </summary>
                <param name="disposing">True to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.CreateFileStream(System.Boolean)">
                <summary>
                Creates the file stream.
                </summary>
                <param name="allowFileSharedWriting">If set to <c>true</c> sets the file stream to allow shared writing.</param>
                <returns>A <see cref="T:System.IO.FileStream"/> object which can be used to write to the file.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.BaseMutexFileAppender">
                <summary>
                Base class for optimized file appenders which require the usage of a mutex. 
                
                It is possible to use this class as replacement of BaseFileAppender and the mutex functionality 
                is not enforced to the implementing subclasses.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseMutexFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.BaseMutexFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="createParameters">The create parameters.</param>
            </member>
            <member name="P:NLog.Internal.FileAppenders.BaseMutexFileAppender.ArchiveMutex">
                <summary>
                Gets the mutually-exclusive lock for archiving files.
                </summary>
                <value>The mutex for archiving.</value>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseMutexFileAppender.Dispose(System.Boolean)">
                <summary>
                Releases unmanaged and - optionally - managed resources.
                </summary>
                <param name="disposing">True to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.BaseMutexFileAppender.CreateSharableMutex(System.String)">
                <summary>
                Creates a mutex that is sharable by more than one process.
                </summary>
                <param name="mutexNamePrefix">The prefix to use for the name of the mutex.</param>
                <returns>A <see cref="T:System.Threading.Mutex"/> object which is sharable by multiple processes.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender">
                <summary>
                Implementation of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which caches 
                file information.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">The parameters.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Close">
                <summary>
                Closes this instance of the appender.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Flush">
                <summary>
                Flushes this current appender.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.GetFileCreationTimeUtc">
                <summary>
                Gets the creation time for a file associated with the appender. The time returned is in Coordinated Universal 
                Time [UTC] standard.
                </summary>
                <returns>The file creation time.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.GetFileLength">
                <summary>
                Gets the length in bytes of the file associated with the appeander.
                </summary>
                <returns>A long value representing the length of the file in bytes.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
                <summary>
                Writes the specified bytes to a file.
                </summary>
                <param name="bytes">The bytes array.</param>
                <param name="offset">The bytes array offset.</param>
                <param name="count">The number of bytes.</param>
            </member>
            <member name="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Factory">
                <summary>
                Factory class which creates <see cref="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender"/> objects.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>
                Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.
                </returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.FileAppenderCache">
                <summary>
                Maintains a collection of file appenders usually associated with file targets.
                </summary>
            </member>
            <member name="F:NLog.Internal.FileAppenders.FileAppenderCache.Empty">
                <summary>
                An "empty" instance of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> class with zero size and empty list of appenders.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.#ctor">
                <summary>
                Initializes a new "empty" instance of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> class with zero size and empty
                list of appenders.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.#ctor(System.Int32,NLog.Internal.FileAppenders.IFileAppenderFactory,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> class.
                </summary>
                <remarks>
                The size of the list should be positive. No validations are performed during initialisation as it is an
                intenal class.
                </remarks>
                <param name="size">Total number of appenders allowed in list.</param>
                <param name="appenderFactory">Factory used to create each appender.</param>
                <param name="createFileParams">Parameters used for creating a file.</param>
            </member>
            <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.ArchiveFilePatternToWatch">
                <summary>
                The archive file path pattern that is used to detect when archiving occurs.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.InvalidateAppendersForArchivedFiles">
                <summary>
                Invalidates appenders for all files that were archived.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.CreateFileParameters">
                <summary>
                Gets the parameters which will be used for creating a file.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.Factory">
                <summary>
                Gets the file appender factory used by all the appenders in this list.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.Size">
                <summary>
                Gets the number of appenders which the list can hold.
                </summary>
            </member>
            <member name="E:NLog.Internal.FileAppenders.FileAppenderCache.CheckCloseAppenders">
                <summary>
                Subscribe to background monitoring of active file appenders
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.AllocateAppender(System.String)">
                <summary>
                It allocates the first slot in the list when the file name does not already in the list and clean up any
                unused slots.
                </summary>
                <param name="fileName">File name associated with a single appender.</param>
                <returns>The allocated appender.</returns>
                <exception cref="T:System.NullReferenceException">
                Thrown when <see cref="M:AllocateAppender"/> is called on an <c>Empty</c><see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> instance.
                </exception>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.CloseAppenders(System.String)">
                <summary>
                Close all the allocated appenders. 
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.CloseAppenders(System.DateTime)">
                <summary>
                Close the allocated appenders initialised before the supplied time.
                </summary>
                <param name="expireTime">The time which prior the appenders considered expired</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.FlushAppenders">
                <summary>
                Fluch all the allocated appenders. 
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.GetFileLastWriteTimeUtc(System.String)">
                <summary>
                File Archive Logic uses the File-Creation-TimeStamp to detect if time to archive, and the File-LastWrite-Timestamp to name the archive-file.
                </summary>
                <remarks>
                NLog always closes all relevant appenders during archive operation, so no need to lookup file-appender
                </remarks>
            </member>
            <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.InvalidateAppender(System.String)">
                <summary>
                Closes the specified appender and removes it from the list. 
                </summary>
                <param name="filePath">File name of the appender to be closed.</param>
                <returns>File Appender that matched the filePath (null if none found)</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.ICreateFileParameters">
                <summary>
                Interface that provides parameters for create file function.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.ConcurrentWriteAttemptDelay">
                <summary>
                Gets or sets the delay in milliseconds to wait before attempting to write to the file again.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.ConcurrentWriteAttempts">
                <summary>
                Gets or sets the number of times the write is appended on the file before NLog
                discards the log message.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.ConcurrentWrites">
                <summary>
                Gets or sets a value indicating whether concurrent writes to the log file by multiple processes on the same host.
                </summary>
                <remarks>
                This makes multi-process logging possible. NLog uses a special technique
                that lets it keep the files open for writing.
                </remarks>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.CreateDirs">
                <summary>
                Gets or sets a value indicating whether to create directories if they do not exist.
                </summary>
                <remarks>
                Setting this to false may improve performance a bit, but you'll receive an error
                when attempting to write to a directory that's not present.
                </remarks>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.EnableFileDelete">
                <summary>
                Gets or sets a value indicating whether to enable log file(s) to be deleted.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.BufferSize">
                <summary>
                Gets or sets the log file buffer size in bytes.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.ForceManaged">
                <summary>
                Gets or set a value indicating whether a managed file stream is forced, instead of using the native implementation.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.FileAttributes">
                <summary>
                Gets or sets the file attributes (Windows only).
                </summary>
            </member>
            <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.IsArchivingEnabled">
                <summary>
                Should archive mutex be created?
                </summary>
            </member>
            <member name="T:NLog.Internal.FileAppenders.IFileAppenderFactory">
                <summary>
                Interface implemented by all factories capable of creating file appenders.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.IFileAppenderFactory.Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender">
                <summary>
                Provides a multiprocess-safe atomic file appends while
                keeping the files open.
                </summary>
                <remarks>
                On Unix you can get all the appends to be atomic, even when multiple 
                processes are trying to write to the same file, because setting the file
                pointer to the end of the file and appending can be made one operation.
                On Win32 we need to maintain some synchronization between processes
                (global named mutex is used for this)
                </remarks>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">The parameters.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
                <summary>
                Writes the specified bytes.
                </summary>
                <param name="bytes">The bytes array.</param>
                <param name="offset">The bytes array offset.</param>
                <param name="count">The number of bytes.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Flush">
                <summary>
                Flushes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.GetFileCreationTimeUtc">
                <summary>
                Gets the creation time for a file associated with the appender. The time returned is in Coordinated Universal 
                Time [UTC] standard.
                </summary>
                <returns>The file creation time.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.GetFileLength">
                <summary>
                Gets the length in bytes of the file associated with the appeander.
                </summary>
                <returns>A long value representing the length of the file in bytes.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Factory">
                <summary>
                Factory class.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>
                Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.
                </returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.NullAppender">
                <summary>
                Appender used to discard data for the FileTarget.
                Used mostly for testing entire stack except the actual writing to disk.
                Throws away all data.
                </summary>
            </member>
            <member name="T:NLog.Internal.FileAppenders.NullAppender.Factory">
                <summary>
                Factory class.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.NullAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>
                Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.
                </returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender">
                <summary>
                Multi-process and multi-host file appender which attempts
                to get exclusive write access and retries if it's not available.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">The parameters.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
                <summary>
                Writes the specified bytes.
                </summary>
                <param name="bytes">The bytes array.</param>
                <param name="offset">The bytes array offset.</param>
                <param name="count">The number of bytes.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Flush">
                <summary>
                Flushes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.GetFileCreationTimeUtc">
                <summary>
                Gets the creation time for a file associated with the appender. The time returned is in Coordinated Universal 
                Time [UTC] standard.
                </summary>
                <returns>The file creation time.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.GetFileLength">
                <summary>
                Gets the length in bytes of the file associated with the appeander.
                </summary>
                <returns>A long value representing the length of the file in bytes.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Factory">
                <summary>
                Factory class.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>
                Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.
                </returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.SingleProcessFileAppender">
                <summary>
                Optimized single-process file appender which keeps the file open for exclusive write.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.SingleProcessFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">The parameters.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
                <summary>
                Writes the specified bytes.
                </summary>
                <param name="bytes">The bytes array.</param>
                <param name="offset">The bytes array offset.</param>
                <param name="count">The number of bytes.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Flush">
                <summary>
                Flushes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.GetFileCreationTimeUtc">
                <summary>
                Gets the creation time for a file associated with the appender. The time returned is in Coordinated Universal 
                Time [UTC] standard.
                </summary>
                <returns>The file creation time.</returns>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.GetFileLength">
                <summary>
                Gets the length in bytes of the file associated with the appeander.
                </summary>
                <returns>A long value representing the length of the file in bytes.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.SingleProcessFileAppender.Factory">
                <summary>
                Factory class.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>
                Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.
                </returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender">
                <summary>
                Provides a multiprocess-safe atomic file append while
                keeping the files open.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender" /> class.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">The parameters.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.CreateAppendOnlyFile(System.String)">
                <summary>
                Creates or opens a file in a special mode, so that writes are automatically
                as atomic writes at the file end.
                See also "UnixMultiProcessFileAppender" which does a similar job on *nix platforms.
                </summary>
                <param name="fileName">File to create or open</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
                <summary>
                Writes the specified bytes.
                </summary>
                <param name="bytes">The bytes array.</param>
                <param name="offset">The bytes array offset.</param>
                <param name="count">The number of bytes.</param>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Flush">
                <summary>
                Flushes this instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.GetFileLength">
                <summary>
                Gets the length in bytes of the file associated with the appeander.
                </summary>
                <returns>A long value representing the length of the file in bytes.</returns>
            </member>
            <member name="T:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Factory">
                <summary>
                Factory class.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
                <summary>
                Opens the appender for given file name and parameters.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="parameters">Creation parameters.</param>
                <returns>
                Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.
                </returns>
            </member>
            <member name="T:NLog.Internal.FileCharacteristics">
                <summary>
                An immutable object that stores basic file info.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileCharacteristics.#ctor(System.DateTime,System.DateTime,System.Int64)">
                <summary>
                Constructs a FileCharacteristics object.
                </summary>
                <param name="creationTimeUtc">The time the file was created in UTC.</param>
                <param name="lastWriteTimeUtc">The time the file was last written to in UTC.</param>
                <param name="fileLength">The size of the file in bytes.</param>
            </member>
            <member name="P:NLog.Internal.FileCharacteristics.CreationTimeUtc">
                <summary>
                The time the file was created in UTC.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileCharacteristics.LastWriteTimeUtc">
                <summary>
                The time the file was last written to in UTC.
                </summary>
            </member>
            <member name="P:NLog.Internal.FileCharacteristics.FileLength">
                <summary>
                The size of the file in bytes.
                </summary>
            </member>
            <member name="T:NLog.Internal.FileCharacteristicsHelper">
                <summary>
                Optimized routines to get the basic file characteristics of the specified file.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileCharacteristicsHelper.CreateHelper(System.Boolean)">
                <summary>
                Initializes static members of the FileCharacteristicsHelper class.
                </summary>
            </member>
            <member name="M:NLog.Internal.FileCharacteristicsHelper.GetFileCharacteristics(System.String,System.IO.FileStream)">
                <summary>
                Gets the information about a file.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="fileStream">The file stream.</param>
                <returns>The file characteristics, if the file information was retrieved successfully, otherwise null.</returns>
            </member>
            <member name="T:NLog.Internal.FilePathLayout">
                <summary>
                A layout that represents a filePath. 
                </summary>
            </member>
            <member name="F:NLog.Internal.FilePathLayout.DirectorySeparatorChars">
                <summary>
                Cached directory separator char array to avoid memory allocation on each method call.
                </summary>
            </member>
            <member name="F:NLog.Internal.FilePathLayout.InvalidFileNameChars">
                <summary>
                Cached invalid filenames char array to avoid memory allocation everytime Path.GetInvalidFileNameChars() is called.
                </summary>
            </member>
            <member name="F:NLog.Internal.FilePathLayout._baseDir">
                <summary>
                not null when <see cref="F:NLog.Internal.FilePathLayout._filePathKind"/> == <c>false</c>
                </summary>
            </member>
            <member name="F:NLog.Internal.FilePathLayout._cleanedFixedResult">
                <summary>
                non null is fixed,
                </summary>
            </member>
            <member name="F:NLog.Internal.FilePathLayout._cachedPrevRawFileName">
                <summary>
                <see cref="F:NLog.Internal.FilePathLayout._cachedPrevRawFileName"/> is the cache-key, and when newly rendered filename matches the cache-key,
                then it reuses the cleaned cache-value <see cref="F:NLog.Internal.FilePathLayout._cachedPrevCleanFileName"/>.
                </summary>
            </member>
            <member name="F:NLog.Internal.FilePathLayout._cachedPrevCleanFileName">
                <summary>
                <see cref="F:NLog.Internal.FilePathLayout._cachedPrevCleanFileName"/> is the cache-value that is reused, when the newly rendered filename
                matches the cache-key <see cref="F:NLog.Internal.FilePathLayout._cachedPrevRawFileName"/>
                </summary>
            </member>
            <member name="M:NLog.Internal.FilePathLayout.#ctor(NLog.Layouts.Layout,System.Boolean,NLog.Targets.FilePathKind)">
                <summary>Initializes a new instance of the <see cref="T:System.Object" /> class.</summary>
            </member>
            <member name="M:NLog.Internal.FilePathLayout.GetRenderedFileName(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Render the raw filename from Layout
                </summary>
                <param name="logEvent">The log event.</param>
                <param name="reusableBuilder">StringBuilder to minimize allocations [optional].</param>
                <returns>String representation of a layout.</returns>
            </member>
            <member name="M:NLog.Internal.FilePathLayout.GetCleanFileName(System.String)">
                <summary>
                Convert the raw filename to a correct filename
                </summary>
                <param name="rawFileName">The filename generated by Layout.</param>
                <returns>String representation of a correct filename.</returns>
            </member>
            <member name="M:NLog.Internal.FilePathLayout.DetectFilePathKind(NLog.Layouts.Layout)">
                <summary>
                Is this (templated/invalid) path an absolute, relative or unknown?
                </summary>
            </member>
            <member name="M:NLog.Internal.FilePathLayout.DetectFilePathKind(NLog.Layouts.SimpleLayout)">
                <summary>
                Is this (templated/invalid) path an absolute, relative or unknown?
                </summary>
            </member>
            <member name="M:NLog.Internal.FormatHelper.ConvertToString(System.Object,System.IFormatProvider)">
                <summary>
                Convert object to string
                </summary>
                <param name="o">value</param>
                <param name="formatProvider">format for conversion.</param>
                <returns></returns>
                <remarks>
                If <paramref name="formatProvider"/> is <c>null</c> and <paramref name="o"/> isn't a <see cref="T:System.String"/> already, then the <see cref="T:NLog.LogFactory"/> will get a locked by <see cref="P:NLog.LogManager.Configuration"/>
                </remarks>
            </member>
            <member name="T:NLog.Internal.IConfigurationManager">
                <summary>
                Interface for the wrapper around System.Configuration.ConfigurationManager.
                </summary>
            </member>
            <member name="P:NLog.Internal.IConfigurationManager.AppSettings">
                <summary>
                Gets the wrapper around ConfigurationManager.AppSettings.
                </summary>
            </member>
            <member name="T:NLog.Internal.ILogMessageFormatter">
                <summary>
                Format a log message
                </summary>
            </member>
            <member name="M:NLog.Internal.ILogMessageFormatter.FormatMessage(NLog.LogEventInfo)">
                <summary>
                Format the message and return
                </summary>
                <param name="logEvent">LogEvent with message to be formatted</param>
                <returns>formatted message</returns>
            </member>
            <member name="M:NLog.Internal.ILogMessageFormatter.HasProperties(NLog.LogEventInfo)">
                <summary>
                Has the logevent properties?
                </summary>
                <param name="logEvent">LogEvent with message to be formatted</param>
                <returns>False when logevent has no properties to be extracted</returns>
            </member>
            <member name="M:NLog.Internal.ILogMessageFormatter.AppendFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Appends the logevent message to the provided StringBuilder
                </summary>
                <param name="logEvent">LogEvent with message to be formatted</param>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the formatted message.</param>
            </member>
            <member name="T:NLog.Internal.IRawValue">
                <summary>
                Get the Raw, unformatted and unstrinyfied, value
                </summary>
            </member>
            <member name="M:NLog.Internal.IRawValue.TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <summary>
                Get the raw value
                </summary>
                <param name="logEvent"></param>
                <param name="value">The value</param>
                <returns>RawValue supported?</returns>
            </member>
            <member name="T:NLog.Internal.IRenderable">
                <summary>
                Interface implemented by layouts and layout renderers.
                </summary>
            </member>
            <member name="M:NLog.Internal.IRenderable.Render(NLog.LogEventInfo)">
                <summary>
                Renders the the value of layout or layout renderer in the context of the specified log event.
                </summary>
                <param name="logEvent">The log event.</param>
                <returns>String representation of a layout.</returns>
            </member>
            <member name="T:NLog.Internal.ISmtpClient">
                <summary>
                Supports mocking of SMTP Client code.
                </summary>
            </member>
            <member name="P:NLog.Internal.ISmtpClient.DeliveryMethod">
                <summary>
                Specifies how outgoing email messages will be handled.
                </summary>
            </member>
            <member name="P:NLog.Internal.ISmtpClient.Host">
                <summary>
                Gets or sets the name or IP address of the host used for SMTP transactions.
                </summary>
            </member>
            <member name="P:NLog.Internal.ISmtpClient.Port">
                <summary>
                Gets or sets the port used for SMTP transactions.
                </summary>
            </member>
            <member name="P:NLog.Internal.ISmtpClient.Timeout">
                <summary>
                Gets or sets a value that specifies the amount of time after which a synchronous <see cref="M:NLog.Internal.ISmtpClient.Send(System.Net.Mail.MailMessage)">Send</see> call times out.
                </summary>
            </member>
            <member name="P:NLog.Internal.ISmtpClient.Credentials">
                <summary>
                Gets or sets the credentials used to authenticate the sender.
                </summary>
            </member>
            <member name="M:NLog.Internal.ISmtpClient.Send(System.Net.Mail.MailMessage)">
                <summary>
                Sends an e-mail message to an SMTP server for delivery. These methods block while the message is being transmitted.
                </summary>
                <param name="msg">
                  <typeparam>System.Net.Mail.MailMessage
                    <name>MailMessage</name>
                </typeparam> A <see cref="T:System.Net.Mail.MailMessage">MailMessage</see> that contains the message to send.</param>
            </member>
            <member name="P:NLog.Internal.ISmtpClient.PickupDirectoryLocation">
                <summary>
                Gets or sets the folder where applications save mail messages to be processed by the local SMTP server.
                </summary>
            </member>
            <member name="T:NLog.Internal.IStringValueRenderer">
                <summary>
                Supports rendering as string value with limited or no allocations (preferred)
                </summary>
            </member>
            <member name="M:NLog.Internal.IStringValueRenderer.GetFormattedString(NLog.LogEventInfo)">
                <summary>
                Renders the value of layout renderer in the context of the specified log event
                </summary>
                <param name="logEvent"></param>
                <returns>null if not possible or unknown</returns>
            </member>
            <member name="T:NLog.Internal.ISupportsInitialize">
                <summary>
                Supports object initialization and termination.
                </summary>
            </member>
            <member name="M:NLog.Internal.ISupportsInitialize.Initialize(NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes this instance.
                </summary>
                <param name="configuration">The configuration.</param>
            </member>
            <member name="M:NLog.Internal.ISupportsInitialize.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="T:NLog.Internal.IUsesStackTrace">
                <summary>
                Allows components to request stack trace information to be provided in the <see cref="T:NLog.LogEventInfo"/>.
                </summary>
            </member>
            <member name="P:NLog.Internal.IUsesStackTrace.StackTraceUsage">
                <summary>
                Gets the level of stack trace information required by the implementing class.
                </summary>
            </member>
            <member name="M:NLog.Internal.LayoutHelpers.RenderShort(NLog.Layouts.Layout,NLog.LogEventInfo,System.Int16,System.String)">
                <summary>
                Render the event info as parse as <c>short</c>
                </summary>
                <param name="layout">current layout</param>
                <param name="logEvent"></param>
                <param name="defaultValue">default value when the render </param>
                <param name="layoutName">layout name for log message to internal log when logging fails</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.LayoutHelpers.RenderInt(NLog.Layouts.Layout,NLog.LogEventInfo,System.Int32,System.String)">
                <summary>
                Render the event info as parse as <c>int</c>
                </summary>
                <param name="layout">current layout</param>
                <param name="logEvent"></param>
                <param name="defaultValue">default value when the render </param>
                <param name="layoutName">layout name for log message to internal log when logging fails</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.LayoutHelpers.RenderBool(NLog.Layouts.Layout,NLog.LogEventInfo,System.Boolean,System.String)">
                <summary>
                Render the event info as parse as <c>bool</c>
                </summary>
                <param name="layout">current layout</param>
                <param name="logEvent"></param>
                <param name="defaultValue">default value when the render </param>
                <param name="layoutName">layout name for log message to internal log when logging fails</param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.LoggerConfiguration">
                <summary>
                Logger configuration.
                </summary>
            </member>
            <member name="M:NLog.Internal.LoggerConfiguration.#ctor(NLog.Internal.TargetWithFilterChain[],System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.LoggerConfiguration" /> class.
                </summary>
                <param name="targetsByLevel">The targets by level.</param>
                <param name="exceptionLoggingOldStyle">  Use the old exception log handling of NLog 3.0? 
                </param>
            </member>
            <member name="P:NLog.Internal.LoggerConfiguration.ExceptionLoggingOldStyle">
                <summary>
                Use the old exception log handling of NLog 3.0? 
                </summary>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it  will be removed in NLog 5.</remarks>
            </member>
            <member name="M:NLog.Internal.LoggerConfiguration.GetTargetsForLevel(NLog.LogLevel)">
                <summary>
                Gets targets for the specified level.
                </summary>
                <param name="level">The level.</param>
                <returns>Chain of targets with attached filters.</returns>
            </member>
            <member name="M:NLog.Internal.LoggerConfiguration.IsEnabled(NLog.LogLevel)">
                <summary>
                Determines whether the specified level is enabled.
                </summary>
                <param name="level">The level.</param>
                <returns>
                A value of <c>true</c> if the specified level is enabled; otherwise, <c>false</c>.
                </returns>
            </member>
            <member name="F:NLog.Internal.LogMessageTemplateFormatter._forceTemplateRenderer">
                <summary>
                When true: Do not fallback to StringBuilder.Format for positional templates
                </summary>
            </member>
            <member name="M:NLog.Internal.LogMessageTemplateFormatter.#ctor(System.Boolean,System.Boolean)">
                <summary>
                New formatter
                </summary>
                <param name="forceTemplateRenderer">When true: Do not fallback to StringBuilder.Format for positional templates</param>
                <param name="singleTargetOnly"></param>
            </member>
            <member name="P:NLog.Internal.LogMessageTemplateFormatter.MessageFormatter">
                <summary>
                The MessageFormatter delegate
                </summary>
            </member>
            <member name="M:NLog.Internal.LogMessageTemplateFormatter.HasProperties(NLog.LogEventInfo)">
                <inheritDoc/>
            </member>
            <member name="T:NLog.Internal.MruCache`2">
                <summary>
                Most-Recently-Used-Cache, that discards less frequently used items on overflow
                </summary>
            </member>
            <member name="M:NLog.Internal.MruCache`2.#ctor(System.Int32)">
                <summary>
                Constructor
                </summary>
                <param name="maxCapacity">Maximum number of items the cache will hold before discarding.</param>
            </member>
            <member name="M:NLog.Internal.MruCache`2.TryAddValue(`0,`1)">
                <summary>
                Attempt to insert item into cache.
                </summary>
                <param name="key">Key of the item to be inserted in the cache.</param>
                <param name="value">Value of the item to be inserted in the cache.</param>
                <returns><c>true</c> when the key does not already exist in the cache, <c>false</c> otherwise.</returns>
            </member>
            <member name="M:NLog.Internal.MruCache`2.TryGetValue(`0,`[email protected])">
                <summary>
                Lookup existing item in cache.
                </summary>
                <param name="key">Key of the item to be searched in the cache.</param>
                <param name="value">Output value of the item found in the cache.</param>
                <returns><c>True</c> when the key is found in the cache, <c>false</c> otherwise.</returns>
            </member>
            <member name="T:NLog.Internal.MultiFileWatcher">
                <summary>
                Watches multiple files at the same time and raises an event whenever 
                a single change is detected in any of those files.
                </summary>
            </member>
            <member name="P:NLog.Internal.MultiFileWatcher.NotifyFilters">
                <summary>
                The types of changes to watch for.
                </summary>
            </member>
            <member name="E:NLog.Internal.MultiFileWatcher.FileChanged">
                <summary>
                Occurs when a change is detected in one of the monitored files.
                </summary>
            </member>
            <member name="M:NLog.Internal.MultiFileWatcher.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.Internal.MultiFileWatcher.StopWatching">
                <summary>
                Stops watching all files.
                </summary>
            </member>
            <member name="M:NLog.Internal.MultiFileWatcher.StopWatching(System.String)">
                <summary>
                Stops watching the specified file.
                </summary>
                <param name="fileName"></param>
            </member>
            <member name="M:NLog.Internal.MultiFileWatcher.Watch(System.Collections.Generic.IEnumerable{System.String})">
                <summary>
                Watches the specified files for changes.
                </summary>
                <param name="fileNames">The file names.</param>
            </member>
            <member name="T:NLog.Internal.MySmtpClient">
                <summary>
                Supports mocking of SMTP Client code.
                </summary>
                <remarks>
                Disabled Error CS0618  'SmtpClient' is obsolete: 'SmtpClient and its network of types are poorly designed,
                 we strongly recommend you use https://github.com/jstedfast/MailKit and https://github.com/jstedfast/MimeKit instead'	
                </remarks>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.HttpNetworkSender">
                <summary>
                Network sender which uses HTTP or HTTPS POST.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.HttpNetworkSender.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.HttpNetworkSender"/> class.
                </summary>
                <param name="url">The network URL.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.HttpNetworkSender.DoSend(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
                <summary>
                Actually sends the given text over the specified protocol.
                </summary>
                <param name="bytes">The bytes to be sent.</param>
                <param name="offset">Offset in buffer.</param>
                <param name="length">Number of bytes to send.</param>
                <param name="asyncContinuation">The async continuation to be invoked after the buffer has been sent.</param>
                <remarks>To be overridden in inheriting classes.</remarks>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.INetworkSenderFactory">
                <summary>
                Creates instances of <see cref="T:NLog.Internal.NetworkSenders.NetworkSender"/> objects for given URLs.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.INetworkSenderFactory.Create(System.String,System.Int32,System.Security.Authentication.SslProtocols,System.TimeSpan)">
                <summary>
                Creates a new instance of the network sender based on a network URL.
                </summary>
                <param name="url">URL that determines the network sender to be created.</param>
                <param name="maxQueueSize">The maximum queue size.</param>
                <param name="sslProtocols">SSL protcols for TCP</param>
                <param name="keepAliveTime">KeepAliveTime for TCP</param>
                <returns>
                A newly created network sender.
                </returns>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.ISocket">
                <summary>
                Interface for mocking socket calls.
                </summary>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.NetworkSender">
                <summary>
                A base class for all network senders. Supports one-way sending of messages
                over various protocols.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.NetworkSender" /> class.
                </summary>
                <param name="url">The network URL.</param>
            </member>
            <member name="P:NLog.Internal.NetworkSenders.NetworkSender.Address">
                <summary>
                Gets the address of the network endpoint.
                </summary>
            </member>
            <member name="P:NLog.Internal.NetworkSenders.NetworkSender.LastSendTime">
                <summary>
                Gets the last send time.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Initialize">
                <summary>
                Initializes this network sender.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Close(NLog.Common.AsyncContinuation)">
                <summary>
                Closes the sender and releases any unmanaged resources.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.FlushAsync(NLog.Common.AsyncContinuation)">
                <summary>
                Flushes any pending messages and invokes a continuation.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Send(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
                <summary>
                Send the given text over the specified protocol.
                </summary>
                <param name="bytes">Bytes to be sent.</param>
                <param name="offset">Offset in buffer.</param>
                <param name="length">Number of bytes to send.</param>
                <param name="asyncContinuation">The asynchronous continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Dispose">
                <summary>
                Closes the sender and releases any unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoInitialize">
                <summary>
                Performs sender-specific initialization.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoClose(NLog.Common.AsyncContinuation)">
                <summary>
                Performs sender-specific close operation.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoFlush(NLog.Common.AsyncContinuation)">
                <summary>
                Performs sender-specific flush.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoSend(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
                <summary>
                Actually sends the given text over the specified protocol.
                </summary>
                <param name="bytes">The bytes to be sent.</param>
                <param name="offset">Offset in buffer.</param>
                <param name="length">Number of bytes to send.</param>
                <param name="asyncContinuation">The async continuation to be invoked after the buffer has been sent.</param>
                <remarks>To be overridden in inheriting classes.</remarks>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSender.ParseEndpointAddress(System.Uri,System.Net.Sockets.AddressFamily)">
                <summary>
                Parses the URI into an endpoint address.
                </summary>
                <param name="uri">The URI to parse.</param>
                <param name="addressFamily">The address family.</param>
                <returns>Parsed endpoint.</returns>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.NetworkSenderFactory">
                <summary>
                Default implementation of <see cref="T:NLog.Internal.NetworkSenders.INetworkSenderFactory"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.NetworkSenderFactory.Create(System.String,System.Int32,System.Security.Authentication.SslProtocols,System.TimeSpan)">
                <inheritdoc />
            </member>
            <member name="T:NLog.Internal.NetworkSenders.SocketProxy">
                <summary>
                Socket proxy for mocking Socket code.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.SocketProxy.#ctor(System.Net.Sockets.AddressFamily,System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.SocketProxy"/> class.
                </summary>
                <param name="addressFamily">The address family.</param>
                <param name="socketType">Type of the socket.</param>
                <param name="protocolType">Type of the protocol.</param>
            </member>
            <member name="P:NLog.Internal.NetworkSenders.SocketProxy.UnderlyingSocket">
                <summary>
                Gets underlying socket instance.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.SocketProxy.Close">
                <summary>
                Closes the wrapped socket.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.SocketProxy.ConnectAsync(System.Net.Sockets.SocketAsyncEventArgs)">
                <summary>
                Invokes ConnectAsync method on the wrapped socket.
                </summary>
                <param name="args">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> instance containing the event data.</param>
                <returns>Result of original method.</returns>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.SocketProxy.SendAsync(System.Net.Sockets.SocketAsyncEventArgs)">
                <summary>
                Invokes SendAsync method on the wrapped socket.
                </summary>
                <param name="args">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> instance containing the event data.</param>
                <returns>Result of original method.</returns>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.SocketProxy.SendToAsync(System.Net.Sockets.SocketAsyncEventArgs)">
                <summary>
                Invokes SendToAsync method on the wrapped socket.
                </summary>
                <param name="args">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> instance containing the event data.</param>
                <returns>Result of original method.</returns>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.SocketProxy.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
                </summary>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.TcpNetworkSender">
                <summary>
                Sends messages over a TCP network connection.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.#ctor(System.String,System.Net.Sockets.AddressFamily)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.TcpNetworkSender"/> class.
                </summary>
                <param name="url">URL. Must start with tcp://.</param>
                <param name="addressFamily">The address family.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.CreateSocket(System.String,System.Net.Sockets.AddressFamily,System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType)">
                <summary>
                Creates the socket with given parameters. 
                </summary>
                <param name="host">The host address.</param>
                <param name="addressFamily">The address family.</param>
                <param name="socketType">Type of the socket.</param>
                <param name="protocolType">Type of the protocol.</param>
                <returns>Instance of <see cref="T:NLog.Internal.NetworkSenders.ISocket" /> which represents the socket.</returns>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.DoInitialize">
                <summary>
                Performs sender-specific initialization.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.DoClose(NLog.Common.AsyncContinuation)">
                <summary>
                Closes the socket.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.DoFlush(NLog.Common.AsyncContinuation)">
                <summary>
                Performs sender-specific flush.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.DoSend(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
                <summary>
                Sends the specified text over the connected socket.
                </summary>
                <param name="bytes">The bytes to be sent.</param>
                <param name="offset">Offset in buffer.</param>
                <param name="length">Number of bytes to send.</param>
                <param name="asyncContinuation">The async continuation to be invoked after the buffer has been sent.</param>
                <remarks>To be overridden in inheriting classes.</remarks>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.TcpNetworkSender.MySocketAsyncEventArgs">
                <summary>
                Facilitates mocking of <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> class.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.MySocketAsyncEventArgs.RaiseCompleted">
                <summary>
                Raises the Completed event.
                </summary>
            </member>
            <member name="T:NLog.Internal.NetworkSenders.UdpNetworkSender">
                <summary>
                Sends messages over the network as UDP datagrams.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.#ctor(System.String,System.Net.Sockets.AddressFamily)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.UdpNetworkSender"/> class.
                </summary>
                <param name="url">URL. Must start with udp://.</param>
                <param name="addressFamily">The address family.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.CreateSocket(System.Net.Sockets.AddressFamily,System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType)">
                <summary>
                Creates the socket.
                </summary>
                <param name="addressFamily">The address family.</param>
                <param name="socketType">Type of the socket.</param>
                <param name="protocolType">Type of the protocol.</param>
                <returns>Implementation of <see cref="T:NLog.Internal.NetworkSenders.ISocket"/> to use.</returns>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.DoInitialize">
                <summary>
                Performs sender-specific initialization.
                </summary>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.DoClose(NLog.Common.AsyncContinuation)">
                <summary>
                Closes the socket.
                </summary>
                <param name="continuation">The continuation.</param>
            </member>
            <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.DoSend(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
                <summary>
                Sends the specified text as a UDP datagram.
                </summary>
                <param name="bytes">The bytes to be sent.</param>
                <param name="offset">Offset in buffer.</param>
                <param name="length">Number of bytes to send.</param>
                <param name="asyncContinuation">The async continuation to be invoked after the buffer has been sent.</param>
                <remarks>To be overridden in inheriting classes.</remarks>
            </member>
            <member name="T:NLog.Internal.ObjectGraphScanner">
                <summary>
                Scans (breadth-first) the object graph following all the edges whose are 
                instances have <see cref="T:NLog.Config.NLogConfigurationItemAttribute"/> attached and returns 
                all objects implementing a specified interfaces.
                </summary>
            </member>
            <member name="M:NLog.Internal.ObjectGraphScanner.FindReachableObjects``1(System.Boolean,System.Object[])">
                <summary>
                Finds the objects which have attached <see cref="T:NLog.Config.NLogConfigurationItemAttribute"/> which are reachable
                from any of the given root objects when traversing the object graph over public properties.
                </summary>
                <typeparam name="T">Type of the objects to return.</typeparam>
                <param name="aggressiveSearch">Also search the properties of the wanted objects.</param>
                <param name="rootObjects">The root objects.</param>
                <returns>Ordered list of objects implementing T.</returns>
            </member>
            <member name="M:NLog.Internal.ObjectGraphScanner.ScanProperties``1(System.Boolean,System.Collections.Generic.List{``0},System.Object,System.Int32,System.Collections.Generic.HashSet{System.Object})">
                <remarks>ISet is not there in .net35, so using HashSet</remarks>
            </member>
            <member name="T:NLog.Internal.ObjectReflectionCache">
                <summary>
                Converts object into a List of property-names and -values using reflection
                </summary>
            </member>
            <member name="T:NLog.Internal.ObjectReflectionCache.GetBinderAdapter">
                <summary>
                Binder for retrieving value of <see cref="T:System.Dynamic.DynamicObject"/>
                </summary>
            </member>
            <member name="M:NLog.Internal.ObjectReflectionCache.GetBinderAdapter.FallbackGetMember(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject)">
                <inheritdoc />
            </member>
            <member name="M:NLog.Internal.PathHelpers.CombinePaths(System.String,System.String,System.String)">
                <summary>
                Combine paths
                </summary>
                <param name="path">basepath, not null</param>
                <param name="dir">optional dir</param>
                <param name="file">optional file</param>
                <returns></returns>
            </member>
            <member name="F:NLog.Internal.PathHelpers.DirectorySeparatorChars">
                <summary>
                Cached directory separator char array to avoid memory allocation on each method call.
                </summary>
            </member>
            <member name="M:NLog.Internal.PathHelpers.TrimDirectorySeparators(System.String)">
                <summary>
                Trims directory separators from the path
                </summary>
                <param name="path">path, could be null</param>
                <returns>never null</returns>
            </member>
            <member name="T:NLog.Internal.PlatformDetector">
                <summary>
                Detects the platform the NLog is running on.
                </summary>
            </member>
            <member name="P:NLog.Internal.PlatformDetector.CurrentOS">
                <summary>
                Gets the current runtime OS.
                </summary>
            </member>
            <member name="P:NLog.Internal.PlatformDetector.IsWin32">
                <summary>
                Gets a value indicating whether current OS is Win32-based (desktop or mobile).
                </summary>
            </member>
            <member name="P:NLog.Internal.PlatformDetector.IsUnix">
                <summary>
                Gets a value indicating whether current OS is Unix-based.
                </summary>
            </member>
            <member name="P:NLog.Internal.PlatformDetector.IsMono">
                <summary>
                Gets a value indicating whether current runtime is Mono-based
                </summary>
            </member>
            <member name="P:NLog.Internal.PlatformDetector.SupportsSharableMutex">
                <summary>
                Gets a value indicating whether current runtime supports use of mutex
                </summary>
            </member>
            <member name="F:NLog.Internal.PlatformDetector.runTimeSupportsSharableMutex">
                <summary>
                 Will creating a mutex succeed runtime?
                "Cached" detection
                </summary>
            </member>
            <member name="P:NLog.Internal.PlatformDetector.RunTimeSupportsSharableMutex">
                <summary>
                Will creating a mutex succeed runtime?
                </summary>
            </member>
            <member name="T:NLog.Internal.PortableFileCharacteristicsHelper">
                <summary>
                Portable implementation of <see cref="T:NLog.Internal.FileCharacteristicsHelper"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.PortableFileCharacteristicsHelper.GetFileCharacteristics(System.String,System.IO.FileStream)">
                <summary>
                Gets the information about a file.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="fileStream">The file stream.</param>
                <returns>The file characteristics, if the file information was retrieved successfully, otherwise null.</returns>
            </member>
            <member name="T:NLog.Internal.PortableThreadIDHelper">
                <summary>
                Portable implementation of <see cref="T:NLog.Internal.ThreadIDHelper"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.PortableThreadIDHelper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.PortableThreadIDHelper" /> class.
                </summary>
            </member>
            <member name="P:NLog.Internal.PortableThreadIDHelper.CurrentProcessID">
                <summary>
                Gets current process ID.
                </summary>
                <value></value>
            </member>
            <member name="P:NLog.Internal.PortableThreadIDHelper.CurrentProcessName">
                <summary>
                Gets current process name.
                </summary>
                <value></value>
            </member>
            <member name="P:NLog.Internal.PortableThreadIDHelper.CurrentProcessBaseName">
                <summary>
                Gets current process name (excluding filename extension, if any).
                </summary>
                <value></value>
            </member>
            <member name="M:NLog.Internal.PortableThreadIDHelper.GetProcessName">
                <summary>
                Gets the name of the process.
                </summary>
            </member>
            <member name="T:NLog.Internal.PropertiesDictionary">
                <summary>
                Dictionary that combines the standard <see cref="P:NLog.LogEventInfo.Properties" /> with the
                MessageTemplate-properties extracted from the <see cref="P:NLog.LogEventInfo.Message" />.
                
                The <see cref="P:NLog.Internal.PropertiesDictionary.MessageProperties" /> are returned as the first items
                in the collection, and in positional order.
                </summary>
            </member>
            <member name="F:NLog.Internal.PropertiesDictionary.PropertyValue.Value">
                <summary>
                Value of the property 
                </summary>
            </member>
            <member name="F:NLog.Internal.PropertiesDictionary.PropertyValue.IsMessageProperty">
                <summary>
                Is this a property of the message?
                </summary>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.PropertyValue.#ctor(System.Object,System.Boolean)">
                <summary>
                
                </summary>
                <param name="value">Value of the property</param>
                <param name="isMessageProperty">Is this a property of the message?</param>
            </member>
            <member name="F:NLog.Internal.PropertiesDictionary._eventProperties">
                <summary>
                The properties of the logEvent
                </summary>
            </member>
            <member name="F:NLog.Internal.PropertiesDictionary._messageProperties">
                <summary>
                The properties extracted from the message
                </summary>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.#ctor(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
                <summary>
                Injects the list of message-template-parameter into the IDictionary-interface
                </summary>
                <param name="parameterList">Message-template-parameters</param>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.Item(System.Object)">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.Keys">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.Values">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.Count">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.IsReadOnly">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.Add(System.Object,System.Object)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.Add(System.Collections.Generic.KeyValuePair{System.Object,System.Object})">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.Clear">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.Contains(System.Collections.Generic.KeyValuePair{System.Object,System.Object})">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.ContainsKey(System.Object)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.CopyTo(System.Collections.Generic.KeyValuePair{System.Object,System.Object}[],System.Int32)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.GetEnumerator">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.Remove(System.Object)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.Remove(System.Collections.Generic.KeyValuePair{System.Object,System.Object})">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.TryGetValue(System.Object,[email protected])">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.VerifyUniqueMessageTemplateParametersFast(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
                <summary>
                Check if the message-template-parameters can be used directly without allocating a dictionary
                </summary>
                <param name="parameterList">Message-template-parameters</param>
                <returns>Are all parameter names unique (true / false)</returns>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.InsertMessagePropertiesIntoEmptyDictionary(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter},System.Collections.Generic.Dictionary{System.Object,NLog.Internal.PropertiesDictionary.PropertyValue})">
                <summary>
                Attempt to insert the message-template-parameters into an empty dictionary
                </summary>
                <param name="messageProperties">Message-template-parameters</param>
                <param name="eventProperties">The initially empty dictionary</param>
                <returns>Message-template-parameters was inserted into dictionary without trouble (true/false)</returns>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.CreateUniqueMessagePropertiesListSlow(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter},System.Collections.Generic.Dictionary{System.Object,NLog.Internal.PropertiesDictionary.PropertyValue})">
                <summary>
                Attempt to override the existing dictionary values using the message-template-parameters 
                </summary>
                <param name="messageProperties">Message-template-parameters</param>
                <param name="eventProperties">The already filled dictionary</param>
                <returns>List of unique message-template-parameters</returns>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.ParameterEnumerator.Current">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.ParameterEnumerator.System#Collections#IEnumerator#Current">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.DictionaryEnumerator.Current">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.DictionaryEnumerator.System#Collections#IEnumerator#Current">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.DictionaryCollection.Count">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.DictionaryCollection.IsReadOnly">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Add(System.Object)">
                <summary>Will always throw, as collection is readonly</summary>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Clear">
                <summary>Will always throw, as collection is readonly</summary>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Remove(System.Object)">
                <summary>Will always throw, as collection is readonly</summary>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Contains(System.Object)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.CopyTo(System.Object[],System.Int32)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.GetEnumerator">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.System#Collections#IEnumerable#GetEnumerator">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.PropertiesDictionary.DictionaryCollection.DictionaryCollectionEnumerator.Current">
                <inheritDoc/>
            </member>
            <member name="T:NLog.Internal.PropertyHelper">
                <summary>
                Reflection helpers for accessing properties.
                </summary>
            </member>
            <member name="M:NLog.Internal.PropertyHelper.SetPropertyFromString(System.Object,System.String,System.String,NLog.Config.ConfigurationItemFactory)">
                <summary>
                Set value parsed from string.
                </summary>
                <param name="obj">object instance to set with property <paramref name="propertyName"/></param>
                <param name="propertyName">name of the property on <paramref name="obj"/></param>
                <param name="value">The value to be parsed.</param>
                <param name="configurationItemFactory"></param>
            </member>
            <member name="M:NLog.Internal.PropertyHelper.IsArrayProperty(System.Type,System.String)">
                <summary>
                Is the property of array-type?
                </summary>
                <param name="t">Type which has the property <paramref name="propertyName"/></param>
                <param name="propertyName">name of the property.</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.PropertyHelper.TryGetPropertyInfo(System.Object,System.String,[email protected])">
                <summary>
                Get propertyinfo
                </summary>
                <param name="obj">object which could have property <paramref name="propertyName"/></param>
                <param name="propertyName">propertyname on <paramref name="obj"/></param>
                <param name="result">result when success.</param>
                <returns>success.</returns>
            </member>
            <member name="M:NLog.Internal.PropertyHelper.TryFlatListConversion(System.Type,System.String,[email protected])">
                <summary>
                Try parse of string to (Generic) list, comma separated.
                </summary>
                <remarks>
                If there is a comma in the value, then (single) quote the value. For single quotes, use the backslash as escape
                </remarks>
                <param name="type"></param>
                <param name="valueRaw"></param>
                <param name="newValue"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.ReflectionHelpers">
                <summary>
                Reflection helpers.
                </summary>
            </member>
            <member name="M:NLog.Internal.ReflectionHelpers.SafeGetTypes(System.Reflection.Assembly)">
                <summary>
                Gets all usable exported types from the given assembly.
                </summary>
                <param name="assembly">Assembly to scan.</param>
                <returns>Usable types from the given assembly.</returns>
                <remarks>Types which cannot be loaded are skipped.</remarks>
            </member>
            <member name="M:NLog.Internal.ReflectionHelpers.IsStaticClass(System.Type)">
                <summary>
                Is this a static class?
                </summary>
                <param name="type"></param>
                <returns></returns>
                <remarks>This is a work around, as Type doesn't have this property. 
                From: https://stackoverflow.com/questions/1175888/determine-if-a-type-is-static
                </remarks>
            </member>
            <member name="T:NLog.Internal.ReflectionHelpers.LateBoundMethod">
                <summary>
                Optimized delegate for calling MethodInfo
                </summary>
                <param name="target">Object instance, use null for static methods.</param>
                <param name="arguments">Complete list of parameters that matches the method, including optional/default parameters.</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.ReflectionHelpers.CreateLateBoundMethod(System.Reflection.MethodInfo)">
                <summary>
                Creates an optimized delegate for calling the MethodInfo using Expression-Trees
                </summary>
                <param name="methodInfo">Method to optimize</param>
                <returns>Optimized delegate for invoking the MethodInfo</returns>
            </member>
            <member name="T:NLog.Internal.ReusableAsyncLogEventList">
                <summary>
                Controls a single allocated AsyncLogEventInfo-List for reuse (only one active user)
                </summary>
            </member>
            <member name="T:NLog.Internal.ReusableBufferCreator">
                <summary>
                Controls a single allocated char[]-buffer for reuse (only one active user)
                </summary>
            </member>
            <member name="T:NLog.Internal.ReusableBuilderCreator">
                <summary>
                Controls a single allocated StringBuilder for reuse (only one active user)
                </summary>
            </member>
            <member name="T:NLog.Internal.ReusableObjectCreator`1">
                <summary>
                Controls a single allocated object for reuse (only one active user)
                </summary>
            </member>
            <member name="F:NLog.Internal.ReusableObjectCreator`1.None">
                <summary>Empty handle when <see cref="P:NLog.Targets.Target.OptimizeBufferReuse"/> is disabled</summary>
            </member>
            <member name="M:NLog.Internal.ReusableObjectCreator`1.Allocate">
                <summary>
                Creates handle to the reusable char[]-buffer for active usage
                </summary>
                <returns>Handle to the reusable item, that can release it again</returns>
            </member>
            <member name="F:NLog.Internal.ReusableObjectCreator`1.LockOject.Result">
                <summary>
                Access the acquired reusable object 
                </summary>
            </member>
            <member name="T:NLog.Internal.ReusableStreamCreator">
                <summary>
                Controls a single allocated MemoryStream for reuse (only one active user)
                </summary>
            </member>
            <member name="T:NLog.Internal.RuntimeOS">
                <summary>
                Supported operating systems.
                </summary>
                <remarks>
                If you add anything here, make sure to add the appropriate detection
                code to <see cref="T:NLog.Internal.PlatformDetector"/>
                </remarks>
            </member>
            <member name="F:NLog.Internal.RuntimeOS.Unknown">
                <summary>
                Unknown operating system.
                </summary>
            </member>
            <member name="F:NLog.Internal.RuntimeOS.Linux">
                <summary>
                Unix/Linux operating systems.
                </summary>
            </member>
            <member name="F:NLog.Internal.RuntimeOS.Windows">
                <summary>
                Desktop versions of Windows (95,98,ME).
                </summary>
            </member>
            <member name="F:NLog.Internal.RuntimeOS.WindowsNT">
                <summary>
                Windows NT, 2000, 2003 and future versions based on NT technology.
                </summary>
            </member>
            <member name="F:NLog.Internal.RuntimeOS.MacOSX">
                <summary>
                Macintosh Mac OSX
                </summary>
            </member>
            <member name="T:NLog.Internal.SimpleStringReader">
                <summary>
                Simple character tokenizer.
                </summary>
            </member>
            <member name="M:NLog.Internal.SimpleStringReader.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.SimpleStringReader" /> class.
                </summary>
                <param name="text">The text to be tokenized.</param>
            </member>
            <member name="P:NLog.Internal.SimpleStringReader.Position">
                <summary>
                Current position in <see cref="P:NLog.Internal.SimpleStringReader.Text"/>
                </summary>
            </member>
            <member name="P:NLog.Internal.SimpleStringReader.Text">
                <summary>
                Full text to be parsed
                </summary>
            </member>
            <member name="M:NLog.Internal.SimpleStringReader.Peek">
                <summary>
                Check current char while not changing the position.
                </summary>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.SimpleStringReader.Read">
                <summary>
                Read the current char and change position
                </summary>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.SimpleStringReader.Substring(System.Int32,System.Int32)">
                <summary>
                Get the substring of the <see cref="P:NLog.Internal.SimpleStringReader.Text"/>
                </summary>
                <param name="startIndex"></param>
                <param name="endIndex"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.SingleCallContinuation">
                <summary>
                Implements a single-call guard around given continuation function.
                </summary>
            </member>
            <member name="M:NLog.Internal.SingleCallContinuation.#ctor(NLog.Common.AsyncContinuation)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.SingleCallContinuation"/> class.
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
            </member>
            <member name="M:NLog.Internal.SingleCallContinuation.Function(System.Exception)">
                <summary>
                Continuation function which implements the single-call guard.
                </summary>
                <param name="exception">The exception.</param>
            </member>
            <member name="T:NLog.Internal.SingleItemOptimizedHashSet`1">
                <summary>
                HashSet optimized for single item
                </summary>
                <typeparam name="T"></typeparam>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.SingleItemScopedInsert.#ctor(`0,NLog.Internal.SingleItemOptimizedHashSet{`0}@,System.Boolean,System.Collections.Generic.IEqualityComparer{`0})">
                <summary>
                Insert single item on scope start, and remove on scope exit
                </summary>
                <param name="singleItem">Item to insert in scope</param>
                <param name="existing">Existing hashset to update</param>
                <param name="forceHashSet">Force allocation of real hashset-container</param>
                <param name="comparer">HashSet EqualityComparer</param>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Add(`0)">
                <summary>
                Add item to collection, if it not already exists
                </summary>
                <param name="item">Item to insert</param>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Clear">
                <summary>
                Clear hashset
                </summary>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Contains(`0)">
                <summary>
                Check if hashset contains item
                </summary>
                <param name="item"></param>
                <returns>Item exists in hashset (true/false)</returns>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Remove(`0)">
                <summary>
                Remove item from hashset
                </summary>
                <param name="item"></param>
                <returns>Item removed from hashset (true/false)</returns>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.CopyTo(`0[],System.Int32)">
                <summary>
                Copy items in hashset to array
                </summary>
                <param name="array">Destination array</param>
                <param name="arrayIndex">Array offset</param>
            </member>
            <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.GetEnumerator">
                <summary>
                Create hashset enumerator
                </summary>
                <returns>Enumerator</returns>
            </member>
            <member name="T:NLog.Internal.SortHelpers">
                <summary>
                Provides helpers to sort log events and associated continuations.
                </summary>
            </member>
            <member name="T:NLog.Internal.SortHelpers.KeySelector`2">
                <summary>
                Key selector delegate.
                </summary>
                <typeparam name="TValue">The type of the value.</typeparam>
                <typeparam name="TKey">The type of the key.</typeparam>
                <param name="value">Value to extract key information from.</param>
                <returns>Key selected from log event.</returns>
            </member>
            <member name="M:NLog.Internal.SortHelpers.BucketSort``2(System.Collections.Generic.IEnumerable{``0},NLog.Internal.SortHelpers.KeySelector{``0,``1})">
                <summary>
                Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set.
                </summary>
                <typeparam name="TValue">The type of the value.</typeparam>
                <typeparam name="TKey">The type of the key.</typeparam>
                <param name="inputs">The inputs.</param>
                <param name="keySelector">The key selector function.</param>
                <returns>
                Dictionary where keys are unique input keys, and values are lists of <see cref="T:NLog.Common.AsyncLogEventInfo"/>.
                </returns>
            </member>
            <member name="M:NLog.Internal.SortHelpers.BucketSort``2(System.Collections.Generic.IList{``0},NLog.Internal.SortHelpers.KeySelector{``0,``1})">
                <summary>
                Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set.
                </summary>
                <typeparam name="TValue">The type of the value.</typeparam>
                <typeparam name="TKey">The type of the key.</typeparam>
                <param name="inputs">The inputs.</param>
                <param name="keySelector">The key selector function.</param>
                <returns>
                Dictionary where keys are unique input keys, and values are lists of <see cref="T:NLog.Common.AsyncLogEventInfo"/>.
                </returns>
            </member>
            <member name="M:NLog.Internal.SortHelpers.BucketSort``2(System.Collections.Generic.IList{``0},NLog.Internal.SortHelpers.KeySelector{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
                <summary>
                Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set.
                </summary>
                <typeparam name="TValue">The type of the value.</typeparam>
                <typeparam name="TKey">The type of the key.</typeparam>
                <param name="inputs">The inputs.</param>
                <param name="keySelector">The key selector function.</param>
                <param name="keyComparer">The key comparer function.</param>
                <returns>
                Dictionary where keys are unique input keys, and values are lists of <see cref="T:NLog.Common.AsyncLogEventInfo"/>.
                </returns>
            </member>
            <member name="T:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2">
                 <summary>
                 Single-Bucket optimized readonly dictionary. Uses normal internally Dictionary if multiple buckets are needed.
                
                 Avoids allocating a new dictionary, when all items are using the same bucket
                 </summary>
                 <typeparam name="TKey">The type of the key.</typeparam>
                 <typeparam name="TValue">The type of the value.</typeparam>
            </member>
            <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Count">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Keys">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Values">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.IsReadOnly">
                <inheritDoc/>
            </member>
            <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Item(`0)">
                <summary>
                Allows direct lookup of existing keys. If trying to access non-existing key exception is thrown.
                Consider to use <see cref="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.TryGetValue(`0,`[email protected])"/> instead for better safety.
                </summary>
                <param name="key">Key value for lookup</param>
                <returns>Mapped value found</returns>
            </member>
            <member name="T:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Enumerator">
                <summary>
                Non-Allocating struct-enumerator
                </summary>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.System#Collections#Generic#IEnumerable{System#Collections#Generic#KeyValuePair{TKey,TValue}}#GetEnumerator">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.System#Collections#IEnumerable#GetEnumerator">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.ContainsKey(`0)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Add(`0,`1)">
                <summary>Will always throw, as dictionary is readonly</summary>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Remove(`0)">
                <summary>Will always throw, as dictionary is readonly</summary>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.TryGetValue(`0,`[email protected])">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Add(System.Collections.Generic.KeyValuePair{`0,`1})">
                <summary>Will always throw, as dictionary is readonly</summary>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Clear">
                <summary>Will always throw, as dictionary is readonly</summary>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1})">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32)">
                <inheritDoc/>
            </member>
            <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Remove(System.Collections.Generic.KeyValuePair{`0,`1})">
                <summary>Will always throw, as dictionary is readonly</summary>
            </member>
            <member name="T:NLog.Internal.StackTraceUsageUtils">
                <summary>
                Utilities for dealing with <see cref="T:NLog.Config.StackTraceUsage"/> values.
                </summary>
            </member>
            <member name="M:NLog.Internal.StackTraceUsageUtils.GetClassFullName">
                <summary>
                Gets the fully qualified name of the class invoking the calling method, including the 
                namespace but not the assembly.    
                </summary>
            </member>
            <member name="M:NLog.Internal.StackTraceUsageUtils.GetClassFullName(System.Diagnostics.StackFrame)">
                <summary>
                Gets the fully qualified name of the class invoking the calling method, including the 
                namespace but not the assembly.    
                </summary>
                <param name="stackFrame">StackFrame from the calling method</param>
                <returns>Fully qualified class name</returns>
            </member>
            <member name="M:NLog.Internal.StackTraceUsageUtils.LookupAssemblyFromStackFrame(System.Diagnostics.StackFrame)">
                <summary>
                Returns the assembly from the provided StackFrame (If not internal assembly)
                </summary>
                <returns>Valid asssembly, or null if assembly was internal</returns>
            </member>
            <member name="M:NLog.Internal.StackTraceUsageUtils.LookupClassNameFromStackFrame(System.Diagnostics.StackFrame)">
                <summary>
                Returns the classname from the provided StackFrame (If not from internal assembly)
                </summary>
                <param name="stackFrame"></param>
                <returns>Valid class name, or empty string if assembly was internal</returns>
            </member>
            <member name="T:NLog.Internal.StreamHelpers">
                <summary>
                Stream helpers
                </summary>
            </member>
            <member name="M:NLog.Internal.StreamHelpers.CopyAndSkipBom(System.IO.Stream,System.IO.Stream,System.Text.Encoding)">
                <summary>
                Copy to output stream and skip BOM if encoding is UTF8
                </summary>
                <param name="input"></param>
                <param name="output"></param>
                <param name="encoding"></param>
            </member>
            <member name="M:NLog.Internal.StreamHelpers.Copy(System.IO.Stream,System.IO.Stream)">
                <summary>
                Copy stream input to output. Skip the first bytes
                </summary>
                <param name="input">stream to read from</param>
                <param name="output">stream to write to</param>
                <remarks>.net35 doesn't have a .copyto</remarks>
            </member>
            <member name="M:NLog.Internal.StreamHelpers.CopyWithOffset(System.IO.Stream,System.IO.Stream,System.Int32)">
                <summary>
                Copy stream input to output. Skip the first bytes
                </summary>
                <param name="input">stream to read from</param>
                <param name="output">stream to write to</param>
                <param name="offset">first bytes to skip (optional)</param>
            </member>
            <member name="T:NLog.Internal.StringBuilderExt">
                <summary>
                Helpers for <see cref="T:System.Text.StringBuilder"/>, which is used in e.g. layout renderers.
                </summary>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.AppendFormattedValue(System.Text.StringBuilder,System.Object,System.String,System.IFormatProvider)">
                <summary>
                Renders the specified log event context item and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">append to this</param>
                <param name="value">value to be appended</param>
                <param name="format">formatstring. If @, then serialize the value with the Default JsonConverter.</param>
                <param name="formatProvider">provider, for example culture</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.AppendInvariant(System.Text.StringBuilder,System.Int32)">
                <summary>
                Appends int without using culture, and most importantly without garbage
                </summary>
                <param name="builder"></param>
                <param name="value">value to append</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.AppendInvariant(System.Text.StringBuilder,System.UInt32)">
                <summary>
                Appends uint without using culture, and most importantly without garbage
                
                Credits Gavin Pugh  - https://www.gavpugh.com/2010/04/01/xnac-avoiding-garbage-when-working-with-stringbuilder/
                </summary>
                <param name="builder"></param>
                <param name="value">value to append</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.ClearBuilder(System.Text.StringBuilder)">
                <summary>
                Clears the provider StringBuilder
                </summary>
                <param name="builder"></param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.CopyToStream(System.Text.StringBuilder,System.IO.MemoryStream,System.Text.Encoding,System.Char[])">
                <summary>
                Copies the contents of the StringBuilder to the MemoryStream using the specified encoding (Without BOM/Preamble)
                </summary>
                <param name="builder">StringBuilder source</param>
                <param name="ms">MemoryStream destination</param>
                <param name="encoding">Encoding used for converter string into byte-stream</param>
                <param name="transformBuffer">Helper char-buffer to minimize memory allocations</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.CopyTo(System.Text.StringBuilder,System.Text.StringBuilder)">
                <summary>
                Copies the contents of the StringBuilder to the destination StringBuilder
                </summary>
                <param name="builder">StringBuilder source</param>
                <param name="destination">StringBuilder destination</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.IndexOf(System.Text.StringBuilder,System.Char,System.Int32)">
                <summary>
                Scans the StringBuilder for the position of needle character
                </summary>
                <param name="builder">StringBuilder source</param>
                <param name="needle">needle character to search for</param>
                <param name="startPos"></param>
                <returns>Index of the first occurrence (Else -1)</returns>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.IndexOfAny(System.Text.StringBuilder,System.Char[],System.Int32)">
                <summary>
                Scans the StringBuilder for the position of needle character
                </summary>
                <param name="builder">StringBuilder source</param>
                <param name="needles">needle characters to search for</param>
                <param name="startPos"></param>
                <returns>Index of the first occurrence (Else -1)</returns>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.EqualTo(System.Text.StringBuilder,System.Text.StringBuilder)">
                <summary>
                Compares the contents of two StringBuilders
                </summary>
                <remarks>
                Correct implementation of <see cref="M:System.Text.StringBuilder.Equals(System.Text.StringBuilder)" /> that also works when <see cref="P:System.Text.StringBuilder.Capacity"/> is not the same
                </remarks>
                <returns>True when content is the same</returns>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.EqualTo(System.Text.StringBuilder,System.String)">
                <summary>
                Compares the contents of a StringBuilder and a String
                </summary>
                <returns>True when content is the same</returns>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.Append2DigitsZeroPadded(System.Text.StringBuilder,System.Int32)">
                <summary>
                Append a number and pad with 0 to 2 digits
                </summary>
                <param name="builder">append to this</param>
                <param name="number">the number</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.Append4DigitsZeroPadded(System.Text.StringBuilder,System.Int32)">
                <summary>
                Append a number and pad with 0 to 4 digits
                </summary>
                <param name="builder">append to this</param>
                <param name="number">the number</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderExt.AppendIntegerAsString(System.Text.StringBuilder,System.Object,System.TypeCode)">
                <summary>
                Apend a int type (byte, int) as string
                </summary>
            </member>
            <member name="M:NLog.Internal.StringBuilderPool.#ctor(System.Int32,System.Int32,System.Int32)">
                <summary>
                Constructor
                </summary>
                <param name="poolCapacity">Max number of items</param>
                <param name="initialBuilderCapacity">Initial StringBuilder Size</param>
                <param name="maxBuilderCapacity">Max StringBuilder Size</param>
            </member>
            <member name="M:NLog.Internal.StringBuilderPool.Acquire">
                <summary>
                Takes StringBuilder from pool
                </summary>
                <returns>Allow return to pool</returns>
            </member>
            <member name="M:NLog.Internal.StringBuilderPool.Release(System.Text.StringBuilder,System.Int32)">
                <summary>
                Releases StringBuilder back to pool at its right place
                </summary>
            </member>
            <member name="T:NLog.Internal.StringBuilderPool.ItemHolder">
                <summary>
                Keeps track of acquired pool item
                </summary>
            </member>
            <member name="M:NLog.Internal.StringBuilderPool.ItemHolder.Dispose">
                <summary>
                Releases pool item back into pool
                </summary>
            </member>
            <member name="T:NLog.Internal.StringHelpers">
                <summary>
                Helpers for <see cref="T:System.String"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.StringHelpers.IsNullOrWhiteSpace(System.String)">
                <summary>
                IsNullOrWhiteSpace, including for .NET 3.5
                </summary>
                <param name="value"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.StringSplitter">
                <summary>
                Split a string
                </summary>
            </member>
            <member name="M:NLog.Internal.StringSplitter.SplitWithSelfEscape(System.String,System.Char)">
                <summary>
                Split string with escape. The escape char is the same as the splitchar
                </summary>
                <param name="text"></param>
                <param name="splitChar">split char. escaped also with this char</param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.StringSplitter.SplitWithEscape(System.String,System.Char,System.Char)">
                <summary>
                Split string with escape
                </summary>
                <param name="text"></param>
                <param name="splitChar"></param>
                <param name="escapeChar"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.StringSplitter.SplitQuoted(System.String,System.Char,System.Char,System.Char)">
                <summary>
                Split a string, optional quoted value
                </summary>
                <param name="text">Text to split</param>
                <param name="splitChar">Character to split the <paramref name="text" /></param>
                <param name="quoteChar">Quote character</param>
                <param name="escapeChar">
                Escape for the <paramref name="quoteChar" />, not escape for the <paramref name="splitChar" />
                , use quotes for that.
                </param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.TargetWithFilterChain">
                <summary>
                Represents target with a chain of filters which determine
                whether logging should happen.
                </summary>
            </member>
            <member name="F:NLog.Internal.TargetWithFilterChain._stackTraceUsage">
                <summary>
                cached result as calculating is expensive.
                </summary>
            </member>
            <member name="M:NLog.Internal.TargetWithFilterChain.#ctor(NLog.Targets.Target,System.Collections.Generic.IList{NLog.Filters.Filter},NLog.Filters.FilterResult)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.TargetWithFilterChain" /> class.
                </summary>
                <param name="target">The target.</param>
                <param name="filterChain">The filter chain.</param>
                <param name="defaultResult">Default action if none of the filters match.</param>
            </member>
            <member name="P:NLog.Internal.TargetWithFilterChain.Target">
                <summary>
                Gets the target.
                </summary>
                <value>The target.</value>
            </member>
            <member name="P:NLog.Internal.TargetWithFilterChain.FilterChain">
                <summary>
                Gets the filter chain.
                </summary>
                <value>The filter chain.</value>
            </member>
            <member name="P:NLog.Internal.TargetWithFilterChain.DefaultResult">
                <summary>
                Default action if none of the filters match.
                </summary>
            </member>
            <member name="P:NLog.Internal.TargetWithFilterChain.NextInChain">
                <summary>
                Gets or sets the next <see cref="T:NLog.Internal.TargetWithFilterChain"/> item in the chain.
                </summary>
                <value>The next item in the chain.</value>
                <example>This is for example the 'target2' logger in writeTo='target1,target2'  </example>
            </member>
            <member name="M:NLog.Internal.TargetWithFilterChain.GetStackTraceUsage">
                <summary>
                Gets the stack trace usage.
                </summary>
                <returns>A <see cref="T:NLog.Config.StackTraceUsage" /> value that determines stack trace handling.</returns>
            </member>
            <member name="T:NLog.Internal.ThreadIDHelper">
                <summary>
                Returns details about current process and thread in a portable manner.
                </summary>
            </member>
            <member name="M:NLog.Internal.ThreadIDHelper.#cctor">
                <summary>
                Initializes static members of the ThreadIDHelper class.
                </summary>
            </member>
            <member name="P:NLog.Internal.ThreadIDHelper.Instance">
                <summary>
                Gets the singleton instance of PortableThreadIDHelper or
                Win32ThreadIDHelper depending on runtime environment.
                </summary>
                <value>The instance.</value>
            </member>
            <member name="P:NLog.Internal.ThreadIDHelper.CurrentProcessID">
                <summary>
                Gets current process ID.
                </summary>
            </member>
            <member name="P:NLog.Internal.ThreadIDHelper.CurrentProcessName">
                <summary>
                Gets current process name.
                </summary>
            </member>
            <member name="P:NLog.Internal.ThreadIDHelper.CurrentProcessBaseName">
                <summary>
                Gets current process name (excluding filename extension, if any).
                </summary>
            </member>
            <member name="T:NLog.Internal.ThreadLocalStorageHelper">
                <summary>
                Helper for dealing with thread-local storage.
                </summary>
            </member>
            <member name="M:NLog.Internal.ThreadLocalStorageHelper.AllocateDataSlot">
                <summary>
                Allocates the data slot for storing thread-local information.
                </summary>
                <returns>Allocated slot key.</returns>
            </member>
            <member name="M:NLog.Internal.ThreadLocalStorageHelper.GetDataForSlot``1(System.Object,System.Boolean)">
                <summary>
                Gets the data for a slot in thread-local storage.
                </summary>
                <typeparam name="T">Type of the data.</typeparam>
                <param name="slot">The slot to get data for.</param>
                <param name="create">Automatically create the object if it doesn't exist.</param>
                <returns>
                Slot data (will create T if null).
                </returns>
            </member>
            <member name="T:NLog.Internal.TimeoutContinuation">
                <summary>
                Wraps <see cref="T:NLog.Common.AsyncContinuation"/> with a timeout.
                </summary>
            </member>
            <member name="M:NLog.Internal.TimeoutContinuation.#ctor(NLog.Common.AsyncContinuation,System.TimeSpan)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.TimeoutContinuation"/> class.
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
                <param name="timeout">The timeout.</param>
            </member>
            <member name="M:NLog.Internal.TimeoutContinuation.Function(System.Exception)">
                <summary>
                Continuation function which implements the timeout logic.
                </summary>
                <param name="exception">The exception.</param>
            </member>
            <member name="M:NLog.Internal.TimeoutContinuation.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
                </summary>
            </member>
            <member name="T:NLog.Internal.UrlHelper">
                <summary>
                URL Encoding helper.
                </summary>
            </member>
            <member name="F:NLog.Internal.UrlHelper.EscapeEncodingFlag.UriString">
                <summary>Allow UnreservedMarks instead of ReservedMarks, as specified by chosen RFC</summary>
            </member>
            <member name="F:NLog.Internal.UrlHelper.EscapeEncodingFlag.LegacyRfc2396">
                <summary>Use RFC2396 standard (instead of RFC3986)</summary>
            </member>
            <member name="F:NLog.Internal.UrlHelper.EscapeEncodingFlag.LowerCaseHex">
                <summary>Should use lowercase when doing HEX escaping of special characters</summary>
            </member>
            <member name="F:NLog.Internal.UrlHelper.EscapeEncodingFlag.SpaceAsPlus">
                <summary>Replace space ' ' with '+' instead of '%20'</summary>
            </member>
            <member name="F:NLog.Internal.UrlHelper.EscapeEncodingFlag.NLogLegacy">
                <summary>Skip UTF8 encoding, and prefix special characters with '%u'</summary>
            </member>
            <member name="M:NLog.Internal.UrlHelper.EscapeDataEncode(System.String,System.Text.StringBuilder,NLog.Internal.UrlHelper.EscapeEncodingFlag)">
                <summary>
                Escape unicode string data for use in http-requests
                </summary>
                <param name="source">unicode string-data to be encoded</param>
                <param name="target">target for the encoded result</param>
                <param name="flags"><see cref="T:NLog.Internal.UrlHelper.EscapeEncodingFlag"/>s for how to perform the encoding</param>
            </member>
            <member name="M:NLog.Internal.UrlHelper.WriteWideChars(System.Text.StringBuilder,System.Char[],System.Byte[],System.Char[])">
                <summary>
                Convert the wide-char into utf8-bytes, and then escape
                </summary>
                <param name="target"></param>
                <param name="charArray"></param>
                <param name="byteArray"></param>
                <param name="hexChars"></param>
            </member>
            <member name="M:NLog.Internal.UrlHelper.IsAllowedChar(NLog.Internal.UrlHelper.EscapeEncodingFlag,System.Char)">
                <summary>
                Is allowed?
                </summary>
                <param name="flags"></param>
                <param name="ch"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.UrlHelper.IsSimpleCharOrNumber(System.Char)">
                <summary>
                Is a-z / A-Z / 0-9
                </summary>
                <param name="ch"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.Internal.Win32FileCharacteristicsHelper">
                <summary>
                Win32-optimized implementation of <see cref="T:NLog.Internal.FileCharacteristicsHelper"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.Win32FileCharacteristicsHelper.GetFileCharacteristics(System.String,System.IO.FileStream)">
                <summary>
                Gets the information about a file.
                </summary>
                <param name="fileName">Name of the file.</param>
                <param name="fileStream">The file stream.</param>
                <returns>The file characteristics, if the file information was retrieved successfully, otherwise null.</returns>
            </member>
            <member name="T:NLog.Internal.Win32ThreadIDHelper">
                <summary>
                Win32-optimized implementation of <see cref="T:NLog.Internal.ThreadIDHelper"/>.
                </summary>
            </member>
            <member name="M:NLog.Internal.Win32ThreadIDHelper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Internal.Win32ThreadIDHelper" /> class.
                </summary>
            </member>
            <member name="P:NLog.Internal.Win32ThreadIDHelper.CurrentProcessID">
                <summary>
                Gets current process ID.
                </summary>
                <value></value>
            </member>
            <member name="P:NLog.Internal.Win32ThreadIDHelper.CurrentProcessName">
                <summary>
                Gets current process name.
                </summary>
                <value></value>
            </member>
            <member name="P:NLog.Internal.Win32ThreadIDHelper.CurrentProcessBaseName">
                <summary>
                Gets current process name (excluding filename extension, if any).
                </summary>
                <value></value>
            </member>
            <member name="T:NLog.Internal.Xamarin.PreserveAttribute">
                <summary>
                Prevents the Xamarin linker from linking the target.
                </summary>
                <remarks>
                By applying this attribute all of the members of the target will be kept as if they had been referenced by the code.
                </remarks>
            </member>
            <member name="P:NLog.Internal.Xamarin.PreserveAttribute.AllMembers">
                <summary>
                Ensures that all members of this type are preserved
                </summary>
            </member>
            <member name="P:NLog.Internal.Xamarin.PreserveAttribute.Conditional">
                <summary>
                Flags the method as a method to preserve during linking if the container class is pulled in.
                </summary>
            </member>
            <member name="T:NLog.Internal.XmlHelper">
                <summary>
                 Helper class for XML
                </summary>
            </member>
            <member name="M:NLog.Internal.XmlHelper.RemoveInvalidXmlChars(System.String)">
                <summary>
                removes any unusual unicode characters that can't be encoded into XML
                </summary>
            </member>
            <member name="M:NLog.Internal.XmlHelper.CreateValidXmlString(System.String)">
                <summary>
                Cleans string of any invalid XML chars found
                </summary>
                <param name="text">unclean string</param>
                <returns>string with only valid XML chars</returns>
            </member>
            <member name="M:NLog.Internal.XmlHelper.SmallAndNoEscapeNeeded(System.String,System.Boolean)">
                <summary>
                Pretest, small text and not escape needed
                </summary>
                <param name="text"></param>
                <param name="xmlEncodeNewlines"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.Internal.XmlHelper.XmlConvertToStringSafe(System.Object)">
                <summary>
                Converts object value to invariant format, and strips any invalid xml-characters
                </summary>
                <param name="value">Object value</param>
                <returns>Object value converted to string</returns>
            </member>
            <member name="M:NLog.Internal.XmlHelper.XmlConvertToString(System.Object)">
                <summary>
                Converts object value to invariant format (understood by JavaScript)
                </summary>
                <param name="value">Object value</param>
                <returns>Object value converted to string</returns>
            </member>
            <member name="M:NLog.Internal.XmlHelper.XmlConvertToElementName(System.String,System.Boolean)">
                <summary>
                XML elements must follow these naming rules:
                 - Element names are case-sensitive
                 - Element names must start with a letter or underscore
                 - Element names can contain letters, digits, hyphens, underscores, and periods
                 - Element names cannot contain spaces
                </summary>
                <param name="xmlElementName"></param>
                <param name="allowNamespace"></param>
            </member>
            <member name="M:NLog.Internal.XmlHelper.XmlConvertToString(System.Object,System.TypeCode,System.Boolean)">
                <summary>
                Converts object value to invariant format (understood by JavaScript)
                </summary>
                <param name="value">Object value</param>
                <param name="objTypeCode">Object TypeCode</param>
                <param name="safeConversion">Check and remove unusual unicode characters from the result string.</param>
                <returns>Object value converted to string</returns>
            </member>
            <member name="M:NLog.Internal.XmlHelper.WriteAttributeSafeString(System.Xml.XmlWriter,System.String,System.String,System.String,System.String)">
                <summary>
                Safe version of WriteAttributeString
                </summary>
                <param name="writer"></param>
                <param name="prefix"></param>
                <param name="localName"></param>
                <param name="ns"></param>
                <param name="value"></param>
            </member>
            <member name="M:NLog.Internal.XmlHelper.WriteAttributeSafeString(System.Xml.XmlWriter,System.String,System.String)">
                <summary>
                Safe version of WriteAttributeString
                </summary>
                <param name="writer"></param>
                <param name="localName"></param>
                <param name="value"></param>
            </member>
            <member name="M:NLog.Internal.XmlHelper.WriteElementSafeString(System.Xml.XmlWriter,System.String,System.String,System.String,System.String)">
                <summary>
                Safe version of WriteElementSafeString
                </summary>
                <param name="writer"></param>
                <param name="prefix"></param>
                <param name="localName"></param>
                <param name="ns"></param>
                <param name="value"></param>
            </member>
            <member name="M:NLog.Internal.XmlHelper.WriteSafeCData(System.Xml.XmlWriter,System.String)">
                <summary>
                Safe version of WriteCData
                </summary>
                <param name="writer"></param>
                <param name="text"></param>
            </member>
            <member name="T:NLog.ISuppress">
                <summary>
                Provides an interface to execute System.Actions without surfacing any exceptions raised for that action.
                </summary>
            </member>
            <member name="M:NLog.ISuppress.Swallow(System.Action)">
                <summary>
                Runs the provided action. If the action throws, the exception is logged at <c>Error</c> level. The exception is not propagated outside of this method.
                </summary>
                <param name="action">Action to execute.</param>
            </member>
            <member name="M:NLog.ISuppress.Swallow``1(System.Func{``0})">
                <summary>
                Runs the provided function and returns its result. If an exception is thrown, it is logged at <c>Error</c> level.
                The exception is not propagated outside of this method; a default value is returned instead.
                </summary>
                <typeparam name="T">Return type of the provided function.</typeparam>
                <param name="func">Function to run.</param>
                <returns>Result returned by the provided function or the default value of type <typeparamref name="T"/> in case of exception.</returns>
            </member>
            <member name="M:NLog.ISuppress.Swallow``1(System.Func{``0},``0)">
                <summary>
                Runs the provided function and returns its result. If an exception is thrown, it is logged at <c>Error</c> level.
                The exception is not propagated outside of this method; a fallback value is returned instead.
                </summary>
                <typeparam name="T">Return type of the provided function.</typeparam>
                <param name="func">Function to run.</param>
                <param name="fallback">Fallback value to return in case of exception.</param>
                <returns>Result returned by the provided function or fallback value in case of exception.</returns>
            </member>
            <member name="M:NLog.ISuppress.Swallow(System.Threading.Tasks.Task)">
                <summary>
                Logs an exception is logged at <c>Error</c> level if the provided task does not run to completion.
                </summary>
                <param name="task">The task for which to log an error if it does not run to completion.</param>
                <remarks>This method is useful in fire-and-forget situations, where application logic does not depend on completion of task. This method is avoids C# warning CS4014 in such situations.</remarks>
            </member>
            <member name="M:NLog.ISuppress.SwallowAsync(System.Threading.Tasks.Task)">
                <summary>
                Returns a task that completes when a specified task to completes. If the task does not run to completion, an exception is logged at <c>Error</c> level. The returned task always runs to completion.
                </summary>
                <param name="task">The task for which to log an error if it does not run to completion.</param>
                <returns>A task that completes in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state when <paramref name="task"/> completes.</returns>
            </member>
            <member name="M:NLog.ISuppress.SwallowAsync(System.Func{System.Threading.Tasks.Task})">
                <summary>
                Runs async action. If the action throws, the exception is logged at <c>Error</c> level. The exception is not propagated outside of this method.
                </summary>
                <param name="asyncAction">Async action to execute.</param>
                <returns>A task that completes in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state when <paramref name="asyncAction"/> completes.</returns>
            </member>
            <member name="M:NLog.ISuppress.SwallowAsync``1(System.Func{System.Threading.Tasks.Task{``0}})">
                <summary>
                Runs the provided async function and returns its result. If the task does not run to completion, an exception is logged at <c>Error</c> level.
                The exception is not propagated outside of this method; a default value is returned instead.
                </summary>
                <typeparam name="TResult">Return type of the provided function.</typeparam>
                <param name="asyncFunc">Async function to run.</param>
                <returns>A task that represents the completion of the supplied task. If the supplied task ends in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state, the result of the new task will be the result of the supplied task; otherwise, the result of the new task will be the default value of type <typeparamref name="TResult"/>.</returns>
            </member>
            <member name="M:NLog.ISuppress.SwallowAsync``1(System.Func{System.Threading.Tasks.Task{``0}},``0)">
                <summary>
                Runs the provided async function and returns its result. If the task does not run to completion, an exception is logged at <c>Error</c> level.
                The exception is not propagated outside of this method; a fallback value is returned instead.
                </summary>
                <typeparam name="TResult">Return type of the provided function.</typeparam>
                <param name="asyncFunc">Async function to run.</param>
                <param name="fallback">Fallback value to return if the task does not end in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state.</param>
                <returns>A task that represents the completion of the supplied task. If the supplied task ends in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state, the result of the new task will be the result of the supplied task; otherwise, the result of the new task will be the fallback value.</returns>
            </member>
            <member name="T:NLog.IValueFormatter">
                <summary>
                Render a message template property to a string
                </summary>
            </member>
            <member name="M:NLog.IValueFormatter.FormatValue(System.Object,System.String,NLog.MessageTemplates.CaptureType,System.IFormatProvider,System.Text.StringBuilder)">
                <summary>
                Serialization of an object, e.g. JSON and append to <paramref name="builder"/>
                </summary>
                <param name="value">The object to serialize to string.</param>
                <param name="format">Parameter Format</param>
                <param name="captureType">Parameter CaptureType</param>
                <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
                <param name="builder">Output destination.</param>
                <returns>Serialize succeeded (true/false)</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer">
                <summary>
                Log event context data.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer"/> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Separator">
                <summary>
                Gets or sets string that will be used to separate key/value pairs.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.IncludeCallerInformation">
                <summary>
                Also render the caller information attributes? (<see cref="T:System.Runtime.CompilerServices.CallerMemberNameAttribute"/>,
                <see cref="T:System.Runtime.CompilerServices.CallerFilePathAttribute"/>, <see cref="T:System.Runtime.CompilerServices.CallerLineNumberAttribute"/>). 
                
                See https://msdn.microsoft.com/en-us/library/hh534540.aspx
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Format">
                <summary>
                Gets or sets how key/value pairs will be formatted.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders all log event's properties and appends them to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="F:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.CallerInformationAttributeNames">
                <summary>
                The names of caller information attributes.
                https://msdn.microsoft.com/en-us/library/hh534540.aspx
                TODO NLog ver. 5 - Remove these properties
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.GetProperties(NLog.LogEventInfo)">
                 <summary>
                 Also render the call attributes? (<see cref="T:System.Runtime.CompilerServices.CallerMemberNameAttribute"/>,
                 <see cref="T:System.Runtime.CompilerServices.CallerFilePathAttribute"/>, <see cref="T:System.Runtime.CompilerServices.CallerLineNumberAttribute"/>). 
                 </summary>
                
            </member>
            <member name="T:NLog.LayoutRenderers.AmbientPropertyAttribute">
                <summary>
                Designates a property of the class as an ambient property.
                </summary>
                <example>
                non-ambient:  ${uppercase:${level}} 
                ambient    :  ${level:uppercase} 
                </example>
            </member>
            <member name="M:NLog.LayoutRenderers.AmbientPropertyAttribute.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.AmbientPropertyAttribute" /> class.
                </summary>
                <param name="name">Ambient property name.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.AppDomainLayoutRenderer">
                <summary>
                 Used to render the application domain name.
                 </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.#ctor">
                <summary>
                Create a new renderer
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppDomain)">
                <summary>
                Create a new renderer
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.AppDomainLayoutRenderer.Format">
                <summary>
                Format string. Possible values: "Short", "Long" or custom like {0} {1}. Default "Long"
                The first parameter is the  <see cref="P:NLog.Internal.Fakeables.IAppDomain.Id"/>, the second the second the  <see cref="P:NLog.Internal.Fakeables.IAppDomain.FriendlyName"/>
                This string is used in <see cref="M:System.String.Format(System.String,System.Object[])"/>
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.CloseLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.AppSettingLayoutRenderer2">
                <summary>
                Application setting.
                </summary>
                <remarks>
                Use this layout renderer to insert the value of an application setting
                stored in the application's App.config or Web.config file.
                </remarks>
                <code lang="NLog Layout Renderer">
                ${appsetting:item=mysetting:default=mydefault} - produces "mydefault" if no appsetting
                </code>
            </member>
            <member name="P:NLog.LayoutRenderers.AppSettingLayoutRenderer2.Item">
                <summary>
                 The AppSetting item-name
                </summary>
                 <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.AppSettingLayoutRenderer2.Name">
                <summary>
                 The AppSetting item-name
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.AppSettingLayoutRenderer2.Default">
                <summary>
                 The default value to render if the AppSetting value is null.
                </summary>
                 <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.AppSettingLayoutRenderer2.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified application setting or default value and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer">
                <summary>
                Renders the assembly version information for the entry assembly or a named assembly.
                </summary>
                <remarks>
                As this layout renderer uses reflection and version information is unlikely to change during application execution,
                it is recommended to use it in conjunction with the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/>.
                </remarks>
                <remarks>
                The entry assembly can't be found in some cases e.g. ASP.NET, unit tests, etc.
                </remarks>
            </member>
            <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Name">
                <summary>
                The (full) name of the assembly. If <c>null</c>, using the entry assembly.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Type">
                <summary>
                Gets or sets the type of assembly version to retrieve.
                </summary>
                <remarks>
                Some version type and platform combinations are not fully supported.
                - UWP earlier than .NET Standard 1.5: Value for <see cref="F:NLog.LayoutRenderers.AssemblyVersionType.Assembly"/> is always returned unless the <see cref="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Name"/> parameter is specified.
                - Silverlight: Value for <see cref="F:NLog.LayoutRenderers.AssemblyVersionType.Assembly"/> is always returned.
                </remarks>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Format">
                <summary>
                Gets or sets the custom format of the assembly version output.
                </summary>
                <remarks>
                Supported placeholders are 'major', 'minor', 'build' and 'revision'.
                The default .NET template for version numbers is 'major.minor.build.revision'. See
                https://docs.microsoft.com/en-gb/dotnet/api/system.version?view=netframework-4.7.2#remarks
                for details.
                </remarks>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.CloseLayoutRenderer">
                <summary>
                Closes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders an assembly version and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.GetAssembly">
                <summary>
                Gets the assembly specified by <see cref="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Name"/>, or entry assembly otherwise
                </summary>
                <returns>Found assembly</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.AssemblyVersionType">
                <summary>
                Type of assembly version to retrieve.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.AssemblyVersionType.Assembly">
                <summary>
                Gets the assembly version.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.AssemblyVersionType.File">
                <summary>
                Gets the file version.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.AssemblyVersionType.Informational">
                <summary>
                Gets additional version information.
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.BaseDirLayoutRenderer">
                <summary>
                The current application domain's base directory.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.BaseDirLayoutRenderer._processDir">
                <summary>
                cached
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.ProcessDir">
                <summary>
                Use base dir of current process.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.BaseDirLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppDomain)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.BaseDirLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.File">
                <summary>
                Gets or sets the name of the file to be Path.Combine()'d with with the base directory.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.Dir">
                <summary>
                Gets or sets the name of the directory to be Path.Combine()'d with with the base directory.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the application base directory and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer">
                <summary>
                The call site source file name. Full callsite <see cref="T:NLog.LayoutRenderers.CallSiteLayoutRenderer"/>
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.IncludeSourcePath">
                <summary>
                Gets or sets a value indicating whether to include source file path.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.SkipFrames">
                <summary>
                Gets or sets the number of frames to skip.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.NLog#Internal#IUsesStackTrace#StackTraceUsage">
                <summary>
                Gets the level of stack trace information required by the implementing class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.CallSiteLayoutRenderer">
                <summary>
                The call site (class name, method name and source information).
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.CallSiteLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.CallSiteLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.ClassName">
                <summary>
                Gets or sets a value indicating whether to render the class name.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.IncludeNamespace">
                <summary>
                Gets or sets a value indicating whether to render the include the namespace with <see cref="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.ClassName"/>.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.MethodName">
                <summary>
                Gets or sets a value indicating whether to render the method name.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.CleanNamesOfAnonymousDelegates">
                <summary>
                Gets or sets a value indicating whether the method name will be cleaned up if it is detected as an anonymous delegate.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.CleanNamesOfAsyncContinuations">
                <summary>
                Gets or sets a value indicating whether the method and class names will be cleaned up if it is detected as an async continuation
                (everything after an await-statement inside of an async method).
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.SkipFrames">
                <summary>
                Gets or sets the number of frames to skip.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.FileName">
                <summary>
                Gets or sets a value indicating whether to render the source file name and line number.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.IncludeSourcePath">
                <summary>
                Gets or sets a value indicating whether to include source file path.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.NLog#Internal#IUsesStackTrace#StackTraceUsage">
                <summary>
                Gets the level of stack trace information required by the implementing class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.CallSiteLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the call site and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer">
                <summary>
                The call site source line number. Full callsite <see cref="T:NLog.LayoutRenderers.CallSiteLayoutRenderer"/>
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.SkipFrames">
                <summary>
                Gets or sets the number of frames to skip.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.NLog#Internal#IUsesStackTrace#StackTraceUsage">
                <summary>
                Gets the level of stack trace information required by the implementing class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.CounterLayoutRenderer">
                <summary>
                A counter value (increases on each layout rendering).
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.CounterLayoutRenderer.Value">
                <summary>
                Gets or sets the initial value of the counter.
                </summary>
                <docgen category='Counter Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CounterLayoutRenderer.Increment">
                <summary>
                Gets or sets the value to be added to the counter after each layout rendering.
                </summary>
                <docgen category='Counter Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CounterLayoutRenderer.Sequence">
                <summary>
                Gets or sets the name of the sequence. Different named sequences can have individual values.
                </summary>
                <docgen category='Counter Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.CounterLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.CurrentDirLayoutRenderer">
                <summary>
                The current working directory of the application.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.CurrentDirLayoutRenderer.File">
                <summary>
                Gets or sets the name of the file to be Path.Combine()'d with the current directory.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.CurrentDirLayoutRenderer.Dir">
                <summary>
                Gets or sets the name of the directory to be Path.Combine()'d with the current directory.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.CurrentDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.CurrentDirLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.DateLayoutRenderer">
                <summary>
                Current date and time.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.DateLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.DateLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.DateLayoutRenderer.Culture">
                <summary>
                Gets or sets the culture used for rendering. 
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.DateLayoutRenderer.Format">
                <summary>
                Gets or sets the date format. Can be any argument accepted by DateTime.ToString(format).
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.DateLayoutRenderer.UniversalTime">
                <summary>
                Gets or sets a value indicating whether to output UTC time instead of local time.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.DateLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.DateLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.DateLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.DbNullLayoutRenderer">
                <summary>
                DB null for a database
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.DbNullLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.DbNullLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.EnvironmentLayoutRenderer">
                <summary>
                The environment variable.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.EnvironmentLayoutRenderer.Variable">
                <summary>
                Gets or sets the name of the environment variable.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.EnvironmentLayoutRenderer.Default">
                <summary>
                Gets or sets the default value to be used when the environment variable is not set.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.EnvironmentLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.EnvironmentLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.EventContextLayoutRenderer">
                <summary>
                Log event context data.
                </summary>
                <remarks>This class was marked as obsolete on NLog 2.0 and it may be removed in a future release.</remarks>
            </member>
            <member name="P:NLog.LayoutRenderers.EventContextLayoutRenderer.Item">
                <summary>
                Gets or sets the name of the item.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.EventContextLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified log event context item and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.EventPropertiesLayoutRenderer">
                <summary>
                Log event context data. See <see cref="P:NLog.LogEventInfo.Properties"/>.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Item">
                <summary>
                Gets or sets the name of the item.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Format">
                <summary>
                Format string for conversion from object to string.
                </summary>
                <docgen category='Rendering Options' order='50' />
            </member>
            <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Culture">
                <summary>
                Gets or sets the culture used for rendering. 
                </summary>
                <docgen category='Rendering Options' order='100' />
            </member>
            <member name="M:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.ExceptionLayoutRenderer">
                <summary>
                Exception information provided through 
                a call to one of the Logger.*Exception() methods.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ExceptionLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Format">
                <summary>
                Gets or sets the format of the output. Must be a comma-separated list of exception
                properties: Message, Type, ShortType, ToString, Method, StackTrace.
                This parameter value is case-insensitive.
                </summary>
                <see cref="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Formats"/>
                <see cref="T:NLog.Config.ExceptionRenderingFormat"/>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.InnerFormat">
                <summary>
                Gets or sets the format of the output of inner exceptions. Must be a comma-separated list of exception
                properties: Message, Type, ShortType, ToString, Method, StackTrace.
                This parameter value is case-insensitive.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Separator">
                <summary>
                Gets or sets the separator used to concatenate parts specified in the Format.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.ExceptionDataSeparator">
                <summary>
                Gets or sets the separator used to concatenate exception data specified in the Format.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.MaxInnerExceptionLevel">
                <summary>
                Gets or sets the maximum number of inner exceptions to include in the output.
                By default inner exceptions are not enabled for compatibility with NLog 1.0.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.InnerExceptionSeparator">
                <summary>
                Gets or sets the separator between inner exceptions.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Formats">
                <summary>
                 Gets the formats of the output of inner exceptions to be rendered in target.
                </summary>
                <docgen category='Rendering Options' order='10' />
                <see cref="T:NLog.Config.ExceptionRenderingFormat"/>
            </member>
            <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.InnerFormats">
                <summary>
                 Gets the formats of the output to be rendered in target.
                </summary>
                <docgen category='Rendering Options' order='10' />
                <see cref="T:NLog.Config.ExceptionRenderingFormat"/>
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendMessage(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the Message of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The exception containing the Message to append.</param>        
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendMethod(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the method name from Exception's stack trace to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose method name should be appended.</param>        
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendStackTrace(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the stack trace from an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose stack trace should be appended.</param>        
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendToString(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the result of calling ToString() on an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose call to ToString() should be appended.</param>       
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendType(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the type of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose type should be appended.</param>        
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendShortType(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the short type of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose short type should be appended.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendData(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends the contents of an Exception's Data property to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose Data property elements should be appended.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendSerializeObject(System.Text.StringBuilder,System.Exception)">
                <summary>
                Appends all the serialized properties of an Exception into the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="ex">The Exception whose properties should be appended.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.CompileFormat(System.String)">
                <summary>
                Split the string and then compile into list of Rendering formats.
                </summary>
                <param name="formatSpecifier"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.LayoutRenderers.FileContentsLayoutRenderer">
                <summary>
                Renders contents of the specified file.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.FileContentsLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.FileContentsLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.FileContentsLayoutRenderer.FileName">
                <summary>
                Gets or sets the name of the file.
                </summary>
                <docgen category='File Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.FileContentsLayoutRenderer.Encoding">
                <summary>
                Gets or sets the encoding used in the file.
                </summary>
                <value>The encoding.</value>
                <docgen category='File Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.FileContentsLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the contents of the specified file and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.FuncLayoutRenderer">
                <summary>
                A layout renderer which could have different behavior per instance by using a <see cref="T:System.Func`1"/>.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.FuncLayoutRenderer.#ctor(System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object})">
                <summary>
                Create a new.
                </summary>
                <param name="layoutRendererName">Name without ${}.</param>
                <param name="renderMethod">Method that renders the layout.</param>
            </member>
            <member name="P:NLog.LayoutRenderers.FuncLayoutRenderer.LayoutRendererName">
                <summary>
                Name used in config without ${}. E.g. "test" could be used as "${test}".
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.FuncLayoutRenderer.RenderMethod">
                <summary>
                Method that renders the layout. 
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.FuncLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.GarbageCollectorInfoLayoutRenderer">
                <summary>
                The information about the garbage collector.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.GarbageCollectorInfoLayoutRenderer.Property">
                <summary>
                Gets or sets the property to retrieve.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.GarbageCollectorInfoLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.GarbageCollectorProperty">
                <summary>
                Gets or sets the property of System.GC to retrieve.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.TotalMemory">
                <summary>
                Total memory allocated.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.TotalMemoryForceCollection">
                <summary>
                Total memory allocated (perform full garbage collection first).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.CollectionCount0">
                <summary>
                Gets the number of Gen0 collections.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.CollectionCount1">
                <summary>
                Gets the number of Gen1 collections.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.CollectionCount2">
                <summary>
                Gets the number of Gen2 collections.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.MaxGeneration">
                <summary>
                Maximum generation number supported by GC.
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.GdcLayoutRenderer">
                <summary>
                Global Diagnostics Context item. Provided for compatibility with log4net.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.GdcLayoutRenderer.Item">
                <summary>
                Gets or sets the name of the item.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.GdcLayoutRenderer.Format">
                <summary>
                Format string for conversion from object to string.
                </summary>
                <docgen category='Rendering Options' order='50' />
            </member>
            <member name="M:NLog.LayoutRenderers.GdcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.GdcLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.GdcLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.GuidLayoutRenderer">
                <summary>
                Globally-unique identifier (GUID).
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.GuidLayoutRenderer.Format">
                <summary>
                Gets or sets the GUID format as accepted by Guid.ToString() method.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.GuidLayoutRenderer.GeneratedFromLogEvent">
                <summary>
                Generate the Guid from the NLog LogEvent (Will be the same for all targets)
                </summary>
                <docgen category='Rendering Options' order='100' />
            </member>
            <member name="M:NLog.LayoutRenderers.GuidLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.GuidLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.GuidLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.HostNameLayoutRenderer">
                <summary>
                The host name that the process is running on.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.GetHostName">
                <summary>
                Gets the host name and falls back to computer name if not available
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.TryLookupValue(System.Func{System.String},System.String)">
                <summary>
                Tries the lookup value.
                </summary>
                <param name="lookupFunc">The lookup function.</param>
                <param name="lookupType">Type of the lookup.</param>
                <returns></returns>
            </member>
            <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.IdentityLayoutRenderer">
                <summary>
                Thread identity information (name and authentication information).
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.Separator">
                <summary>
                Gets or sets the separator to be used when concatenating 
                parts of identity information.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.Name">
                <summary>
                Gets or sets a value indicating whether to render Thread.CurrentPrincipal.Identity.Name.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.AuthType">
                <summary>
                Gets or sets a value indicating whether to render Thread.CurrentPrincipal.Identity.AuthenticationType.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.IsAuthenticated">
                <summary>
                Gets or sets a value indicating whether to render Thread.CurrentPrincipal.Identity.IsAuthenticated.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.IdentityLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.InstallContextLayoutRenderer">
                <summary>
                Installation parameter (passed to InstallNLogConfig).
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.InstallContextLayoutRenderer.Parameter">
                <summary>
                Gets or sets the name of the parameter.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.InstallContextLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified installation parameter and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.LayoutRenderer">
                <summary>
                Render environmental information related to logging events.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.LayoutRenderer.LoggingConfiguration">
                <summary>
                Gets the logging configuration this target is part of.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.ToString">
                <summary>
                Returns a <see cref="T:System.String"/> that represents this instance.
                </summary>
                <returns>
                A <see cref="T:System.String"/> that represents this instance.
                </returns>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Render(NLog.LogEventInfo)">
                <summary>
                Renders the the value of layout renderer in the context of the specified log event.
                </summary>
                <param name="logEvent">The log event.</param>
                <returns>String representation of a layout renderer.</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.NLog#Internal#ISupportsInitialize#Initialize(NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes this instance.
                </summary>
                <param name="configuration">The configuration.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.NLog#Internal#ISupportsInitialize#Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Initialize(NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes this instance.
                </summary>
                <param name="configuration">The configuration.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.RenderAppendBuilder(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the value of layout renderer in the context of the specified log event.
                </summary>
                <param name="logEvent">The log event.</param>
                <param name="builder">The layout render output is appended to builder</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the value of layout renderer in the context of the specified log event into <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.CloseLayoutRenderer">
                <summary>
                Closes the layout renderer.
                </summary>      
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Dispose(System.Boolean)">
                <summary>
                Releases unmanaged and - optionally - managed resources.
                </summary>
                <param name="disposing">True to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.GetFormatProvider(NLog.LogEventInfo,System.IFormatProvider)">
                <summary>
                Get the <see cref="T:System.IFormatProvider"/> for rendering the messages to a <see cref="T:System.String"/>
                </summary>
                <param name="logEvent">LogEvent with culture</param>
                <param name="layoutCulture">Culture in on Layout level</param>
                <returns></returns>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.GetCulture(NLog.LogEventInfo,System.Globalization.CultureInfo)">
                <summary>
                Get the <see cref="T:System.Globalization.CultureInfo"/> for rendering the messages to a <see cref="T:System.String"/>, needed for date and number formats
                </summary>
                <param name="logEvent">LogEvent with culture</param>
                <param name="layoutCulture">Culture in on Layout level</param>
                <returns></returns>
                <remarks>
                <see cref="M:NLog.LayoutRenderers.LayoutRenderer.GetFormatProvider(NLog.LogEventInfo,System.IFormatProvider)"/> is preferred
                </remarks>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register``1(System.String)">
                <summary>
                Register a custom layout renderer.
                </summary>
                <remarks>Short-cut for registing to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
                <typeparam name="T"> Type of the layout renderer.</typeparam>
                <param name="name"> Name of the layout renderer - without ${}.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(System.String,System.Type)">
                <summary>
                Register a custom layout renderer.
                </summary>
                <remarks>Short-cut for registing to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
                <param name="layoutRendererType"> Type of the layout renderer.</param>
                <param name="name"> Name of the layout renderer - without ${}.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(System.String,System.Func{NLog.LogEventInfo,System.Object})">
                <summary>
                Register a custom layout renderer with a callback function <paramref name="func"/>. The callback recieves the logEvent.
                </summary>
                <param name="name">Name of the layout renderer - without ${}.</param>
                <param name="func">Callback that returns the value for the layout renderer.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object})">
                <summary>
                Register a custom layout renderer with a callback function <paramref name="func"/>. The callback recieves the logEvent and the current configuration.
                </summary>
                <param name="name">Name of the layout renderer - without ${}.</param>
                <param name="func">Callback that returns the value for the layout renderer.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.LayoutRendererAttribute">
                <summary>
                Marks class as a layout renderer and assigns a name to it.
                </summary>
                <remarks>This attribute is not required when registering the layout in the API.</remarks>
            </member>
            <member name="M:NLog.LayoutRenderers.LayoutRendererAttribute.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LayoutRendererAttribute" /> class.
                </summary>
                <param name="name">Name of the layout renderer, without the `${ }`</param>
            </member>
            <member name="T:NLog.LayoutRenderers.LevelFormat">
                <summary>
                Format of the ${level} layout renderer output.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.LevelFormat.Name">
                <summary>
                Render the full level name.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.LevelFormat.FirstCharacter">
                <summary>
                Render the first character of the level.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.LevelFormat.Ordinal">
                <summary>
                Render the ordinal (aka number) for the level.
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.LevelLayoutRenderer">
                <summary>
                The log level.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.LevelLayoutRenderer.Format">
                <summary>
                Gets or sets a value indicating the output format of the level.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.LevelLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.LevelLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.LevelLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.LiteralLayoutRenderer">
                <summary>
                A string literal.
                </summary>
                <remarks>
                This is used to escape '${' sequence 
                as ;${literal:text=${}'
                </remarks>
            </member>
            <member name="M:NLog.LayoutRenderers.LiteralLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.LiteralLayoutRenderer.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer" /> class.
                </summary>
                <param name="text">The literal text value.</param>
                <remarks>This is used by the layout compiler.</remarks>
            </member>
            <member name="P:NLog.LayoutRenderers.LiteralLayoutRenderer.Text">
                <summary>
                Gets or sets the literal text.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.LiteralLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified string literal and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer">
                <summary>
                XML event description compatible with log4j, Chainsaw and NLogViewer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppDomain)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNLogData">
                <summary>
                Gets or sets a value indicating whether to include NLog-specific extensions to log4j schema.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IndentXml">
                <summary>
                Gets or sets a value indicating whether the XML should use spaces for indentation.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.AppInfo">
                <summary>
                Gets or sets the AppInfo field. By default it's the friendly name of the current AppDomain.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeCallSite">
                <summary>
                Gets or sets a value indicating whether to include call site (class and method name) in the information sent over the network.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeSourceInfo">
                <summary>
                Gets or sets a value indicating whether to include source info (file name and line number) in the information sent over the network.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeMdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeMdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> stack.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NdlcItemSeparator">
                <summary>
                Gets or sets the NDLC item separator.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeAllProperties">
                <summary>
                Gets or sets the option to include all properties from the log events
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsContext"/> stack.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NdcItemSeparator">
                <summary>   
                Gets or sets the NDC item separator.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.LoggerName">
                <summary>
                Gets or sets the log4j:event logger-xml-attribute (Default ${logger})
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NLog#Internal#IUsesStackTrace#StackTraceUsage">
                <summary>
                Gets the level of stack trace information required by the implementing class.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the XML logging event and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.LoggerNameLayoutRenderer">
                <summary>
                The logger name.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.LoggerNameLayoutRenderer.ShortName">
                <summary>
                Gets or sets a value indicating whether to render short logger name (the part after the trailing dot character).
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.LoggerNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.LoggerNameLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.LongDateLayoutRenderer">
                <summary>
                The date and time in a long, sortable format yyyy-MM-dd HH:mm:ss.ffff.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.LongDateLayoutRenderer.UniversalTime">
                <summary>
                Gets or sets a value indicating whether to output UTC time instead of local time.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.LongDateLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the date in the long format (yyyy-MM-dd HH:mm:ss.ffff) and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.MachineNameLayoutRenderer">
                <summary>
                The machine name that the process is running on.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.MachineNameLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.MachineNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.MdcLayoutRenderer">
                <summary>
                Mapped Diagnostic Context item. Provided for compatibility with log4net.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.MdcLayoutRenderer.Item">
                <summary>
                Gets or sets the name of the item.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.MdcLayoutRenderer.Format">
                <summary>
                Format string for conversion from object to string.
                </summary>
                <docgen category='Rendering Options' order='50' />
            </member>
            <member name="M:NLog.LayoutRenderers.MdcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.MdcLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.MdlcLayoutRenderer">
                <summary>
                Mapped Diagnostic Logical Context item (based on CallContext).
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.MdlcLayoutRenderer.Item">
                <summary>
                Gets or sets the name of the item.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.MdlcLayoutRenderer.Format">
                <summary>
                Format string for conversion from object to string.
                </summary>
                <docgen category='Rendering Options' order='50' />
            </member>
            <member name="M:NLog.LayoutRenderers.MdlcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.MdlcLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.MessageLayoutRenderer">
                <summary>
                The formatted log message.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.MessageLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.MessageLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.MessageLayoutRenderer.WithException">
                <summary>
                Gets or sets a value indicating whether to log exception along with message.
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.MessageLayoutRenderer.ExceptionSeparator">
                <summary>
                Gets or sets the string that separates message from the exception.
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.MessageLayoutRenderer.Raw">
                <summary>
                Gets or sets whether it should render the raw message without formatting parameters
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.MessageLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.MessageLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.NdcLayoutRenderer">
                <summary>
                Nested Diagnostic Context item. Provided for compatibility with log4net.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.NdcLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.NdcLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.NdcLayoutRenderer.TopFrames">
                <summary>
                Gets or sets the number of top stack frames to be rendered.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NdcLayoutRenderer.BottomFrames">
                <summary>
                Gets or sets the number of bottom stack frames to be rendered.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NdcLayoutRenderer.Separator">
                <summary>
                Gets or sets the separator to be used for concatenating nested diagnostics context output.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.NdcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified Nested Diagnostics Context item and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.NdlcLayoutRenderer">
                <summary>
                <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> Renderer (Async scope)
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.NdlcLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.NdlcLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.NdlcLayoutRenderer.TopFrames">
                <summary>
                Gets or sets the number of top stack frames to be rendered.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NdlcLayoutRenderer.BottomFrames">
                <summary>
                Gets or sets the number of bottom stack frames to be rendered.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NdlcLayoutRenderer.Separator">
                <summary>
                Gets or sets the separator to be used for concatenating nested logical context output.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.NdlcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified Nested Logical Context item and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.NdlcTimingLayoutRenderer">
                <summary>
                <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> Timing Renderer (Async scope)
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.CurrentScope">
                <summary>
                Gets or sets whether to only include the duration of the last scope created
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.ScopeBeginTime">
                <summary>
                Gets or sets whether to just display the scope creation time, and not the duration
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.Format">
                <summary>
                Gets or sets the TimeSpan format. Can be any argument accepted by TimeSpan.ToString(format).
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the timing details of the Nested Logical Context item and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.NewLineLayoutRenderer">
                <summary>
                A newline literal.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.NewLineLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified string literal and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.NLogDirLayoutRenderer">
                <summary>
                The directory where NLog.dll is located.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.#cctor">
                <summary>
                Initializes static members of the NLogDirLayoutRenderer class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.NLogDirLayoutRenderer.File">
                <summary>
                Gets or sets the name of the file to be Path.Combine()'d with the directory name.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.NLogDirLayoutRenderer.Dir">
                <summary>
                Gets or sets the name of the directory to be Path.Combine()'d with the directory name.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.CloseLayoutRenderer">
                <summary>
                Closes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the directory where NLog is located and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer">
                <summary>
                The performance counter.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.Category">
                <summary>
                Gets or sets the name of the counter category.
                </summary>
                <docgen category='Performance Counter Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.Counter">
                <summary>
                Gets or sets the name of the performance counter.
                </summary>
                <docgen category='Performance Counter Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.Instance">
                <summary>
                Gets or sets the name of the performance counter instance (e.g. this.Global_).
                </summary>
                <docgen category='Performance Counter Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.MachineName">
                <summary>
                Gets or sets the name of the machine to read the performance counter from.
                </summary>
                <docgen category='Performance Counter Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.Format">
                <summary>
                Format string for conversion from float to string.
                </summary>
                <docgen category='Rendering Options' order='50' />
            </member>
            <member name="P:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.Culture">
                <summary>
                Gets or sets the culture used for rendering. 
                </summary>
                <docgen category='Rendering Options' order='100' />
            </member>
            <member name="M:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.GetCurrentProcessInstanceName(System.String)">
                <summary>
                If having multiple instances with the same process-name, then they will get different instance names
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.CloseLayoutRenderer">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.PerformanceCounterLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.ProcessIdLayoutRenderer">
                <summary>
                The identifier of the current process.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessIdLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.ProcessInfoLayoutRenderer">
                <summary>
                The information about the running process.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Property">
                <summary>
                Gets or sets the property to retrieve.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Format">
                <summary>
                Gets or sets the format-string to use if the property supports it (Ex. DateTime / TimeSpan / Enum)
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.CloseLayoutRenderer">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.ProcessInfoProperty">
                <summary>
                Property of System.Diagnostics.Process to retrieve.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.BasePriority">
                <summary>
                Base Priority.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.ExitCode">
                <summary>
                Exit Code.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.ExitTime">
                <summary>
                Exit Time.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.Handle">
                <summary>
                Process Handle.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.HandleCount">
                <summary>
                Handle Count.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.HasExited">
                <summary>
                Whether process has exited.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.Id">
                <summary>
                Process ID.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MachineName">
                <summary>
                Machine name.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MainWindowHandle">
                <summary>
                Handle of the main window.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MainWindowTitle">
                <summary>
                Title of the main window.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MaxWorkingSet">
                <summary>
                Maximum Working Set.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MinWorkingSet">
                <summary>
                Minimum Working Set.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.NonPagedSystemMemorySize">
                <summary>
                Non-paged System Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.NonPagedSystemMemorySize64">
                <summary>
                Non-paged System Memory Size (64-bit).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedMemorySize">
                <summary>
                Paged Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedMemorySize64">
                <summary>
                Paged Memory Size (64-bit)..
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedSystemMemorySize">
                <summary>
                Paged System Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedSystemMemorySize64">
                <summary>
                Paged System Memory Size (64-bit).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakPagedMemorySize">
                <summary>
                Peak Paged Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakPagedMemorySize64">
                <summary>
                Peak Paged Memory Size (64-bit).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakVirtualMemorySize">
                <summary>
                Peak Virtual Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakVirtualMemorySize64">
                <summary>
                Peak Virtual Memory Size (64-bit)..
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakWorkingSet">
                <summary>
                Peak Working Set Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakWorkingSet64">
                <summary>
                Peak Working Set Size (64-bit).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PriorityBoostEnabled">
                <summary>
                Whether priority boost is enabled.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PriorityClass">
                <summary>
                Priority Class.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PrivateMemorySize">
                <summary>
                Private Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PrivateMemorySize64">
                <summary>
                Private Memory Size (64-bit).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PrivilegedProcessorTime">
                <summary>
                Privileged Processor Time.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.ProcessName">
                <summary>
                Process Name.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.Responding">
                <summary>
                Whether process is responding.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.SessionId">
                <summary>
                Session ID.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.StartTime">
                <summary>
                Process Start Time.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.TotalProcessorTime">
                <summary>
                Total Processor Time.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.UserProcessorTime">
                <summary>
                User Processor Time.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.VirtualMemorySize">
                <summary>
                Virtual Memory Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.VirtualMemorySize64">
                <summary>
                Virtual Memory Size (64-bit).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.WorkingSet">
                <summary>
                Working Set Size.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.WorkingSet64">
                <summary>
                Working Set Size (64-bit).
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.ProcessNameLayoutRenderer">
                <summary>
                The name of the current process.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.ProcessNameLayoutRenderer.FullName">
                <summary>
                Gets or sets a value indicating whether to write the full path to the process executable.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the current process name (optionally with a full path).
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.ProcessTimeLayoutRenderer">
                <summary>
                The process time in format HH:mm:ss.mmm.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.Invariant">
                <summary>
                Gets or sets a value indicating whether to output in culture invariant format
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.WritetTimestamp(System.Text.StringBuilder,System.TimeSpan,System.Globalization.CultureInfo)">
                <summary>
                Write timestamp to builder with format hh:mm:ss:fff
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer">
                <summary>
                High precision timer, based on the value returned from QueryPerformanceCounter() optionally converted to seconds.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.Normalize">
                <summary>
                Gets or sets a value indicating whether to normalize the result by subtracting 
                it from the result of the first call (so that it's effectively zero-based).
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.Difference">
                <summary>
                Gets or sets a value indicating whether to output the difference between the result 
                of QueryPerformanceCounter and the previous one.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.Seconds">
                <summary>
                Gets or sets a value indicating whether to convert the result to seconds by dividing 
                by the result of QueryPerformanceFrequency().
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.Precision">
                <summary>
                Gets or sets the number of decimal digits to be included in output.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.AlignDecimalPoint">
                <summary>
                Gets or sets a value indicating whether to align decimal point (emit non-significant zeros).
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.QueryPerformanceCounterLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.RegistryLayoutRenderer">
                <summary>
                A value from the Registry.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.RegistryLayoutRenderer.#ctor">
                <summary>
                Create new renderer
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.RegistryLayoutRenderer.Value">
                <summary>
                Gets or sets the registry value name.
                </summary>
                <docgen category='Registry Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.RegistryLayoutRenderer.DefaultValue">
                <summary>
                Gets or sets the value to be output when the specified registry key or value is not found.
                </summary>
                <docgen category='Registry Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.RegistryLayoutRenderer.RequireEscapingSlashesInDefaultValue">
                <summary>
                Require escaping backward slashes in <see cref="P:NLog.LayoutRenderers.RegistryLayoutRenderer.DefaultValue"/>. Need to be backwardscompatible.
                
                When true:
                
                `\` in value should be configured as `\\`
                `\\` in value should be configured as `\\\\`.
                </summary>
                <remarks>Default value wasn't a Layout before and needed an escape of the slash</remarks>
                <docgen category='Registry Options' order='50' />
            </member>
            <member name="P:NLog.LayoutRenderers.RegistryLayoutRenderer.View">
                <summary>
                Gets or sets the registry view (see: https://msdn.microsoft.com/de-de/library/microsoft.win32.registryview.aspx). 
                Allowed values: Registry32, Registry64, Default 
                </summary>
                <docgen category='Registry Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.RegistryLayoutRenderer.Key">
                 <summary>
                 Gets or sets the registry key.
                 </summary>
                 <example>
                 HKCU\Software\NLogTest
                 </example>
                 <remarks>
                 Possible keys:
                 <ul>
                <li>HKEY_LOCAL_MACHINE</li>
                <li>HKLM</li>
                <li>HKEY_CURRENT_USER</li>
                <li>HKCU</li>
                <li>HKEY_CLASSES_ROOT</li>
                <li>HKEY_USERS</li>
                <li>HKEY_CURRENT_CONFIG</li>
                <li>HKEY_DYN_DATA</li>
                <li>HKEY_PERFORMANCE_DATA</li>
                 </ul>
                 </remarks>
                 <docgen category='Registry Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.RegistryLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Reads the specified registry key and value and appends it to
                the passed <see cref="T:System.Text.StringBuilder"/>.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event. Ignored.</param>
            </member>
            <member name="P:NLog.LayoutRenderers.RegistryLayoutRenderer.ParseResult.HasSubKey">
                <summary>
                Has <see cref="P:NLog.LayoutRenderers.RegistryLayoutRenderer.ParseResult.SubKey"/>?
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.RegistryLayoutRenderer.ParseKey(System.String)">
                <summary>
                Parse key to <see cref="T:Microsoft.Win32.RegistryHive"/> and subkey.
                </summary>
                <param name="key">full registry key name</param>
                <returns>Result of parsing, never <c>null</c>.</returns>
            </member>
            <member name="F:NLog.LayoutRenderers.RegistryLayoutRenderer.HiveAliases">
                <summary>
                Aliases for the hives. See https://msdn.microsoft.com/en-us/library/ctb3kd86(v=vs.110).aspx
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.SequenceIdLayoutRenderer">
                <summary>
                The sequence ID
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.SequenceIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.SequenceIdLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.ShortDateLayoutRenderer">
                <summary>
                The short date in a sortable format yyyy-MM-dd.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.ShortDateLayoutRenderer.UniversalTime">
                <summary>
                Gets or sets a value indicating whether to output UTC time instead of local time.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.ShortDateLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the current short date string (yyyy-MM-dd) and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.SpecialFolderLayoutRenderer">
                <summary>
                System special folder path (includes My Documents, My Music, Program Files, Desktop, and more).
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.Folder">
                <summary>
                Gets or sets the system special folder to use.
                </summary>
                <remarks>
                Full list of options is available at <a href="https://docs.microsoft.com/en-us/dotnet/api/system.environment.specialfolder">MSDN</a>.
                The most common ones are:
                <ul>
                <li><b>ApplicationData</b> - roaming application data for current user.</li>
                <li><b>CommonApplicationData</b> - application data for all users.</li>
                <li><b>MyDocuments</b> - My Documents</li>
                <li><b>DesktopDirectory</b> - Desktop directory</li>
                <li><b>LocalApplicationData</b> - non roaming application data</li>
                <li><b>Personal</b> - user profile directory</li>
                <li><b>System</b> - System directory</li>
                </ul>
                </remarks>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.File">
                <summary>
                Gets or sets the name of the file to be Path.Combine()'d with the directory name.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.Dir">
                <summary>
                Gets or sets the name of the directory to be Path.Combine()'d with the directory name.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the directory where NLog is located and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.StackTraceFormat">
                <summary>
                Format of the ${stacktrace} layout renderer output.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.StackTraceFormat.Raw">
                <summary>
                Raw format (multiline - as returned by StackFrame.ToString() method).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.StackTraceFormat.Flat">
                <summary>
                Flat format (class and method names displayed in a single line).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.StackTraceFormat.DetailedFlat">
                <summary>
                Detailed flat format (method signatures displayed in a single line).
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.StackTraceLayoutRenderer">
                <summary>
                Stack trace renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.StackTraceLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.StackTraceLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.Format">
                <summary>
                Gets or sets the output format of the stack trace.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.TopFrames">
                <summary>
                Gets or sets the number of top stack frames to be rendered.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.SkipFrames">
                <summary>
                Gets or sets the number of frames to skip.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.Separator">
                <summary>
                Gets or sets the stack frame separator string.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.NLog#Internal#IUsesStackTrace#StackTraceUsage">
                <summary>
                Gets the level of stack trace information required by the implementing class.
                </summary>
                <value></value>
            </member>
            <member name="M:NLog.LayoutRenderers.StackTraceLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the call site and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.TempDirLayoutRenderer">
                <summary>
                A temporary directory.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.TempDirLayoutRenderer.File">
                <summary>
                Gets or sets the name of the file to be Path.Combine()'d with the directory name.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.TempDirLayoutRenderer.Dir">
                <summary>
                Gets or sets the name of the directory to be Path.Combine()'d with the directory name.
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.TempDirLayoutRenderer.InitializeLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.TempDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the directory where NLog is located and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.ThreadIdLayoutRenderer">
                <summary>
                The identifier of the current thread.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.ThreadIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.ThreadNameLayoutRenderer">
                <summary>
                The name of the current thread.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.ThreadNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.TicksLayoutRenderer">
                <summary>
                The Ticks value of current date and time.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.TicksLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.TicksLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.TimeLayoutRenderer">
                <summary>
                The time in a 24-hour, sortable format HH:mm:ss.mmmm.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.TimeLayoutRenderer.UniversalTime">
                <summary>
                Gets or sets a value indicating whether to output UTC time instead of local time.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.TimeLayoutRenderer.Invariant">
                <summary>
                Gets or sets a value indicating whether to output in culture invariant format
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.TimeLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.TimeLayoutRenderer.NLog#Internal#IRawValue#TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.TraceActivityIdLayoutRenderer">
                <summary>
                A renderer that puts into log a System.Diagnostics trace correlation id.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.TraceActivityIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.LayoutRenderers.TraceActivityIdLayoutRenderer.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="T:NLog.LayoutRenderers.VariableLayoutRenderer">
                <summary>
                Render a NLog variable (xml or config)
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.VariableLayoutRenderer.Name">
                <summary>
                Gets or sets the name of the NLog variable.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.VariableLayoutRenderer.Default">
                <summary>
                Gets or sets the default value to be used when the variable is not set.
                </summary>
                <remarks>Not used if Name is <c>null</c></remarks>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.VariableLayoutRenderer.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.VariableLayoutRenderer.TryGetLayout([email protected])">
                <summary>
                Try get the 
                </summary>
                <param name="layout"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.LayoutRenderers.VariableLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the specified variable and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.WindowsIdentityLayoutRenderer">
                <summary>
                Thread Windows identity information (username).
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.WindowsIdentityLayoutRenderer.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.WindowsIdentityLayoutRenderer" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.WindowsIdentityLayoutRenderer.Domain">
                <summary>
                Gets or sets a value indicating whether domain name should be included.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.WindowsIdentityLayoutRenderer.UserName">
                <summary>
                Gets or sets a value indicating whether username should be included.
                </summary>
                <docgen category='Rendering Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.WindowsIdentityLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the current thread windows identity information and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper">
                <summary>
                Applies caching to another layout output.
                </summary>
                <remarks>
                The value of the inner layout will be rendered only once and reused subsequently.
                </remarks>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption">
                <summary>
                A value indicating when the cache is cleared.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption.None">
                <summary>Never clear the cache.</summary>
            </member>
            <member name="F:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption.OnInit">
                <summary>Clear the cache whenever the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> is initialized.</summary>
            </member>
            <member name="F:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption.OnClose">
                <summary>Clear the cache whenever the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> is closed.</summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.Cached">
                <summary>
                Gets or sets a value indicating whether this <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> is enabled.
                </summary>
                <docgen category='Caching Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCache">
                <summary>
                Gets or sets a value indicating when the cache is cleared.
                </summary>
                <docgen category='Caching Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.CacheKey">
                <summary>
                Cachekey. If the cachekey changes, resets the value. For example, the cachekey would be the current day.s
                </summary>
                <docgen category='Caching Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.CloseLayoutRenderer">
                <summary>
                Closes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.Transform(System.String)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="text">Output to be transform.</param>
                <returns>Transformed text.</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.RenderInner(NLog.LogEventInfo)">
                <summary>
                Renders the inner layout contents.
                </summary>
                <param name="logEvent">The log event.</param>
                <returns>Contents of inner layout.</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.NLog#Internal#IStringValueRenderer#GetFormattedString(NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper">
                <summary>
                Filters characters not allowed in the file names by replacing them with safe character.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.FSNormalize">
                <summary>
                Gets or sets a value indicating whether to modify the output of this renderer so it can be used as a part of file path
                (illegal characters are replaced with '_').
                </summary>
                <docgen category='Advanced Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper">
                <summary>
                Escapes output of another layout using JSON rules.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.JsonEncode">
                <summary>
                Gets or sets a value indicating whether to apply JSON encoding.
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.EscapeUnicode">
                <summary>
                Gets or sets a value indicating whether to escape non-ascii characters
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper">
                <summary>
                Left part of a text
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.Length">
                <summary>
                Gets or sets the length in characters. 
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.Transform(System.String)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper">
                <summary>
                Converts the result of another layout output to lower case.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.Lowercase">
                <summary>
                Gets or sets a value indicating whether lower case conversion should be applied.
                </summary>
                <value>A value of <c>true</c> if lower case conversion should be applied; otherwise, <c>false</c>.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.Culture">
                <summary>
                Gets or sets the culture used for rendering. 
                </summary>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper">
                <summary>
                Left part of a text
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper.NoRawValue">
                <summary>
                Gets or sets a value indicating whether to disable the IRawValue-interface
                </summary>
                <value>A value of <c>true</c> if IRawValue-interface should be ignored; otherwise, <c>false</c>.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper.Transform(System.String)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper">
                <summary>
                Only outputs the inner layout when exception has been defined for log message.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper.Transform(System.String)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="text">Output to be transform.</param>
                <returns>Transformed text.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.PaddingHorizontalAlignment">
                <summary>
                Horizontal alignment for padding layout renderers.
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.Wrappers.PaddingHorizontalAlignment.Left">
                <summary>
                When layout text is too long, align it to the left
                (remove characters from the right).
                </summary>
            </member>
            <member name="F:NLog.LayoutRenderers.Wrappers.PaddingHorizontalAlignment.Right">
                <summary>
                When layout text is too long, align it to the right
                (remove characters from the left).
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper">
                <summary>
                Applies padding to another layout output.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.Padding">
                <summary>
                Gets or sets the number of characters to pad the output to. 
                </summary>
                <remarks>
                Positive padding values cause left padding, negative values 
                cause right padding to the desired width.
                </remarks>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.PadCharacter">
                <summary>
                Gets or sets the padding character.
                </summary>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.FixedLength">
                <summary>
                Gets or sets a value indicating whether to trim the 
                rendered text to the absolute value of the padding length.
                </summary>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.AlignmentOnTruncation">
                <summary>
                Gets or sets a value indicating whether a value that has
                been truncated (when <see cref="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.FixedLength" /> is true)
                will be left-aligned (characters removed from the right)
                or right-aligned (characters removed from the left). The
                default is left alignment.
                </summary>
                <docgen category='Transformation Options' order='10' />RegistryLayoutRenderer
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.Transform(System.String)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="text">Output to be transform.</param>
                <returns>Transformed text.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper">
                <summary>
                Replaces a string in the output of another layout with another string.
                </summary>
                <example>
                ${replace:searchFor=\\n+:replaceWith=-:regex=true:inner=${message}}
                </example>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.SearchFor">
                <summary>
                Gets or sets the text to search for.
                </summary>
                <value>The text search for.</value>
                <docgen category='Search/Replace Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Regex">
                <summary>
                Gets or sets a value indicating whether regular expressions should be used.
                </summary>
                <value>A value of <c>true</c> if regular expressions should be used otherwise, <c>false</c>.</value>
                <docgen category='Search/Replace Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.ReplaceWith">
                <summary>
                Gets or sets the replacement string.
                </summary>
                <value>The replacement string.</value>
                <docgen category='Search/Replace Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.ReplaceGroupName">
                <summary>
                Gets or sets the group name to replace when using regular expressions.
                Leave null or empty to replace without using group name.
                </summary>
                <value>The group name.</value>
                <docgen category='Search/Replace Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.IgnoreCase">
                <summary>
                Gets or sets a value indicating whether to ignore case.
                </summary>
                <value>A value of <c>true</c> if case should be ignored when searching; otherwise, <c>false</c>.</value>
                <docgen category='Search/Replace Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.WholeWords">
                <summary>
                Gets or sets a value indicating whether to search for whole words.
                </summary>
                <value>A value of <c>true</c> if whole words should be searched for; otherwise, <c>false</c>.</value>
                <docgen category='Search/Replace Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.InitializeLayoutRenderer">
                <summary>
                Initializes the layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Transform(System.String)">
                <summary>
                Post-processes the rendered message. 
                </summary>
                <param name="text">The text to be post-processed.</param>
                <returns>Post-processed text.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Replacer">
                <summary>
                This class was created instead of simply using a lambda expression so that the "ThreadAgnosticAttributeTest" will pass
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.ReplaceNamedGroup(System.String,System.String,System.String,System.Text.RegularExpressions.Match)">
                <summary>
                A match evaluator for Regular Expression based replacing
                </summary>
                <param name="input">Input string.</param>
                <param name="groupName">Group name in the regex.</param>
                <param name="replacement">Replace value.</param>
                <param name="match">Match from regex.</param>
                <returns>Groups replaced with <paramref name="replacement"/>.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper">
                <summary>
                Replaces newline characters from the result of another layout renderer with spaces.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.Replacement">
                <summary>
                Gets or sets a value indicating the string that should be used for separating lines.
                </summary>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper">
                <summary>
                Right part of a text
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper.Length">
                <summary>
                Gets or sets the length in characters. 
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper.Transform(System.String)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper">
                <summary>
                Decodes text "encrypted" with ROT-13.
                </summary>
                <remarks>
                See <a href="https://en.wikipedia.org/wiki/ROT13">https://en.wikipedia.org/wiki/ROT13</a>.
                </remarks>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.Text">
                <summary>
                Gets or sets the layout to be wrapped.
                </summary>
                <value>The layout to be wrapped.</value>
                <remarks>This variable is for backwards compatibility</remarks>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.DecodeRot13(System.String)">
                <summary>
                Encodes/Decodes ROT-13-encoded string.
                </summary>
                <param name="encodedValue">The string to be encoded/decoded.</param>
                <returns>Encoded/Decoded text.</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.DecodeRot13(System.Text.StringBuilder,System.Int32)">
                <summary>
                Encodes/Decodes ROT-13-encoded string.
                </summary>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper">
                <summary>
                Substring the result
                </summary>
                <example>
                ${substring:${level}:start=2:length=2}
                ${substring:${level}:start=-2:length=2}
                ${substring:Inner=${level}:start=2:length=2}
                </example>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.Start">
                <summary>
                Gets or sets the start index. 
                </summary>
                <value>Index</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.Length">
                <summary>
                Gets or sets the length in characters. If <c>null</c>, then the whole string
                </summary>
                <value>Index</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.Transform(System.String)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.CalcStart(System.Int32)">
                <summary>
                Calculate start position
                </summary>
                <returns>0 or positive number</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.CalcLength(System.Int32,System.Int32)">
                <summary>
                Calculate needed length
                </summary>
                <returns>0 or positive number</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper">
                <summary>
                Trims the whitespace from the result of another layout renderer.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.TrimWhiteSpace">
                <summary>
                Gets or sets a value indicating whether lower case conversion should be applied.
                </summary>
                <value>A value of <c>true</c> if lower case conversion should be applied; otherwise, <c>false</c>.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper">
                <summary>
                Converts the result of another layout output to upper case.
                </summary>
                <example>
                ${uppercase:${level}} //[DefaultParameter]
                ${uppercase:Inner=${level}} 
                ${level:uppercase} // [AmbientProperty]
                </example>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.Uppercase">
                <summary>
                Gets or sets a value indicating whether upper case conversion should be applied.
                </summary>
                <value>A value of <c>true</c> if upper case conversion should be applied otherwise, <c>false</c>.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.Culture">
                <summary>
                Gets or sets the culture used for rendering. 
                </summary>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper">
                <summary>
                Encodes the result of another layout output for use with URLs.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.SpaceAsPlus">
                <summary>
                Gets or sets a value indicating whether spaces should be translated to '+' or '%20'.
                </summary>
                <value>A value of <c>true</c> if space should be translated to '+'; otherwise, <c>false</c>.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.EscapeDataRfc3986">
                <summary>
                Gets or sets a value whether escaping be done according to Rfc3986 (Supports Internationalized Resource Identifiers - IRIs)
                </summary>
                <value>A value of <c>true</c> if Rfc3986; otherwise, <c>false</c> for legacy Rfc2396.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.EscapeDataNLogLegacy">
                <summary>
                Gets or sets a value whether escaping be done according to the old NLog style (Very non-standard)
                </summary>
                <value>A value of <c>true</c> if legacy encoding; otherwise, <c>false</c> for standard UTF8 encoding.</value>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.Transform(System.String)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="text">Output to be transform.</param>
                <returns>Transformed text.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper">
                <summary>
                Outputs alternative layout when the inner layout produces empty result.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.WhenEmpty">
                <summary>
                Gets or sets the layout to be rendered when original layout produced empty result.
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.InitializeLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper">
                <summary>
                Only outputs the inner layout when the specified condition has been met.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.When">
                <summary>
                Gets or sets the condition that must be met for the <see cref="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner"/> layout to be printed.
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.Else">
                <summary>
                If <see cref="P:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.When"/> is not met, print this layout.
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.TransformFormattedMesssage(System.Text.StringBuilder)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper">
                <summary>
                Replaces newline characters from the result of another layout renderer with spaces.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper.WrapLine">
                <summary>
                Gets or sets the line length for wrapping.
                </summary>
                <remarks>
                Only positive values are allowed
                </remarks>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper.Transform(System.String)">
                <summary>
                Post-processes the rendered message. 
                </summary>
                <param name="text">The text to be post-processed.</param>
                <returns>Post-processed text.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase">
                <summary>
                Base class for <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s which wrapping other <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s. 
                
                This has the <see cref="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner"/> property (which is default) and can be used to wrap.
                </summary>
                <example>
                ${uppercase:${level}} //[DefaultParameter]
                ${uppercase:Inner=${level}} 
                </example>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner">
                <summary>
                Gets or sets the wrapped layout.
                
                [DefaultParameter] so Inner: is not required if it's the first
                </summary>
                <docgen category='Transformation Options' order='10' />
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.InitializeLayoutRenderer">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
                <summary>
                Renders the inner message, processes it and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
                </summary>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="logEvent">Logging event.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <summary>
                Appends the rendered output from <see cref="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner"/>-layout and transforms the added output (when necessary)
                </summary>
                <param name="logEvent">Logging event.</param>
                <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
                <param name="orgLength">Start position for any necessary transformation of <see cref="T:System.Text.StringBuilder"/>.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Transform(NLog.LogEventInfo,System.String)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="logEvent">Logging event.</param>
                <param name="text">Output to be transform.</param>
                <returns>Transformed text.</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Transform(System.String)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="text">Output to be transform.</param>
                <returns>Transformed text.</returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.RenderInner(NLog.LogEventInfo)">
                <summary>
                Renders the inner layout contents.
                </summary>
                <param name="logEvent">The log event.</param>
                <returns>Contents of inner layout.</returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase">
                <summary>
                Base class for <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s which wrapping other <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s. 
                
                This expects the transformation to work on a <see cref="T:System.Text.StringBuilder"/>
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.TransformFormattedMesssage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="logEvent"></param>
                <param name="target">Output to be transform.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.TransformFormattedMesssage(System.Text.StringBuilder)">
                <summary>
                Transforms the output of another layout.
                </summary>
                <param name="target">Output to be transform.</param>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the inner layout contents.
                </summary>
                <param name="logEvent"></param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.Transform(System.String)">
                <summary>
                
                </summary>
                <param name="text"></param>
                <returns></returns>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.RenderInner(NLog.LogEventInfo)">
                <summary>
                
                </summary>
                <param name="logEvent"></param>
                <returns></returns>
            </member>
            <member name="T:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper">
                <summary>
                Converts the result of another layout output to be XML-compliant.
                </summary>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper" /> class.
                </summary>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.XmlEncode">
                <summary>
                Gets or sets a value indicating whether to apply XML encoding.
                </summary>
                <remarks>Ensures always valid XML, but gives a performance hit</remarks>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="P:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.XmlEncodeNewlines">
                <summary>
                Gets or sets a value indicating whether to tranform newlines (\r\n) into (&#13;&#10;)
                </summary>
                <docgen category="Transformation Options" order="10"/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
                <inheritdoc/>
            </member>
            <member name="M:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.Transform(System.String)">
                <inheritdoc/>
            </member>
            <member name="T:NLog.Layouts.CompoundLayout">
                <summary>
                A layout containing one or more nested layouts.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CompoundLayout.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.CompoundLayout"/> class.
                </summary>
            </member>
            <member name="P:NLog.Layouts.CompoundLayout.Layouts">
                <summary>
                Gets the inner layouts.
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="M:NLog.Layouts.CompoundLayout.InitializeLayout">
                <summary>
                Initializes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CompoundLayout.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Formats the log event relying on inner layouts.
                </summary>
                <param name="logEvent">The log event to be formatted.</param>
                <returns>A string representation of the log event.</returns>
            </member>
            <member name="M:NLog.Layouts.CompoundLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Formats the log event relying on inner layouts.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.Layouts.CompoundLayout.CloseLayout">
                <summary>
                Closes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CompoundLayout.ToString">
                <summary>
                Generate description of Compound Layout
                </summary>
                <returns>Compound Layout String Description</returns>
            </member>
            <member name="T:NLog.Layouts.CsvColumn">
                <summary>
                A column in the CSV.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CsvColumn.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.CsvColumn" /> class.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CsvColumn.#ctor(System.String,NLog.Layouts.Layout)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.CsvColumn" /> class.
                </summary>
                <param name="name">The name of the column.</param>
                <param name="layout">The layout of the column.</param>
            </member>
            <member name="P:NLog.Layouts.CsvColumn.Name">
                <summary>
                Gets or sets the name of the column.
                </summary>
                <docgen category='CSV Column Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvColumn.Layout">
                <summary>
                Gets or sets the layout of the column.
                </summary>
                <docgen category='CSV Column Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvColumn.Quoting">
                <summary>
                Gets or sets the override of Quoting mode
                </summary>
                <remarks>
                <see cref="F:NLog.Layouts.CsvQuotingMode.All"/> and <see cref="F:NLog.Layouts.CsvQuotingMode.Nothing"/> are faster than the default <see cref="F:NLog.Layouts.CsvQuotingMode.Auto"/>
                </remarks>
                <docgen category='CSV Column Options' order='10' />
            </member>
            <member name="T:NLog.Layouts.CsvColumnDelimiterMode">
                <summary>
                Specifies allowed column delimiters.
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Auto">
                <summary>
                Automatically detect from regional settings.
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Comma">
                <summary>
                Comma (ASCII 44).
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Semicolon">
                <summary>
                Semicolon (ASCII 59).
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Tab">
                <summary>
                Tab character (ASCII 9).
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Pipe">
                <summary>
                Pipe character (ASCII 124).
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Space">
                <summary>
                Space character (ASCII 32).
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Custom">
                <summary>
                Custom string, specified by the CustomDelimiter.
                </summary>
            </member>
            <member name="T:NLog.Layouts.CsvLayout">
                <summary>
                A specialized layout that renders CSV-formatted events.
                </summary>
                <remarks>If <see cref="P:NLog.Layouts.LayoutWithHeaderAndFooter.Header"/> is set, then the header generation with columnnames will be disabled.</remarks>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.CsvLayout"/> class.
                </summary>
            </member>
            <member name="P:NLog.Layouts.CsvLayout.Columns">
                <summary>
                Gets the array of parameters to be passed.
                </summary>
                <docgen category='CSV Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvLayout.WithHeader">
                <summary>
                Gets or sets a value indicating whether CVS should include header.
                </summary>
                <value>A value of <c>true</c> if CVS should include header; otherwise, <c>false</c>.</value>
                <docgen category='CSV Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvLayout.Delimiter">
                <summary>
                Gets or sets the column delimiter.
                </summary>
                <docgen category='CSV Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvLayout.Quoting">
                <summary>
                Gets or sets the quoting mode.
                </summary>
                <docgen category='CSV Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvLayout.QuoteChar">
                <summary>
                Gets or sets the quote Character.
                </summary>
                <docgen category='CSV Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.CsvLayout.CustomColumnDelimiter">
                <summary>
                Gets or sets the custom column delimiter value (valid when ColumnDelimiter is set to 'Custom').
                </summary>
                <docgen category='CSV Options' order='10' />
            </member>
            <member name="M:NLog.Layouts.CsvLayout.InitializeLayout">
                <summary>
                Initializes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Formats the log event for write.
                </summary>
                <param name="logEvent">The log event to be formatted.</param>
                <returns>A string representation of the log event.</returns>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Formats the log event for write.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.RenderHeader(System.Text.StringBuilder)">
                <summary>
                Get the headers with the column names.
                </summary>
                <returns></returns>
            </member>
            <member name="T:NLog.Layouts.CsvLayout.CsvHeaderLayout">
                <summary>
                Header with column names for CSV layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.#ctor(NLog.Layouts.CsvLayout)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.CsvLayout.CsvHeaderLayout"/> class.
                </summary>
                <param name="parent">The parent.</param>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <returns>The rendered layout.</returns>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.Layouts.CsvLayout.ToString">
                <summary>
                Generate description of CSV Layout
                </summary>
                <returns>CSV Layout String Description</returns>
            </member>
            <member name="T:NLog.Layouts.CsvQuotingMode">
                <summary>
                Specifies CSV quoting modes.
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvQuotingMode.All">
                <summary>
                Quote all column (Fast)
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvQuotingMode.Nothing">
                <summary>
                Quote nothing (Very fast)
                </summary>
            </member>
            <member name="F:NLog.Layouts.CsvQuotingMode.Auto">
                <summary>
                Quote only whose values contain the quote symbol or the separator (Slow)
                </summary>
            </member>
            <member name="T:NLog.Layouts.JsonAttribute">
                <summary>
                JSON attribute.
                </summary>
            </member>
            <member name="M:NLog.Layouts.JsonAttribute.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.JsonAttribute" /> class.
                </summary>
            </member>
            <member name="M:NLog.Layouts.JsonAttribute.#ctor(System.String,NLog.Layouts.Layout)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.JsonAttribute" /> class.
                </summary>
                <param name="name">The name of the attribute.</param>
                <param name="layout">The layout of the attribute's value.</param>
            </member>
            <member name="M:NLog.Layouts.JsonAttribute.#ctor(System.String,NLog.Layouts.Layout,System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.JsonAttribute" /> class.
                </summary>
                <param name="name">The name of the attribute.</param>
                <param name="layout">The layout of the attribute's value.</param>
                <param name="encode">Encode value with json-encode</param>
            </member>
            <member name="P:NLog.Layouts.JsonAttribute.Name">
                <summary>
                Gets or sets the name of the attribute.
                </summary>
                <docgen category='JSON Attribute Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonAttribute.Layout">
                <summary>
                Gets or sets the layout that will be rendered as the attribute's value.
                </summary>
                <docgen category='JSON Attribute Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonAttribute.Encode">
                <summary>
                Determines wether or not this attribute will be Json encoded.
                </summary>
                <docgen category='JSON Attribute Options' order='100' />
            </member>
            <member name="P:NLog.Layouts.JsonAttribute.EscapeUnicode">
                <summary>
                Gets or sets a value indicating whether to escape non-ascii characters
                </summary>
                <docgen category='JSON Attribute Options' order='100' />
            </member>
            <member name="P:NLog.Layouts.JsonAttribute.IncludeEmptyValue">
                <summary>
                Gets or sets whether an attribute with empty value should be included in the output
                </summary>
                <docgen category='JSON Attribute Options' order='100' />
            </member>
            <member name="T:NLog.Layouts.JsonLayout">
                <summary>
                A specialized layout that renders JSON-formatted events.
                </summary>
            </member>
            <member name="M:NLog.Layouts.JsonLayout.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.JsonLayout"/> class.
                </summary>
            </member>
            <member name="P:NLog.Layouts.JsonLayout.Attributes">
                <summary>
                Gets the array of attributes' configurations.
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.SuppressSpaces">
                <summary>
                Gets or sets the option to suppress the extra spaces in the output json
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.RenderEmptyObject">
                <summary>
                Gets or sets the option to render the empty object value {}
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.IncludeGdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.GlobalDiagnosticsContext"/> dictionary.
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.IncludeMdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.IncludeMdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.IncludeAllProperties">
                <summary>
                Gets or sets the option to include all properties from the log event (as JSON)
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.ExcludeProperties">
                <summary>
                List of property names to exclude when <see cref="P:NLog.Layouts.JsonLayout.IncludeAllProperties"/> is true
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.JsonLayout.MaxRecursionLimit">
                <summary>
                How far should the JSON serializer follow object references before backing off
                </summary>
                <docgen category='JSON Options' order='10' />
            </member>
            <member name="M:NLog.Layouts.JsonLayout.InitializeLayout">
                <summary>
                Initializes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.JsonLayout.CloseLayout">
                <summary>
                Closes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.JsonLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Formats the log event as a JSON document for writing.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.Layouts.JsonLayout.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Formats the log event as a JSON document for writing.
                </summary>
                <param name="logEvent">The log event to be formatted.</param>
                <returns>A JSON string representation of the log event.</returns>
            </member>
            <member name="M:NLog.Layouts.JsonLayout.ToString">
                <summary>
                Generate description of JSON Layout
                </summary>
                <returns>JSON Layout String Description</returns>
            </member>
            <member name="T:NLog.Layouts.Layout">
                <summary>
                Abstract interface that layouts must implement.
                </summary>
            </member>
            <member name="F:NLog.Layouts.Layout.IsInitialized">
                <summary>
                Is this layout initialized? See <see cref="M:NLog.Layouts.Layout.Initialize(NLog.Config.LoggingConfiguration)"/>
                </summary>
            </member>
            <member name="P:NLog.Layouts.Layout.ThreadAgnostic">
                <summary>
                Gets a value indicating whether this layout is thread-agnostic (can be rendered on any thread).
                </summary>
                <remarks>
                Layout is thread-agnostic if it has been marked with [ThreadAgnostic] attribute and all its children are
                like that as well.
                
                Thread-agnostic layouts only use contents of <see cref="T:NLog.LogEventInfo"/> for its output.
                </remarks>
            </member>
            <member name="P:NLog.Layouts.Layout.StackTraceUsage">
                <summary>
                Gets the level of stack trace information required for rendering.
                </summary>
            </member>
            <member name="P:NLog.Layouts.Layout.LoggingConfiguration">
                <summary>
                Gets the logging configuration this target is part of.
                </summary>
            </member>
            <member name="M:NLog.Layouts.Layout.op_Implicit(System.String)~NLog.Layouts.Layout">
                <summary>
                Converts a given text to a <see cref="T:NLog.Layouts.Layout" />.
                </summary>
                <param name="text">Text to be converted.</param>
                <returns><see cref="T:NLog.Layouts.SimpleLayout"/> object represented by the text.</returns>
            </member>
            <member name="M:NLog.Layouts.Layout.FromString(System.String)">
                <summary>
                Implicitly converts the specified string to a <see cref="T:NLog.Layouts.SimpleLayout"/>.
                </summary>
                <param name="layoutText">The layout string.</param>
                <returns>Instance of <see cref="T:NLog.Layouts.SimpleLayout"/>.</returns>
            </member>
            <member name="M:NLog.Layouts.Layout.FromString(System.String,NLog.Config.ConfigurationItemFactory)">
                <summary>
                Implicitly converts the specified string to a <see cref="T:NLog.Layouts.SimpleLayout"/>.
                </summary>
                <param name="layoutText">The layout string.</param>
                <param name="configurationItemFactory">The NLog factories to use when resolving layout renderers.</param>
                <returns>Instance of <see cref="T:NLog.Layouts.SimpleLayout"/>.</returns>
            </member>
            <member name="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)">
                <summary>
                Precalculates the layout for the specified log event and stores the result
                in per-log event cache.
                
                Only if the layout doesn't have [ThreadAgnostic] and doens't contain layouts with [ThreadAgnostic]. 
                </summary>
                <param name="logEvent">The log event.</param>
                <remarks>
                Calling this method enables you to store the log event in a buffer
                and/or potentially evaluate it in another thread even though the 
                layout may contain thread-dependent renderer.
                </remarks>
            </member>
            <member name="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo)">
                <summary>
                Renders the event info in layout.
                </summary>
                <param name="logEvent">The event info.</param>
                <returns>String representing log event.</returns>
            </member>
            <member name="M:NLog.Layouts.Layout.RenderAppendBuilder(NLog.LogEventInfo,System.Text.StringBuilder,System.Boolean)">
                <summary>
                Optimized version of <see cref="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo)"/> for internal Layouts. Works best
                when override of <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> is available.
                </summary>
                <param name="logEvent">The event info.</param>
                <param name="target">Appends the string representing log event to target</param>
                <param name="cacheLayoutResult">Should rendering result be cached on LogEventInfo</param>
            </member>
            <member name="M:NLog.Layouts.Layout.RenderAllocateBuilder(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Valid default implementation of <see cref="M:NLog.Layouts.Layout.GetFormattedMessage(NLog.LogEventInfo)" />, when having implemented the optimized <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/>
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="reusableBuilder">StringBuilder to help minimize allocations [optional].</param>
                <returns>The rendered layout.</returns>
            </member>
            <member name="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.Layouts.Layout.NLog#Internal#ISupportsInitialize#Initialize(NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes this instance.
                </summary>
                <param name="configuration">The configuration.</param>
            </member>
            <member name="M:NLog.Layouts.Layout.NLog#Internal#ISupportsInitialize#Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Layouts.Layout.Initialize(NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes this instance.
                </summary>
                <param name="configuration">The configuration.</param>
            </member>
            <member name="M:NLog.Layouts.Layout.Close">
                <summary>
                Closes this instance.
                </summary>
            </member>
            <member name="M:NLog.Layouts.Layout.InitializeLayout">
                <summary>
                Initializes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.Layout.CloseLayout">
                <summary>
                Closes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.Layout.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <returns>The rendered layout.</returns>
            </member>
            <member name="M:NLog.Layouts.Layout.Register``1(System.String)">
                <summary>
                Register a custom Layout.
                </summary>
                <remarks>Short-cut for registing to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
                <typeparam name="T"> Type of the Layout.</typeparam>
                <param name="name"> Name of the Layout.</param>
            </member>
            <member name="M:NLog.Layouts.Layout.Register(System.String,System.Type)">
                <summary>
                Register a custom Layout.
                </summary>
                <remarks>Short-cut for registing to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
                <param name="layoutType"> Type of the Layout.</param>
                <param name="name"> Name of the Layout.</param>
            </member>
            <member name="M:NLog.Layouts.Layout.PrecalculateBuilderInternal(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Optimized version of <see cref="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)"/> for internal Layouts, when
                override of <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> is available.
                </summary>
            </member>
            <member name="M:NLog.Layouts.Layout.TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <summary>
                Try get value
                </summary>
                <param name="logEvent"></param>
                <param name="rawValue">rawValue if return result is true</param>
                <returns>false if we could not determine the rawValue</returns>
            </member>
            <member name="T:NLog.Layouts.LayoutAttribute">
                <summary>
                Marks class as a layout renderer and assigns a format string to it.
                </summary>
            </member>
            <member name="M:NLog.Layouts.LayoutAttribute.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.LayoutAttribute" /> class.
                </summary>
                <param name="name">Layout name.</param>
            </member>
            <member name="T:NLog.Layouts.LayoutParser">
                <summary>
                Parses layout strings.
                </summary>
            </member>
            <member name="M:NLog.Layouts.LayoutParser.AddLiteral(System.Text.StringBuilder,System.Collections.Generic.List{NLog.LayoutRenderers.LayoutRenderer})">
                <summary>
                Add <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer"/> to <paramref name="result"/>
                </summary>
                <param name="literalBuf"></param>
                <param name="result"></param>
            </member>
            <member name="T:NLog.Layouts.LayoutWithHeaderAndFooter">
                <summary>
                A specialized layout that supports header and footer.
                </summary>
            </member>
            <member name="P:NLog.Layouts.LayoutWithHeaderAndFooter.Layout">
                <summary>
                Gets or sets the body layout (can be repeated multiple times).
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.LayoutWithHeaderAndFooter.Header">
                <summary>
                Gets or sets the header layout.
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.LayoutWithHeaderAndFooter.Footer">
                <summary>
                Gets or sets the footer layout.
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="M:NLog.Layouts.LayoutWithHeaderAndFooter.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <returns>The rendered layout.</returns>
            </member>
            <member name="M:NLog.Layouts.LayoutWithHeaderAndFooter.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result.</param>
            </member>
            <member name="T:NLog.Layouts.Log4JXmlEventLayout">
                <summary>
                A specialized layout that renders Log4j-compatible XML events.
                </summary>
                <remarks>
                This layout is not meant to be used explicitly. Instead you can use ${log4jxmlevent} layout renderer.
                </remarks>
            </member>
            <member name="M:NLog.Layouts.Log4JXmlEventLayout.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.Log4JXmlEventLayout" /> class.
                </summary>
            </member>
            <member name="P:NLog.Layouts.Log4JXmlEventLayout.Renderer">
                <summary>
                Gets the <see cref="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer"/> instance that renders log events.
                </summary>
            </member>
            <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeMdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeAllProperties">
                <summary>
                Gets or sets the option to include all properties from the log events
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeNdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsContext"/> stack.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeMdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeNdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> stack.
                </summary>
                <docgen category='Payload Options' order='10' />
            </member>
            <member name="M:NLog.Layouts.Log4JXmlEventLayout.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <returns>The rendered layout.</returns>
            </member>
            <member name="M:NLog.Layouts.Log4JXmlEventLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Renders the layout for the specified logging event by invoking layout renderers.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="T:NLog.Layouts.SimpleLayout">
                <summary>
                Represents a string with embedded placeholders that can render contextual information.
                </summary>
                <remarks>
                This layout is not meant to be used explicitly. Instead you can just use a string containing layout 
                renderers everywhere the layout is required.
                </remarks>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout" /> class.
                </summary>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.#ctor(System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout" /> class.
                </summary>
                <param name="txt">The layout string to parse.</param>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.#ctor(System.String,NLog.Config.ConfigurationItemFactory)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout"/> class.
                </summary>
                <param name="txt">The layout string to parse.</param>
                <param name="configurationItemFactory">The NLog factories to use when creating references to layout renderers.</param>
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.OriginalText">
                <summary>
                Original text before compile to Layout renderes
                </summary>
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.Text">
                <summary>
                Gets or sets the layout text.
                </summary>
                <docgen category='Layout Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.IsFixedText">
                <summary>
                Is the message fixed? (no Layout renderers used)
                </summary>
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.FixedText">
                <summary>
                Get the fixed text. Only set when <see cref="P:NLog.Layouts.SimpleLayout.IsFixedText"/> is <c>true</c>
                </summary>
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.IsSimpleStringText">
                <summary>
                Is the message a simple formatted string? (Can skip StringBuilder)
                </summary>
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.Renderers">
                <summary>
                Gets a collection of <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> objects that make up this layout.
                </summary>
            </member>
            <member name="P:NLog.Layouts.SimpleLayout.StackTraceUsage">
                <summary>
                Gets the level of stack trace information required for rendering.
                </summary>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.op_Implicit(System.String)~NLog.Layouts.SimpleLayout">
                <summary>
                Converts a text to a simple layout.
                </summary>
                <param name="text">Text to be converted.</param>
                <returns>A <see cref="T:NLog.Layouts.SimpleLayout"/> object.</returns>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.Escape(System.String)">
                <summary>
                Escapes the passed text so that it can
                be used literally in all places where
                layout is normally expected without being
                treated as layout.
                </summary>
                <param name="text">The text to be escaped.</param>
                <returns>The escaped text.</returns>
                <remarks>
                Escaping is done by replacing all occurrences of
                '${' with '${literal:text=${}'
                </remarks>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.Evaluate(System.String,NLog.LogEventInfo)">
                <summary>
                Evaluates the specified text by expanding all layout renderers.
                </summary>
                <param name="text">The text to be evaluated.</param>
                <param name="logEvent">Log event to be used for evaluation.</param>
                <returns>The input text with all occurrences of ${} replaced with
                values provided by the appropriate layout renderers.</returns>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.Evaluate(System.String)">
                <summary>
                Evaluates the specified text by expanding all layout renderers
                in new <see cref="T:NLog.LogEventInfo" /> context.
                </summary>
                <param name="text">The text to be evaluated.</param>
                <returns>The input text with all occurrences of ${} replaced with
                values provided by the appropriate layout renderers.</returns>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.ToString">
                <summary>
                Returns a <see cref="T:System.String"></see> that represents the current object.
                </summary>
                <returns>
                A <see cref="T:System.String"></see> that represents the current object.
                </returns>
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.InitializeLayout">
                <inheritdoc />
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.Precalculate(NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.TryGetRawValue(NLog.LogEventInfo,[email protected])">
                <inheritdoc />
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.GetFormattedMessage(NLog.LogEventInfo)">
                <inheritdoc />
            </member>
            <member name="M:NLog.Layouts.SimpleLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <inheritdoc />
            </member>
            <member name="T:NLog.Layouts.XmlAttribute">
                <summary>
                XML attribute.
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlAttribute.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.XmlAttribute" /> class.
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlAttribute.#ctor(System.String,NLog.Layouts.Layout)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.XmlAttribute" /> class.
                </summary>
                <param name="name">The name of the attribute.</param>
                <param name="layout">The layout of the attribute's value.</param>
            </member>
            <member name="M:NLog.Layouts.XmlAttribute.#ctor(System.String,NLog.Layouts.Layout,System.Boolean)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.XmlAttribute" /> class.
                </summary>
                <param name="name">The name of the attribute.</param>
                <param name="layout">The layout of the attribute's value.</param>
                <param name="encode">Encode value with xml-encode</param>
            </member>
            <member name="P:NLog.Layouts.XmlAttribute.Name">
                <summary>
                Gets or sets the name of the attribute.
                </summary>
                <docgen category='XML Attribute Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlAttribute.Layout">
                <summary>
                Gets or sets the layout that will be rendered as the attribute's value.
                </summary>
                <docgen category='XML Attribute Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlAttribute.Encode">
                <summary>
                Determines wether or not this attribute will be Xml encoded.
                </summary>
                <docgen category='XML Attribute Options' order='100' />
            </member>
            <member name="P:NLog.Layouts.XmlAttribute.IncludeEmptyValue">
                <summary>
                Gets or sets whether an attribute with empty value should be included in the output
                </summary>
                <docgen category='XML Attribute Options' order='100' />
            </member>
            <member name="T:NLog.Layouts.XmlElement">
                <summary>
                A XML Element
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlElement.#ctor">
                <inheritdoc />
            </member>
            <member name="M:NLog.Layouts.XmlElement.#ctor(System.String,NLog.Layouts.Layout)">
                <inheritdoc />
            </member>
            <member name="P:NLog.Layouts.XmlElement.Name">
                <summary>
                Name of the element
                </summary>
            </member>
            <member name="P:NLog.Layouts.XmlElement.Value">
                <summary>
                Value inside the element
                </summary>
            </member>
            <member name="T:NLog.Layouts.XmlElementBase">
                <summary>
                A specialized layout that renders XML-formatted events.
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlElementBase.#ctor(System.String,NLog.Layouts.Layout)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.XmlElementBase"/> class.
                </summary>
                <param name="elementName">The name of the top XML node</param>
                <param name="elementValue">The value of the top XML node</param>
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.ElementNameInternal">
                <summary>
                Name of the XML element
                </summary>
                <remarks>Upgrade to private protected when using C# 7.2 </remarks>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.ElementValueInternal">
                <summary>
                Value inside the XML element
                </summary>
                <remarks>Upgrade to private protected when using C# 7.2 </remarks>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.ElementEncode">
                <summary>
                Xml Encode the value for the XML element
                </summary>
                <remarks>Ensures always valid XML, but gives a performance hit</remarks>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.IndentXml">
                <summary>
                Auto indent and create new lines
                </summary>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.Elements">
                <summary>
                Gets the array of xml 'elements' configurations.
                </summary>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.Attributes">
                <summary>
                Gets the array of 'attributes' configurations for the element
                </summary>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.IncludeEmptyValue">
                <summary>
                Gets or sets whether a ElementValue with empty value should be included in the output
                </summary>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.IncludeMdc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
                </summary>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.IncludeMdlc">
                <summary>
                Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
                </summary>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.IncludeAllProperties">
                <summary>
                Gets or sets the option to include all properties from the log event (as XML)
                </summary>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.ExcludeProperties">
                <summary>
                List of property names to exclude when <see cref="P:NLog.Layouts.XmlElementBase.IncludeAllProperties"/> is true
                </summary>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.PropertiesElementName">
                <summary>
                XML element name to use when rendering properties
                </summary>
                <remarks>
                Support string-format where {0} means property-key-name
                
                Skips closing element tag when having configured <see cref="P:NLog.Layouts.XmlElementBase.PropertiesElementValueAttribute"/>
                </remarks>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.PropertiesElementKeyAttribute">
                 <summary>
                 XML attribute name to use when rendering property-key
                
                 When null (or empty) then key-attribute is not included
                 </summary>
                 <remarks>
                 Will replace newlines in attribute-value with &#13;&#10;
                 </remarks>
                 <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.PropertiesElementValueAttribute">
                 <summary>
                 XML attribute name to use when rendering property-value
                 
                 When null (or empty) then value-attribute is not included and
                 value is formatted as XML-element-value
                 </summary>
                 <remarks>
                 Skips closing element tag when using attribute for value
                
                 Will replace newlines in attribute-value with &#13;&#10;
                 </remarks>
                 <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.PropertiesCollectionItemName">
                <summary>
                XML element name to use for rendering IList-collections items
                </summary>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlElementBase.MaxRecursionLimit">
                <summary>
                How far should the XML serializer follow object references before backing off
                </summary>
                <docgen category='LogEvent Properties XML Options' order='10' />
            </member>
            <member name="M:NLog.Layouts.XmlElementBase.InitializeLayout">
                <summary>
                Initializes the layout.
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlElementBase.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
                <summary>
                Formats the log event as a XML document for writing.
                </summary>
                <param name="logEvent">The logging event.</param>
                <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
            </member>
            <member name="M:NLog.Layouts.XmlElementBase.GetFormattedMessage(NLog.LogEventInfo)">
                <summary>
                Formats the log event as a XML document for writing.
                </summary>
                <param name="logEvent">The log event to be formatted.</param>
                <returns>A XML string representation of the log event.</returns>
            </member>
            <member name="M:NLog.Layouts.XmlElementBase.RenderAttribute(System.Text.StringBuilder,System.String,System.String)">
                <summary>
                write attribute, only if <paramref name="attributeName"/> is not empty
                </summary>
                <param name="sb"></param>
                <param name="attributeName"></param>
                <param name="value"></param>
                <returns>rendered</returns>
            </member>
            <member name="M:NLog.Layouts.XmlElementBase.ToString">
                <summary>
                Generate description of XML Layout
                </summary>
                <returns>XML Layout String Description</returns>
            </member>
            <member name="T:NLog.Layouts.XmlLayout">
                <summary>
                A specialized layout that renders XML-formatted events.
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlLayout.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.Layouts.XmlElementBase"/> class.
                </summary>
            </member>
            <member name="M:NLog.Layouts.XmlLayout.#ctor(System.String,NLog.Layouts.Layout)">
                <inheritdoc />
            </member>
            <member name="P:NLog.Layouts.XmlLayout.ElementName">
                <summary>
                Name of the root XML element
                </summary>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="P:NLog.Layouts.XmlLayout.ElementValue">
                <summary>
                Value inside the root XML element
                </summary>
                <docgen category='XML Options' order='10' />
            </member>
            <member name="T:NLog.LogEventInfo">
                <summary>
                Represents the logging event.
                </summary>
            </member>
            <member name="F:NLog.LogEventInfo.ZeroDate">
                <summary>
                Gets the date of the first log event created.
                </summary>
            </member>
            <member name="F:NLog.LogEventInfo._formattedMessage">
                <summary>
                The formatted log message. 
                </summary>
            </member>
            <member name="F:NLog.LogEventInfo._message">
                <summary>
                The log message including any parameter placeholders
                </summary>
            </member>
            <member name="M:NLog.LogEventInfo.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
                </summary>
            </member>
            <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.String)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
                </summary>
                <param name="level">Log level.</param>
                <param name="loggerName">Logger name.</param>
                <param name="message">Log message including parameter placeholders.</param>
            </member>
            <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.String,System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
                </summary>
                <param name="level">Log level.</param>
                <param name="loggerName">Logger name.</param>
                <param name="message">Log message including parameter placeholders.</param>
                <param name="messageTemplateParameters">Log message including parameter placeholders.</param>
            </member>
            <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
                </summary>
                <param name="level">Log level.</param>
                <param name="loggerName">Logger name.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">Log message including parameter placeholders.</param>
                <param name="parameters">Parameter array.</param>
            </member>
            <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.IFormatProvider,System.String,System.Object[],System.Exception)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
                </summary>
                <param name="level">Log level.</param>
                <param name="loggerName">Logger name.</param>
                <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
                <param name="message">Log message including parameter placeholders.</param>
                <param name="parameters">Parameter array.</param>
                <param name="exception">Exception information.</param>
            </member>
            <member name="P:NLog.LogEventInfo.SequenceID">
                <summary>
                Gets the unique identifier of log event which is automatically generated
                and monotonously increasing.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.TimeStamp">
                <summary>
                Gets or sets the timestamp of the logging event.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.Level">
                <summary>
                Gets or sets the level of the logging event.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.HasStackTrace">
                <summary>
                Gets a value indicating whether stack trace has been set for this event.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.UserStackFrame">
                <summary>
                Gets the stack frame of the method that did the logging.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.UserStackFrameNumber">
                <summary>
                Gets the number index of the stack frame that represents the user
                code (not the NLog code).
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.StackTrace">
                <summary>
                Gets the entire stack trace.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.CallerClassName">
                <summary>
                Gets the callsite class name
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.CallerMemberName">
                <summary>
                Gets the callsite member function name
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.CallerFilePath">
                <summary>
                Gets the callsite source file path
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.CallerLineNumber">
                <summary>
                Gets the callsite source file line number
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.Exception">
                <summary>
                Gets or sets the exception information.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.LoggerName">
                <summary>
                Gets or sets the logger name.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.LoggerShortName">
                <summary>
                Gets the logger short name.
                </summary>
                <remarks>This property was marked as obsolete on NLog 2.0 and it may be removed in a future release.</remarks>
            </member>
            <member name="P:NLog.LogEventInfo.Message">
                <summary>
                Gets or sets the log message including any parameter placeholders.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.Parameters">
                <summary>
                Gets or sets the parameter values or null if no parameters have been specified.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.FormatProvider">
                <summary>
                Gets or sets the format provider that was provided while logging or <see langword="null" />
                when no formatProvider was specified.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.MessageFormatter">
                <summary>
                Gets or sets the message formatter for generating <see cref="P:NLog.LogEventInfo.FormattedMessage"/>
                Uses string.Format(...) when nothing else has been configured.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.FormattedMessage">
                <summary>
                Gets the formatted message.
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.HasProperties">
                <summary>
                Checks if any per-event properties (Without allocation)
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.Properties">
                <summary>
                Gets the dictionary of per-event context properties.
                </summary>
            </member>
            <member name="M:NLog.LogEventInfo.CreateOrUpdatePropertiesInternal(System.Boolean,System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
                <summary>
                Gets the dictionary of per-event context properties. 
                Internal helper for the PropertiesDictionary type.
                </summary>
                <param name="forceCreate">Create the event-properties dictionary, even if no initial template parameters</param>
                <param name="templateParameters">Provided when having parsed the message template and capture template parameters (else null)</param>
                <returns></returns>
            </member>
            <member name="P:NLog.LogEventInfo.MessageTemplateParameters">
                <summary>
                Gets the named parameters extracted from parsing <see cref="P:NLog.LogEventInfo.Message"/> as MessageTemplate
                </summary>
            </member>
            <member name="P:NLog.LogEventInfo.Context">
                <summary>
                Gets the dictionary of per-event context properties.
                </summary>
                <remarks>This property was marked as obsolete on NLog 2.0 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.LogEventInfo.CreateNullEvent">
                <summary>
                Creates the null event.
                </summary>
                <returns>Null log event.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.String)">
                <summary>
                Creates the log event.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="loggerName">Name of the logger.</param>
                <param name="message">The message.</param>
                <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Creates the log event.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="loggerName">Name of the logger.</param>
                <param name="formatProvider">The format provider.</param>
                <param name="message">The message.</param>
                <param name="parameters">The parameters.</param>
                <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.IFormatProvider,System.Object)">
                <summary>
                Creates the log event.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="loggerName">Name of the logger.</param>
                <param name="formatProvider">The format provider.</param>
                <param name="message">The message.</param>
                <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.String,System.Exception)">
                <summary>
                Creates the log event.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="loggerName">Name of the logger.</param>
                <param name="message">The message.</param>
                <param name="exception">The exception.</param>
                <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
                <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
            </member>
            <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.Exception,System.IFormatProvider,System.String)">
                <summary>
                Creates the log event.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="loggerName">Name of the logger.</param>
                <param name="exception">The exception.</param>
                <param name="formatProvider">The format provider.</param>
                <param name="message">The message.</param>
                <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.Exception,System.IFormatProvider,System.String,System.Object[])">
                <summary>
                Creates the log event.
                </summary>
                <param name="logLevel">The log level.</param>
                <param name="loggerName">Name of the logger.</param>
                <param name="exception">The exception.</param>
                <param name="formatProvider">The format provider.</param>
                <param name="message">The message.</param>
                <param name="parameters">The parameters.</param>
                <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.WithContinuation(NLog.Common.AsyncContinuation)">
                <summary>
                Creates <see cref="T:NLog.Common.AsyncLogEventInfo"/> from this <see cref="T:NLog.LogEventInfo"/> by attaching the specified asynchronous continuation.
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
                <returns>Instance of <see cref="T:NLog.Common.AsyncLogEventInfo"/> with attached continuation.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.ToString">
                <summary>
                Returns a string representation of this log event.
                </summary>
                <returns>String representation of the log event.</returns>
            </member>
            <member name="M:NLog.LogEventInfo.SetStackTrace(System.Diagnostics.StackTrace,System.Int32)">
                <summary>
                Sets the stack trace for the event info.
                </summary>
                <param name="stackTrace">The stack trace.</param>
                <param name="userStackFrame">Index of the first user stack frame within the stack trace.</param>
            </member>
            <member name="M:NLog.LogEventInfo.SetCallerInfo(System.String,System.String,System.String,System.Int32)">
                <summary>
                Sets the details retrieved from the Caller Information Attributes
                </summary>
                <param name="callerClassName"></param>
                <param name="callerMemberName"></param>
                <param name="callerFilePath"></param>
                <param name="callerLineNumber"></param>
            </member>
            <member name="M:NLog.LogEventInfo.SetDefaultMessageFormatter(System.Nullable{System.Boolean})">
                <summary>
                Set the <see cref="P:NLog.LogEventInfo.DefaultMessageFormatter"/>
                </summary>
                <param name="mode">true = Always, false = Never, null = Auto Detect</param>
            </member>
            <member name="T:NLog.LogFactory`1">
                <summary>
                Specialized LogFactory that can return instances of custom logger types.
                </summary>
                <typeparam name="T">The type of the logger to be returned. Must inherit from <see cref="T:NLog.Logger"/>.</typeparam>
            </member>
            <member name="M:NLog.LogFactory`1.GetLogger(System.String)">
                <summary>
                Gets the logger with type <typeparamref name="T"/>.
                </summary>
                <param name="name">The logger name.</param>
                <returns>An instance of <typeparamref name="T"/>.</returns>
            </member>
            <member name="M:NLog.LogFactory`1.GetCurrentClassLogger">
                <summary>
                Gets a custom logger with the name of the current class and type <typeparamref name="T"/>.
                </summary>
                <returns>An instance of <typeparamref name="T"/>.</returns>
                <remarks>This is a slow-running method. 
                Make sure you're not doing this in a loop.</remarks>
            </member>
            <member name="T:NLog.LogFactory">
                <summary>
                Creates and manages instances of <see cref="T:NLog.Logger" /> objects.
                </summary>
            </member>
            <member name="F:NLog.LogFactory._syncRoot">
                <remarks>
                Internal for unit tests
                </remarks>
            </member>
            <member name="F:NLog.LogFactory._candidateConfigFilePaths">
                <summary>
                Overwrite possible file paths (including filename) for possible NLog config files. 
                When this property is <c>null</c>, the default file paths (<see cref="M:NLog.LogFactory.GetCandidateConfigFilePaths"/> are used.
                </summary>
            </member>
            <member name="E:NLog.LogFactory.ConfigurationChanged">
                <summary>
                Occurs when logging <see cref="P:NLog.LogFactory.Configuration" /> changes.
                </summary>
            </member>
            <member name="E:NLog.LogFactory.ConfigurationReloaded">
                <summary>
                Occurs when logging <see cref="P:NLog.LogFactory.Configuration" /> gets reloaded.
                </summary>
            </member>
            <member name="M:NLog.LogFactory.#cctor">
                <summary>
                Initializes static members of the LogManager class.
                </summary>
            </member>
            <member name="M:NLog.LogFactory.#ctor">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogFactory" /> class.
                </summary>
            </member>
            <member name="M:NLog.LogFactory.#ctor(NLog.Config.LoggingConfiguration)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogFactory" /> class.
                </summary>
                <param name="config">The config.</param>
            </member>
            <member name="M:NLog.LogFactory.#ctor(NLog.Config.ILoggingConfigurationLoader)">
                <summary>
                Initializes a new instance of the <see cref="T:NLog.LogFactory" /> class.
                </summary>
                <param name="configLoader">The config loader</param>
            </member>
            <member name="P:NLog.LogFactory.CurrentAppDomain">
                <summary>
                Gets the current <see cref="T:NLog.Internal.Fakeables.IAppDomain"/>.
                </summary>
            </member>
            <member name="P:NLog.LogFactory.ThrowExceptions">
                <summary>
                Gets or sets a value indicating whether exceptions should be thrown. See also <see cref="P:NLog.LogFactory.ThrowConfigExceptions"/>.
                </summary>
                <value>A value of <c>true</c> if exception should be thrown; otherwise, <c>false</c>.</value>
                <remarks>By default exceptions are not thrown under any circumstances.</remarks>
            </member>
            <member name="P:NLog.LogFactory.ThrowConfigExceptions">
                <summary>
                Gets or sets a value indicating whether <see cref="T:NLog.NLogConfigurationException"/> should be thrown.
                
                If <c>null</c> then <see cref="P:NLog.LogFactory.ThrowExceptions"/> is used.
                </summary>
                <value>A value of <c>true</c> if exception should be thrown; otherwise, <c>false</c>.</value>
                <remarks>
                This option is for backwards-compatiblity.
                By default exceptions are not thrown under any circumstances.
                </remarks>
            </member>
            <member name="P:NLog.LogFactory.KeepVariablesOnReload">
                <summary>
                Gets or sets a value indicating whether Variables should be kept on configuration reload.
                Default value - false.
                </summary>
            </member>
            <member name="P:NLog.LogFactory.Configuration">
                <summary>
                Gets or sets the current logging configuration. After setting this property all
                existing loggers will be re-configured, so there is no need to call <see cref="M:NLog.LogFactory.ReconfigExistingLoggers" />
                manually.
                </summary>
            </member>
            <member name="P:NLog.LogFactory.GlobalThreshold">
                <summary>
                Gets or sets the global log level threshold. Log events below this threshold are not logged.
                </summary>
            </member>
            <member name="P:NLog.LogFactory.DefaultCultureInfo">
                <summary>
                Gets the default culture info to use as <see cref="P:NLog.LogEventInfo.FormatProvider"/>.
                </summary>
                <value>
                Specific culture info or null to use <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/>
                </value>
            </member>
            <member name="M:NLog.LogFactory.Dispose">
                <summary>
                Performs application-defined tasks associated with freeing, releasing, or resetting 
                unmanaged resources.
                </summary>
            </member>
            <member name="M:NLog.LogFactory.CreateNullLogger">
                <summary>
                Creates a logger that discards all log messages.
                </summary>
                <returns>Null logger instance.</returns>
            </member>
            <member name="M:NLog.LogFactory.GetCurrentClassLogger">
                <summary>
                Gets the logger with the name of the current class. 
                </summary>
                <returns>The logger.</returns>
                <remarks>This is a slow-running method. 
                Make sure you're not doing this in a loop.</remarks>
            </member>
            <member name="M:NLog.LogFactory.GetCurrentClassLogger``1">
                <summary>
                Gets the logger with the name of the current class. 
                </summary>
                <returns>The logger with type <typeparamref name="T"/>.</returns>
                <typeparam name="T">Type of the logger</typeparam>
                <remarks>This is a slow-running method. 
                Make sure you're not doing this in a loop.</remarks>
            </member>
            <member name="M:NLog.LogFactory.GetCurrentClassLogger(System.Type)">
                <summary>
                Gets a custom logger with the name of the current class. Use <paramref name="loggerType"/> to pass the type of the needed Logger.
                </summary>
                <param name="loggerType">The type of the logger to create. The type must inherit from <see cref="T:NLog.Logger"/></param>
                <returns>The logger of type <paramref name="loggerType"/>.</returns>
                <remarks>This is a slow-running method. Make sure you are not calling this method in a 
                loop.</remarks>
            </member>
            <member name="M:NLog.LogFactory.GetLogger(System.String)">
                <summary>
                Gets the specified named logger.
                </summary>
                <param name="name">Name of the logger.</param>
                <returns>The logger reference. Multiple calls to <c>GetLogger</c> with the same argument 
                are not guaranteed to return the same logger reference.</returns>
            </member>
            <member name="M:NLog.LogFactory.GetLogger``1(System.String)">
                <summary>
                Gets the specified named logger.
                </summary>
                <param name="name">Name of the logger.</param>
                <typeparam name="T">Type of the logger</typeparam>
                <returns>The logger reference with type <typeparamref name="T"/>. Multiple calls to <c>GetLogger</c> with the same argument 
                are not guaranteed to return the same logger reference.</returns>
            </member>
            <member name="M:NLog.LogFactory.GetLogger(System.String,System.Type)">
                <summary>
                Gets the specified named logger.  Use <paramref name="loggerType"/> to pass the type of the needed Logger.
                </summary>
                <param name="name">Name of the logger.</param>
                <param name="loggerType">The type of the logger to create. The type must inherit from <see cref="T:NLog.Logger" />.</param>
                <returns>The logger of type <paramref name="loggerType"/>. Multiple calls to <c>GetLogger</c> with the 
                same argument aren't guaranteed to return the same logger reference.</returns>
            </member>
            <member name="M:NLog.LogFactory.ReconfigExistingLoggers">
                <summary>
                Loops through all loggers previously returned by GetLogger and recalculates their 
                target and filter list. Useful after modifying the configuration programmatically
                to ensure that all loggers have been properly configured.
                </summary>
            </member>
            <member name="M:NLog.LogFactory.Flush">
                <summary>
                Flush any pending log messages (in case of asynchronous targets) with the default timeout of 15 seconds.
                </summary>
            </member>
            <member name="M:NLog.LogFactory.Flush(System.TimeSpan)">
                <summary>
                Flush any pending log messages (in case of asynchronous targets).
                </summary>
                <param name="timeout">Maximum time to allow for the flush. Any messages after that time 
                will be discarded.</param>
            </member>
            <member name="M:NLog.LogFactory.Flush(System.Int32)">
                <summary>
                Flush any pending log messages (in case of asynchronous targets).
                </summary>
                <param name="timeoutMilliseconds">Maximum time to allow for the flush. Any messages 
                after that time will be discarded.</param>
            </member>
            <member name="M:NLog.LogFactory.Flush(NLog.Common.AsyncContinuation)">
                <summary>
                Flush any pending log messages (in case of asynchronous targets).
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
            </member>
            <member name="M:NLog.LogFactory.Flush(NLog.Common.AsyncContinuation,System.Int32)">
                <summary>
                Flush any pending log messages (in case of asynchronous targets).
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
                <param name="timeoutMilliseconds">Maximum time to allow for the flush. Any messages 
                after that time will be discarded.</param>
            </member>
            <member name="M:NLog.LogFactory.Flush(NLog.Common.AsyncContinuation,System.TimeSpan)">
                <summary>
                Flush any pending log messages (in case of asynchronous targets).
                </summary>
                <param name="asyncContinuation">The asynchronous continuation.</param>
                <param name="timeout">Maximum time to allow for the flush. Any messages after that time will be discarded.</param>
            </member>
            <member name="M:NLog.LogFactory.DisableLogging">
                <summary>
                Decreases the log enable counter and if it reaches -1 the logs are disabled.
                </summary>
                <remarks>
                Logging is enabled if the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls is greater than 
                or equal to <see cref="M:NLog.LogFactory.SuspendLogging"/> calls.
                
                This method was marked as obsolete on NLog 4.0 and it may be removed in a future release.
                </remarks>
                <returns>An object that implements IDisposable whose Dispose() method re-enables logging. 
                To be used with C# <c>using ()</c> statement.</returns>
            </member>
            <member name="M:NLog.LogFactory.EnableLogging">
                <summary>
                Increases the log enable counter and if it reaches 0 the logs are disabled.
                </summary>
                <remarks>
                Logging is enabled if the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls is greater than 
                or equal to <see cref="M:NLog.LogFactory.SuspendLogging"/> calls.
                
                This method was marked as obsolete on NLog 4.0 and it may be removed in a future release.
                </remarks>
            </member>
            <member name="M:NLog.LogFactory.SuspendLogging">
                <summary>
                Decreases the log enable counter and if it reaches -1 the logs are disabled.
                </summary>
                <remarks>
                Logging is enabled if the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls is greater than 
                or equal to <see cref="M:NLog.LogFactory.SuspendLogging"/> calls.
                </remarks>
                <returns>An object that implements IDisposable whose Dispose() method re-enables logging. 
                To be used with C# <c>using ()</c> statement.</returns>
            </member>
            <member name="M:NLog.LogFactory.ResumeLogging">
                <summary>
                Increases the log enable counter and if it reaches 0 the logs are disabled.
                </summary>
                <remarks>Logging is enabled if the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls is greater 
                than or equal to <see cref="M:NLog.LogFactory.SuspendLogging"/> calls.</remarks>
            </member>
            <member name="M:NLog.LogFactory.IsLoggingEnabled">
                <summary>
                Returns <see langword="true" /> if logging is currently enabled.
                </summary>
                <returns>A value of <see langword="true" /> if logging is currently enabled, 
                <see langword="false"/> otherwise.</returns>
                <remarks>Logging is enabled if the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls is greater 
                than or equal to <see cref="M:NLog.LogFactory.SuspendLogging"/> calls.</remarks>
            </member>
            <member name="M:NLog.LogFactory.OnConfigurationChanged(NLog.Config.LoggingConfigurationChangedEventArgs)">
                <summary>
                Raises the event when the configuration is reloaded. 
                </summary>
                <param name="e">Event arguments.</param>
            </member>
            <member name="M:NLog.LogFactory.OnConfigurationReloaded(NLog.Config.LoggingConfigurationReloadedEventArgs)">
                <summary>
                Raises the event when the configuration is reloaded. 
                </summary>
                <param name="e">Event arguments</param>
            </member>
            <member name="F:NLog.LogFactory._isDisposing">
                <summary>
                Currently this logfactory is disposing?
                </summary>
            </member>
            <member name="M:NLog.LogFactory.Dispose(System.Boolean)">
                <summary>
                Releases unmanaged and - optionally - managed resources.
                </summary>
                <param name="disposing"><c>True</c> to release both managed and unmanaged resources;
                <c>false</c> to release only unmanaged resources.</param>
            </member>
            <member name=&qu