- if
is null => returns (never matches) - if
doesn't contains any '*' nor '?' => returns (matches only on case sensitive equals) - if
== '*' => returns (always matches) - if
doesn't contain '?' - if
contains exactly 2 '*' one at the beginning and one at the end (i.e. "*foobar*) => returns - if
contains exactly 1 '*' at the beginning (i.e. "*foobar") => returns - if
contains exactly 1 '*' at the end (i.e. "foobar*") => returns
- if
- returns
- '*' means zero or more occurrences of any character
- '?' means exactly one occurrence of any character
- '*' means zero or more occurrences of any character
- '?' means exactly one occurrence of any character
- '*' means zero or more occurrences of any character
- '?' means exactly one occurrence of any character
.
.
${appsetting:item=mysetting:default=mydefault} - produces "mydefault" if no appsetting
- ApplicationData - roaming application data for current user.
- CommonApplicationData - application data for all users.
- MyDocuments - My Documents
- DesktopDirectory - Desktop directory
- LocalApplicationData - non roaming application data
- Personal - user profile directory
- System - System directory
-
-
-
-
-
-
[Target("MyFirst")]
public sealed class MyFirstTarget : AsyncTaskTarget
{
public MyFirstTarget()
{
this.Host = "localhost";
}
[RequiredParameter]
public Layout Host { get; set; }
protected override Task WriteAsyncTask(LogEventInfo logEvent, CancellationToken token)
{
string logMessage = this.RenderLogEvent(this.Layout, logEvent);
string hostName = this.RenderLogEvent(this.Host, logEvent);
return SendTheMessageToRemoteHost(hostName, logMessage);
}
private async Task SendTheMessageToRemoteHost(string hostName, string message)
{
// To be implemented
}
}
protected override Task WriteAsyncTask(LogEventInfo logEvent, CancellationToken token)
{
return CustomWriteAsync(logEvent, token);
}
private async Task CustomWriteAsync(LogEventInfo logEvent, CancellationToken token)
{
await MyLogMethodAsync(logEvent, token).ConfigureAwait(false);
}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
| Condition | Foreground Color | Background Color |
|---|---|---|
| level == LogLevel.Fatal | Red | NoChange |
| level == LogLevel.Error | Yellow | NoChange |
| level == LogLevel.Warn | Magenta | NoChange |
| level == LogLevel.Info | White | NoChange |
| level == LogLevel.Debug | Gray | NoChange |
| level == LogLevel.Trace | DarkGray | NoChange |
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${basedir}/${level}.log
All KeepFileOpen = false gives the best compability, but slow performance and lead to file-locking issues with other applications.
a random value between 0 and 20 milliseconds - 2nd attempt
a random value between 0 and 40 milliseconds - 3rd attempt
a random value between 0 and 80 milliseconds - 4th attempt
... and so on.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
Mail target works best when used with BufferingWrapper target which lets you send multiple log messages in single mail
To set up the buffered mail target in the configuration file, use the following syntax:
To set up the buffered mail target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
tags.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
To print the results, use any application that's able to receive messages over TCP or UDP. NetCat is a simple but very powerful command-line tool that can be used for that. This image demonstrates the NetCat tool receiving log messages from Network target.
There are two specialized versions of the Network target: Chainsaw and NLogViewer which write to instances of Chainsaw log4j viewer or NLogViewer application respectively.
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
- tcp://host:port - TCP (auto select IPv4/IPv6)
- tcp4://host:port - force TCP/IPv4
- tcp6://host:port - force TCP/IPv6
- udp://host:port - UDP (auto select IPv4/IPv6)
- udp4://host:port - force UDP/IPv4
- udp6://host:port - force UDP/IPv6
- http://host:port/pageName - HTTP using POST verb
- https://host:port/pageName - HTTPS using POST verb
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
[Target("MyFirst")]
public sealed class MyFirstTarget : TargetWithContext
{
public MyFirstTarget()
{
this.Host = "localhost";
}
[RequiredParameter]
public Layout Host { get; set; }
protected override void Write(LogEventInfo logEvent)
{
string logMessage = this.RenderLogEvent(this.Layout, logEvent);
string hostName = this.RenderLogEvent(this.Host, logEvent);
return SendTheMessageToRemoteHost(hostName, logMessage);
}
private void SendTheMessageToRemoteHost(string hostName, string message)
{
// To be implemented
}
}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}
<system.net>
<defaultProxy enabled = "true" useDefaultCredentials = "true" >
<proxy usesystemdefault = "True" />
</defaultProxy>
</system.net>
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
The example web service that works with this example is shown below
Asynchronous target wrapper allows the logger code to execute more quickly, by queueing messages and processing them in a separate thread. You should wrap targets that spend a non-trivial amount of time in their Write() method with asynchronous target to speed up logging.
Because asynchronous logging is quite a common scenario, NLog supports a shorthand notation for wrapping all targets with AsyncWrapper. Just add async="true" to the <targets/> element in the configuration file.
... your targets go here ...
]]>
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes the messages to be written to server1, and if it fails, messages go to server2.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes the messages not contains the string '1' to be ignored.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example works like this. If there are no Warn,Error or Fatal messages in the buffer only Info messages are written to the file, but if there are any warnings or errors, the output includes detailed trace (levels >= Debug). You can plug in a different type of buffering wrapper (such as ASPNetBufferingWrapper) to achieve different functionality.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes the messages to be written to either file1.txt or file2.txt chosen randomly on a per-message basis.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes each log message to be repeated 3 times.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes each write attempt to be repeated 3 times, sleeping 1 second between attempts if first one fails.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes the messages to be written to either file1.txt or file2.txt. Each odd message is written to file2.txt, each even message goes to file1.txt.
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
This example causes the messages to be written to both file1.txt or file2.txt
To set up the target in the configuration file, use the following syntax:
To set up the log target programmatically use code like this:
[CanBeNull] object Test() => null;
void UseTest() {
var p = Test();
var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
}
[NotNull] object Foo() {
return null; // Warning: Possible 'null' assignment
}
public void Foo([ItemNotNull]List<string> books)
{
foreach (var book in books) {
if (book != null) // Warning: Expression is always true
Console.WriteLine(book.ToUpper());
}
}
public void Foo([ItemCanBeNull]List<string> books)
{
foreach (var book in books)
{
// Warning: Possible 'System.NullReferenceException'
Console.WriteLine(book.ToUpper());
}
}
[StringFormatMethod("message")]
void ShowError(string message, params object[] args) { /* do something */ }
void Foo() {
ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
}
void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
void Foo() {
LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
}
namespace TestNamespace
{
public class Constants
{
public static int INT_CONST = 1;
public const string STRING_CONST = "1";
}
public class Class1
{
[ValueProvider("TestNamespace.Constants")] public int myField;
public void Foo([ValueProvider("TestNamespace.Constants")] string str) { }
public void Test()
{
Foo(/*try completion here*/);//
myField = /*try completion here*/
}
}
}
void Foo([ValueRange(0, 100)] int value) {
if (value == -1) { // Warning: Expression is always 'false'
...
}
}
void Foo([NonNegativeValue] int value) {
if (value == -1) { // Warning: Expression is always 'false'
...
}
}
void Foo(string param) {
if (param == null)
throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
}
NotifyChanged(string) NotifyChanged(params string[]) NotifyChanged{T}(Expression{Func{T}}) NotifyChanged{T,U}(Expression{Func{T,U}}) SetProperty{T}(ref T, T, string)
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 */ }
}
}
Examples of generated notifications:
NotifyChanged("Property") NotifyChanged(() => Property) NotifyChanged((VM x) => x.Property) SetProperty(ref myField, value, "Property")
Function Definition Table syntax:
- FDT ::= FDTRow [;FDTRow]*
- FDTRow ::= Input => Output | Output <= Input
- Input ::= ParameterName: Value [, Input]*
- Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}
- Value ::= true | false | null | notnull | canbenull
Using
Value
You can use multiple
[ContractAnnotation("=> halt")] public void TerminationMethod()[ContractAnnotation("null <= param:null")] // reverse condition syntax public string GetName(string surname)[ContractAnnotation("s:null => true")] public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()// A method that returns null if the parameter is null, // and not null if the parameter is not null [ContractAnnotation("null => null; notnull => notnull")] public object Transform(object data)[ContractAnnotation("=> true, result: notnull; => false, result: null")] public bool TryParse(string s, out Person result)
[LocalizationRequiredAttribute(true)]
class Foo {
string str = "my string"; // Warning: Localizable string
}
[CannotApplyEqualityOperator]
class NoEquality { }
class UsesNoEquality {
void Test() {
var ca1 = new NoEquality();
var ca2 = new NoEquality();
if (ca1 != null) { // OK
bool condition = ca1 == ca2; // Warning
}
}
}
[BaseTypeRequired(typeof(IComponent)] // Specify requirement
class ComponentAttribute : Attribute { }
[Component] // ComponentAttribute requires implementing IComponent interface
class MyComponent : IComponent { }
You can use
[UsedImplicitly]
public class TypeConverter {}
public class SummaryData
{
[UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
public SummaryData() {}
}
[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.Default)]
public interface IService {}
[Pure] int Multiply(int x, int y) => x * y;
void M() {
Multiply(123, 42); // Warning: Return value of pure method is not used
}
Similarly to
[MustUseReturnValue("Use the return value to...")].
class Foo {
[ProvidesContext] IBarService _barService = ...;
void ProcessNode(INode node) {
DoSomething(node, node.GetGlobalServices().Bar);
// ^ Warning: use value of '_barService' field
}
}
[SourceTemplate]
public static void forEach<T>(this IEnumerable<T> xs) {
foreach (var x in xs) {
//$ $END$
}
}
[SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
public static void forEach<T>(this IEnumerable<T> collection) {
foreach (var item in collection) {
//$ $END$
}
}
Applying the attribute on a template method parameter:
[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); */
}
public class MyStringCollection : List<string>
{
[CollectionAccess(CollectionAccessType.Read)]
public string GetFirstString()
{
return this.ElementAt(0);
}
}
class Test
{
public void Foo()
{
// Warning: Contents of the collection is never updated
var col = new MyStringCollection();
string x = col.GetFirstString();
}
}
static void ThrowIfNull<T>([NoEnumeration] T v, string n) where T : class
{
// custom check for null but no enumeration
}
void Foo(IEnumerable<string> values)
{
ThrowIfNull(values, nameof(values));
var x = values.ToList(); // No warnings about multiple enumeration
}
void Foo([LanguageInjection(InjectedLanguage.CSS, Prefix = "body{", Suffix = "}")] string cssProps)
{
// cssProps should only contains a list of CSS properties
}