[CanBeNull] public object Test() { return null; }
public void UseTest() {
var p = Test();
var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
}
[NotNull] public object Foo() {
return null; // Warning: Possible 'null' assignment
}
[StringFormatMethod("message")]
public void ShowError(string message, params object[] args) { /* do something */ }
public void Foo() {
ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
}
public 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)
internal class Foo : INotifyPropertyChanged {
public event PropertyChangedEventHandler PropertyChanged;
[NotifyPropertyChangedInvocator]
protected virtual void NotifyChanged(string propertyName) { ... }
private 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
You can use multiple
[ContractAnnotation("=> halt")] public void TerminationMethod()[ContractAnnotation("halt <= condition: false")] public void Assert(bool condition, string text) // regular assertion method[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("s:null=>false; =>true,result:notnull; =>false, result:null")] public bool TryParse(string s, out Person result)
[LocalizationRequiredAttribute(true)]
internal class Foo {
private string str = "my string"; // Warning: Localizable string
}
[CannotApplyEqualityOperator]
class NoEquality { }
class UsesNoEquality {
public void Test() {
var ca1 = new NoEquality();
var ca2 = new NoEquality();
if (ca1 != null) { // OK
bool condition = ca1 == ca2; // Warning
}
}
}
[BaseTypeRequired(typeof(IComponent)] // Specify requirement
internal class ComponentAttribute : Attribute { }
[Component] // ComponentAttribute requires implementing IComponent interface
internal class MyComponent : IComponent { }
[Pure] private int Multiply(int x, int y) { return x * y; }
public void Foo() {
const int a = 2, b = 2;
Multiply(a, b); // Waring: Return value of pure method is not used
}
[ActionName("Foo")]
public ActionResult Login(string returnUrl) {
ViewBag.ReturnUrl = Url.Action("Foo"); // OK
return RedirectToAction("Bar"); // Error: Cannot resolve action
}
.
.
.
.
.
.
- 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
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
NOTE: If your receiver application is ever likely to be off-line, don't use TCP protocol or you'll get TCP timeouts and your application will crawl. Either switch to UDP transport or use AsyncWrapper target so that your application threads will not be blocked by the timing-out connection attempts.
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
NOTE: If your receiver application is ever likely to be off-line, don't use TCP protocol or you'll get TCP timeouts and your application will crawl. Either switch to UDP transport or use AsyncWrapper target so that your application threads will not be blocked by the timing-out connection attempts.
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
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.
NOTE: If your receiver application is ever likely to be off-line, don't use TCP protocol or you'll get TCP timeouts and your application will be very slow. Either switch to UDP transport or use AsyncWrapper target so that your application threads will not be blocked by the timing-out connection attempts.
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}
${longdate}|${level:uppercase=true}|${logger}|${message}
- tcp://host:port - TCP (auto select IPv4/IPv6) (not supported on Windows Phone 7.0)
- tcp4://host:port - force TCP/IPv4 (not supported on Windows Phone 7.0)
- tcp6://host:port - force TCP/IPv6 (not supported on Windows Phone 7.0)
- udp://host:port - UDP (auto select IPv4/IPv6, not supported on Silverlight and on Windows Phone 7.0)
- udp4://host:port - force UDP/IPv4 (not supported on Silverlight and on Windows Phone 7.0)
- udp6://host:port - force UDP/IPv6 (not supported on Silverlight and on Windows Phone 7.0)
- http://host:port/pageName - HTTP using POST verb
- https://host:port/pageName - HTTPS using POST verb
${longdate}|${level:uppercase=true}|${logger}|${message}
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message}
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message}
${longdate}|${level:uppercase=true}|${logger}|${message}
${basedir}/${level}.log
All 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.
Caution: Enabling this option can considerably slow down your file
logging in multi-process scenarios. If only one process is going to
be writing to the file, consider setting
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
${longdate}|${level:uppercase=true}|${logger}|${message}
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
To set up the log target programmatically use code like this:
To set up the target in the configuration file, use the following syntax:
This assumes just one target and a single rule. More configuration options are described here.
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
To set up the target in the configuration file, use the following syntax:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
${longdate}|${level:uppercase=true}|${logger}|${message}
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
This example causes each log message to be repeated 3 times.
To set up the target in the configuration file, use the following syntax:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file:
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:
The above examples assume just one target and a single rule. See below for a programmatic configuration that's equivalent to the above config file: