However, the attributes are still visible in the source code, and ReSharper can make use of them. So by default, using the attributes referenced from the JetBrains.Annotations NuGet package does nothing at compile time – the resulting compiled assembly does not include a reference to, and the attributes are not applied to any classes, methods, properties, parameters and so on. When applied to attributes, it means the attribute itself doesn’t get applied to the compiled target method, class, etc. For methods, this means any calls to that method are ignored.
If the string argument to the annotation is not defined as a compiler symbol in your project properties, the target of the attribute isn’t compiled into the resulting assembly. This is a special attribute that the compiler understands, and can be applied to all sorts of types, methods, properties, and, surprisingly, attributes. All of the annotation attributes are marked with the attribute. Of course, the ReSharper team have already thought of this, and make use of a little-known feature of.
Jetbrains annotations code#
Many developers don’t wish to add references if they can avoid it, especially not to a library that is there solely to aid source code analysis, no matter how helpful it is. The most obvious concern here is in adding a binary reference to a third party assembly. Once added as a reference, your source code can simply use the attributes directly. This will add a binary dependency on the assembly, which includes all of the attributes in the JetBrains.Annotations namespace. The simplest way to include the annotations is to add a reference to the official JetBrains.Annotations NuGet package. There are several ways of doing this, targeting different usage scenarios.
In order to use the annotation attributes, you need to include them in your project. When running an inspection or looking to activate a feature, ReSharper will look at method calls, properties and so on, and look to see if any annotation attributes are applied to the method, parameters or return value, and use that annotation to help improve the accuracy and usefulness of the inspection or feature.
NET attributes, so it’s very easy to add to your own source code. We can even include the annotations when distributing our code, so consumers of our libraries get better support in ReSharper.Īnnotations are implemented with. NET Framework classes and methods.įurthermore, extensions can also define “external annotations” for pre-compiled assemblies, such as telling ReSharper that ‘s Assert methods can result in dead code, or to add regular expression highlighting for Assert.Matches.Įven better, we can use these annotations in our own code, and improve ReSharper’s analyses and inspections when working with our own types and methods. The good news is that the development team has already done the hard work of annotating the whole of the Base Class Library for you, so you don’t need to do anything in order to get this support when working with standard. So what are these annotations and how do we use them? For example, string format argument matching and regular expression syntax highlighting are enabled on methods marked with annotations, as are navigation to MVC controllers and actions:Īnd the advanced support for INotifyPropert圜hanged in various UI frameworks is also enabled by annotations: ReSharper even uses annotations to provide extra functionality. Annotations can tell us when items in a list can be null, or will never be null, or when a method is an assertion method, and any code after that method call is redundant due to the assert throwing an exception. Conversely, if we know that a method will never return null, ReSharper can warn you that any null checks on the result are redundant, and help you safely remove the redundant code. If we know that a parameter to a called method should never be null, ReSharper can warn you to check for null before calling the method. They build abstract syntax trees, create a semantic model of your code, and construct control flow graphs for tracking values, especially nullness.īut we can make them smarter through the use of annotations. ReSharper’s analyses and inspections are already very smart, finding code smells, dead code, and potential runtime issues directly from your source code.
0 kommentar(er)
