824 lines
41 KiB
XML
824 lines
41 KiB
XML
<?xml version="1.0"?>
|
|
<doc>
|
|
<assembly>
|
|
<name>JetBrains.Annotations</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 checking for <c>null</c> is required 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 can 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 applied 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>
|
|
<example><code>
|
|
public void Foo([ItemNotNull]List<string> books)
|
|
{
|
|
foreach (var book in books) {
|
|
if (book != null) // Warning: Expression is always true
|
|
Console.WriteLine(book.ToUpper());
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.ItemCanBeNullAttribute">
|
|
<summary>
|
|
Can be applied 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>
|
|
<example><code>
|
|
public void Foo([ItemCanBeNull]List<string> books)
|
|
{
|
|
foreach (var book in books)
|
|
{
|
|
// Warning: Possible 'System.NullReferenceException'
|
|
Console.WriteLine(book.ToUpper());
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.StringFormatMethodAttribute">
|
|
<summary>
|
|
Indicates that the marked method builds string by the format pattern and (optional) arguments.
|
|
The parameter, which contains the format string, should be given in the 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 the format string
|
|
</param>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.StructuredMessageTemplateAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter is a message template where placeholders are to be replaced by the following arguments
|
|
in the order in which they appear
|
|
</summary>
|
|
<example><code>
|
|
void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
|
|
|
|
void Foo() {
|
|
LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.ValueProviderAttribute">
|
|
<summary>
|
|
Use this annotation to specify a type that contains static or const fields
|
|
with values for the annotated property/field/parameter.
|
|
The specified type will be used to improve completion suggestions.
|
|
</summary>
|
|
<example><code>
|
|
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*/
|
|
}
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.ValueRangeAttribute">
|
|
<summary>
|
|
Indicates that the integral value falls into the specified interval.
|
|
It's allowed to specify multiple non-intersecting intervals.
|
|
Values of interval boundaries are inclusive.
|
|
</summary>
|
|
<example><code>
|
|
void Foo([ValueRange(0, 100)] int value) {
|
|
if (value == -1) { // Warning: Expression is always 'false'
|
|
...
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.NonNegativeValueAttribute">
|
|
<summary>
|
|
Indicates that the integral value never falls below zero.
|
|
</summary>
|
|
<example><code>
|
|
void Foo([NonNegativeValue] int value) {
|
|
if (value == -1) { // Warning: Expression is always 'false'
|
|
...
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.InvokerParameterNameAttribute">
|
|
<summary>
|
|
Indicates that the function argument should be a 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(() => Property)</c></item>
|
|
<item><c>NotifyChanged((VM x) => 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 => Output | Output <= 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 the method has a single input parameter, its name could be omitted.<br/>
|
|
Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for the method output
|
|
means that the method 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 the semicolon. There is no notion of order rows, all rows are checked
|
|
for applicability and applied per each program state tracked by the analysis engine.<br/>
|
|
</syntax>
|
|
<examples><list>
|
|
<item><code>
|
|
[ContractAnnotation("=> halt")]
|
|
public void TerminationMethod()
|
|
</code></item>
|
|
<item><code>
|
|
[ContractAnnotation("null <= param:null")] // reverse condition syntax
|
|
public string GetName(string surname)
|
|
</code></item>
|
|
<item><code>
|
|
[ContractAnnotation("s:null => 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 => null; notnull => notnull")]
|
|
public object Transform(object data)
|
|
</code></item>
|
|
<item><code>
|
|
[ContractAnnotation("=> true, result: notnull; => false, result: null")]
|
|
public bool TryParse(string s, out Person result)
|
|
</code></item>
|
|
</list></examples>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.LocalizationRequiredAttribute">
|
|
<summary>
|
|
Indicates whether the marked element should be localized.
|
|
</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 be ignored by usage-checking inspections. <br/>
|
|
You can use <see cref="T:JetBrains.Annotations.ImplicitUseKindFlags"/> and <see cref="T:JetBrains.Annotations.ImplicitUseTargetFlags"/>
|
|
to configure how this attribute is applied.
|
|
</summary>
|
|
<example><code>
|
|
[UsedImplicitly]
|
|
public class TypeConverter {}
|
|
|
|
public class SummaryData
|
|
{
|
|
[UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
|
|
public SummaryData() {}
|
|
}
|
|
|
|
[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.Default)]
|
|
public interface IService {}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.MeansImplicitUseAttribute">
|
|
<summary>
|
|
Can be applied to attributes, type parameters, and parameters of a type assignable from <see cref="T:System.Type"/> .
|
|
When applied to an attribute, the decorated attribute behaves the same as <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>.
|
|
When applied to a type parameter or to a parameter of type <see cref="T:System.Type"/>,
|
|
indicates that the corresponding type is used implicitly.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.ImplicitUseKindFlags">
|
|
<summary>
|
|
Specifies the details of implicitly used symbol when it is marked
|
|
with <see cref="T:JetBrains.Annotations.MeansImplicitUseAttribute"/> or <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>.
|
|
</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>
|
|
Specifies what is considered to be 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 the type marked with the attribute are considered used.</summary>
|
|
</member>
|
|
<member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.WithInheritors">
|
|
<summary> Inherited entities are considered used. </summary>
|
|
</member>
|
|
<member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.WithMembers">
|
|
<summary>Entity marked with the 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 the 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); // Warning: Return value of pure method is not used
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.MustUseReturnValueAttribute">
|
|
<summary>
|
|
Indicates that the return value of the method invocation must be used.
|
|
</summary>
|
|
<remarks>
|
|
Methods decorated with this attribute (in contrast to pure methods) might change state,
|
|
but make no sense without using their return value. <br/>
|
|
Similarly to <see cref="T:JetBrains.Annotations.PureAttribute"/>, this attribute
|
|
will help to detect usages of the method when the return value is not used.
|
|
Optionally, you can specify a message to use when showing warnings, e.g.
|
|
<code>[MustUseReturnValue("Use the return value to...")]</code>.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.RequireStaticDelegateAttribute">
|
|
<summary>
|
|
This annotation allows to enforce allocation-less usage patterns of delegates for performance-critical APIs.
|
|
When this annotation is applied to the parameter of delegate type, IDE checks the input argument of this parameter:
|
|
* When lambda expression or anonymous method is passed as an argument, IDE verifies that the passed closure
|
|
has no captures of the containing local variables and the compiler is able to cache the delegate instance
|
|
to avoid heap allocations. Otherwise the warning is produced.
|
|
* IDE warns when method name or local function name is passed as an argument as this always results
|
|
in heap allocation of the delegate instance.
|
|
</summary>
|
|
<remarks>
|
|
In C# 9.0 code IDE would also suggest to annotate the anonymous function with 'static' modifier
|
|
to make use of the similar analysis provided by the language/compiler.
|
|
</remarks>
|
|
</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 of 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 code completion
|
|
as a 'Source Template'. When the extension method is completed over some expression, its 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<T>(this IEnumerable<T> 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<T>(this IEnumerable<T> 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 the marked 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 the marked 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 the marked 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 the marked 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 the marked 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 the marked parameter or 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 the contents of the collection.
|
|
Use <see cref="P:JetBrains.Annotations.CollectionAccessAttribute.CollectionAccessType"/> to specify the access type.
|
|
</summary>
|
|
<remarks>
|
|
Using this attribute only makes sense if all collection methods are marked with this attribute.
|
|
</remarks>
|
|
<example><code>
|
|
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();
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.CollectionAccessType">
|
|
<summary>
|
|
Provides a value for the <see cref="T:JetBrains.Annotations.CollectionAccessAttribute"/> to define
|
|
how the collection method invocation affects the contents 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 the 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 the method is a 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 a parameter is not enumerated.
|
|
Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection.
|
|
</summary>
|
|
<example><code>
|
|
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
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.RegexPatternAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter, field, or property is a 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:JetBrains.Annotations.XamlItemStyleOfItemsControlAttribute">
|
|
<summary>
|
|
XAML attribute. Indicates the property of some <c>Style</c>-derived type, that
|
|
is used to style items 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:JetBrains.Annotations.XamlOneWayBindingModeByDefaultAttribute">
|
|
<summary>
|
|
XAML attribute. Indicates that DependencyProperty has <c>OneWay</c> binding mode by default.
|
|
</summary>
|
|
<remarks>
|
|
This attribute must be applied to DependencyProperty's CLR accessor property if it is present, to DependencyProperty descriptor field otherwise.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.XamlTwoWayBindingModeByDefaultAttribute">
|
|
<summary>
|
|
XAML attribute. Indicates that DependencyProperty has <c>TwoWay</c> binding mode by default.
|
|
</summary>
|
|
<remarks>
|
|
This attribute must be applied to DependencyProperty's CLR accessor property if it is present, to DependencyProperty descriptor field otherwise.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.RouteTemplateAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter, field, or property is a route template.
|
|
</summary>
|
|
<remarks>
|
|
This attribute allows IDE to recognize the use of web frameworks' route templates
|
|
to enable syntax highlighting, code completion, navigation, rename and other features in string literals.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.RouteParameterConstraintAttribute">
|
|
<summary>
|
|
Indicates that the marked type is custom route parameter constraint,
|
|
which is registered in application's Startup with name <c>ConstraintName</c>
|
|
</summary>
|
|
<remarks>
|
|
You can specify <c>ProposedType</c> if target constraint matches only route parameters of specific type,
|
|
it will allow IDE to create method's parameter from usage in route template
|
|
with specified type instead of default <c>System.String</c>
|
|
and check if constraint's proposed type conflicts with matched parameter's type
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.UriStringAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter, field, or property is an URI string.
|
|
</summary>
|
|
<remarks>
|
|
This attribute enables code completion, navigation, rename and other features
|
|
in URI string literals assigned to annotated parameter, field or property.
|
|
</remarks>
|
|
</member>
|
|
</members>
|
|
</doc>
|