1232 lines
66 KiB
XML
1232 lines
66 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 a 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. This annotation is used for parameters
|
|
like 'string paramName' parameter of the <see cref="T:System.ArgumentNullException"/> constructor.
|
|
</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 dependence 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 the 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 an 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 APIs,
|
|
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 the delegate can only be invoked during method execution
|
|
(the delegate can be invoked zero or multiple times, but not stored to some field and invoked later,
|
|
when the containing method is no longer on the execution stack).
|
|
If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
|
|
If <see cref="P:JetBrains.Annotations.InstantHandleAttribute.RequireAwait"/> is true, the attribute will only take effect if the method invocation is located under the 'await' expression.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.InstantHandleAttribute.RequireAwait">
|
|
<summary>
|
|
Require the method invocation to be used under the 'await' expression for this attribute to take effect on the code analysis engine.
|
|
Can be used for delegate/enumerable parameters of 'async' methods.
|
|
</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.MustDisposeResourceAttribute">
|
|
<summary>
|
|
Indicates that the resource disposal must be handled by the use site,
|
|
meaning that the resource ownership is transferred to the callee.
|
|
This annotation can be used to annotate disposable types or their constructors individually to enable
|
|
the resource disposal IDE code analysis in every context where the new instance of this type is created.
|
|
Factory methods and 'out' parameters can also be annotated to indicate that the return value of disposable type
|
|
needs handling.
|
|
</summary>
|
|
<remarks>
|
|
Annotation of input parameters with this attribute is meaningless.<br/>
|
|
Constructors inherit this attribute from their type, if it is annotated,
|
|
but not from the base constructors they delegate to (if any).<br/>
|
|
Resource disposal is expected to be expressed via either <c>using (resource)</c> statement,
|
|
<c>using var</c> declaration, explicit 'Dispose' method call, or an argument passing
|
|
to a parameter with the <see cref="T:JetBrains.Annotations.HandlesResourceDisposalAttribute"/> attribute applied.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.MustDisposeResourceAttribute.Value">
|
|
<summary>
|
|
When set to <c>false</c>, disposing of the resource is not obligatory.
|
|
The main use-case for explicit <c>[MustDisposeResource(false)]</c> annotation is to loosen inherited annotation.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.HandlesResourceDisposalAttribute">
|
|
<summary>
|
|
Indicates that method or class instance acquires resource ownership and will dispose it after use.
|
|
</summary>
|
|
<remarks>
|
|
Annotation of 'out' parameter with this attribute is meaningless.<br/>
|
|
When a instance method is annotated with this attribute,
|
|
it means that it is handling the resource disposal of the corresponding resource instance.<br/>
|
|
When a field or a property is annotated with this attribute, it means that this type owns the resource
|
|
and will handle the resource disposal properly (e.g. in own IDisposable implementation).
|
|
</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, the IDE checks the input argument of this parameter:
|
|
* When a lambda expression or anonymous method is passed as an argument, the 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 a warning is produced.
|
|
* The IDE warns when the 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, the IDE will also suggest to annotate the anonymous function with the '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 the 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 the call site.
|
|
</summary>
|
|
<remarks>
|
|
Template method bodies 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.
|
|
The expression to be used in the expansion can be adjusted by the <see cref="P:JetBrains.Annotations.SourceTemplateAttribute.Target"/> parameter.
|
|
</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 the caret inside the block:
|
|
<code>
|
|
[SourceTemplate]
|
|
public static void forEach<T>(this IEnumerable<T> xs) {
|
|
foreach (var x in xs) {
|
|
//$ $END$
|
|
}
|
|
}
|
|
</code>
|
|
</example>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.SourceTemplateAttribute.Target">
|
|
<summary>
|
|
Allows specifying which expression to capture for template execution if more than one present on the expansion.
|
|
If not specified, <see cref="F:JetBrains.Annotations.SourceTemplateTargetExpression.Inner"/> is assumed.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.SourceTemplateTargetExpression">
|
|
<summary>
|
|
Provides a value for the <see cref="T:JetBrains.Annotations.SourceTemplateAttribute"/> to define how to capture
|
|
the expression at the point of expansion
|
|
</summary>
|
|
</member>
|
|
<member name="F:JetBrains.Annotations.SourceTemplateTargetExpression.Inner">
|
|
<summary>Selects inner expression</summary>
|
|
<example><c>value > 42.{caret}</c> captures <c>42</c></example>
|
|
<example><c>_args = args.{caret}</c> captures <c>args</c></example>
|
|
</member>
|
|
<member name="F:JetBrains.Annotations.SourceTemplateTargetExpression.Outer">
|
|
<summary>Selects outer expression</summary>
|
|
<example><c>value > 42.{caret}</c> captures <c>value > 42</c></example>
|
|
<example><c>_args = args.{caret}</c> captures whole assignment</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 to -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.CollectionAccessAttribute">
|
|
<summary>
|
|
Indicates how a method, constructor invocation, or property access
|
|
over a collection type affects the contents of the collection.
|
|
When applied to a return value of a method, indicates if the returned collection
|
|
is created exclusively for the caller (CollectionAccessType.UpdatedContent) or
|
|
can be read/updated from outside (CollectionAccessType.Read | CollectionAccessType.UpdatedContent)
|
|
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 an 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 the <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 the 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 an 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.InjectedLanguage">
|
|
<summary>
|
|
Language of injected code fragment inside marked by the <see cref="T:JetBrains.Annotations.LanguageInjectionAttribute"/> string literal.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.LanguageInjectionAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter, field, or property is accepting a string literal
|
|
containing code fragments in a specified language.
|
|
</summary>
|
|
<example><code>
|
|
void Foo([LanguageInjection(InjectedLanguage.CSS, Prefix = "body{", Suffix = "}")] string cssProps)
|
|
{
|
|
// cssProps should only contains a list of CSS properties
|
|
}
|
|
</code></example>
|
|
<example><code>
|
|
void Bar([LanguageInjection("json")] string json)
|
|
{
|
|
}
|
|
</code></example>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.LanguageInjectionAttribute.InjectedLanguage">
|
|
<summary>Specifies a language of the injected code fragment.</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.LanguageInjectionAttribute.InjectedLanguageName">
|
|
<summary>Specifies a language name of the injected code fragment.</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.LanguageInjectionAttribute.Prefix">
|
|
<summary>Specifies a string that "precedes" the injected string literal.</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.LanguageInjectionAttribute.Suffix">
|
|
<summary>Specifies a string that "follows" the injected string literal.</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.CodeTemplateAttribute">
|
|
<summary>
|
|
<para>
|
|
Defines the code search template using the Structural Search and Replace syntax.
|
|
It allows you to find and, if necessary, replace blocks of code that match a specific pattern.
|
|
Search and replace patterns consist of a textual part and placeholders.
|
|
Textural part must contain only identifiers allowed in the target language and will be matched exactly (white spaces, tabulation characters, and line breaks are ignored).
|
|
Placeholders allow matching variable parts of the target code blocks.
|
|
A placeholder has the following format: $placeholder_name$- where placeholder_name is an arbitrary identifier.
|
|
</para>
|
|
<para>
|
|
Available placeholders:
|
|
<list type="bullet">
|
|
<item>$this$ - expression of containing type</item>
|
|
<item>$thisType$ - containing type</item>
|
|
<item>$member$ - current member placeholder</item>
|
|
<item>$qualifier$ - this placeholder is available in the replace pattern and can be used to insert a qualifier expression matched by the $member$ placeholder.
|
|
(Note that if $qualifier$ placeholder is used, then $member$ placeholder will match only qualified references)</item>
|
|
<item>$expression$ - expression of any type</item>
|
|
<item>$identifier$ - identifier placeholder</item>
|
|
<item>$args$ - any number of arguments</item>
|
|
<item>$arg$ - single argument</item>
|
|
<item>$arg1$ ... $arg10$ - single argument</item>
|
|
<item>$stmts$ - any number of statements</item>
|
|
<item>$stmt$ - single statement</item>
|
|
<item>$stmt1$ ... $stmt10$ - single statement</item>
|
|
<item>$name{Expression, 'Namespace.FooType'}$ - expression with 'Namespace.FooType' type</item>
|
|
<item>$expression{'Namespace.FooType'}$ - expression with 'Namespace.FooType' type</item>
|
|
<item>$name{Type, 'Namespace.FooType'}$ - 'Namespace.FooType' type</item>
|
|
<item>$type{'Namespace.FooType'}$ - 'Namespace.FooType' type</item>
|
|
<item>$statement{1,2}$ - 1 or 2 statements</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Note that you can also define your own placeholders of the supported types and specify arguments for each placeholder type.
|
|
This can be done using the following format: $name{type, arguments}$. Where 'name' - is the name of your placeholder,
|
|
'type' - is the type of your placeholder (one of the following: Expression, Type, Identifier, Statement, Argument, Member),
|
|
'arguments' - arguments list for your placeholder. Each placeholder type supports its own arguments, check examples below for more details.
|
|
The placeholder type may be omitted and determined from the placeholder name, if the name has one of the following prefixes:
|
|
<list type="bullet">
|
|
<item>expr, expression - expression placeholder, e.g. $exprPlaceholder{}$, $expressionFoo{}$</item>
|
|
<item>arg, argument - argument placeholder, e.g. $argPlaceholder{}$, $argumentFoo{}$</item>
|
|
<item>ident, identifier - identifier placeholder, e.g. $identPlaceholder{}$, $identifierFoo{}$</item>
|
|
<item>stmt, statement - statement placeholder, e.g. $stmtPlaceholder{}$, $statementFoo{}$</item>
|
|
<item>type - type placeholder, e.g. $typePlaceholder{}$, $typeFoo{}$</item>
|
|
<item>member - member placeholder, e.g. $memberPlaceholder{}$, $memberFoo{}$</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Expression placeholder arguments:
|
|
<list type="bullet">
|
|
<item>expressionType - string value in single quotes, specifies full type name to match (empty string by default)</item>
|
|
<item>exactType - boolean value, specifies if expression should have exact type match (false by default)</item>
|
|
</list>
|
|
Examples:
|
|
<list type="bullet">
|
|
<item>$myExpr{Expression, 'Namespace.FooType', true}$ - defines expression placeholder, matching expressions of the 'Namespace.FooType' type with exact matching.</item>
|
|
<item>$myExpr{Expression, 'Namespace.FooType'}$ - defines expression placeholder, matching expressions of the 'Namespace.FooType' type or expressions which can be implicitly converted to 'Namespace.FooType'.</item>
|
|
<item>$myExpr{Expression}$ - defines expression placeholder, matching expressions of any type.</item>
|
|
<item>$exprFoo{'Namespace.FooType', true}$ - defines expression placeholder, matching expressions of the 'Namespace.FooType' type with exact matching.</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Type placeholder arguments:
|
|
<list type="bullet">
|
|
<item>type - string value in single quotes, specifies full type name to match (empty string by default)</item>
|
|
<item>exactType - boolean value, specifies if expression should have exact type match (false by default)</item>
|
|
</list>
|
|
Examples:
|
|
<list type="bullet">
|
|
<item>$myType{Type, 'Namespace.FooType', true}$ - defines type placeholder, matching 'Namespace.FooType' types with exact matching.</item>
|
|
<item>$myType{Type, 'Namespace.FooType'}$ - defines type placeholder, matching 'Namespace.FooType' types or types, which can be implicitly converted to 'Namespace.FooType'.</item>
|
|
<item>$myType{Type}$ - defines type placeholder, matching any type.</item>
|
|
<item>$typeFoo{'Namespace.FooType', true}$ - defines types placeholder, matching 'Namespace.FooType' types with exact matching.</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Identifier placeholder arguments:
|
|
<list type="bullet">
|
|
<item>nameRegex - string value in single quotes, specifies regex to use for matching (empty string by default)</item>
|
|
<item>nameRegexCaseSensitive - boolean value, specifies if name regex is case sensitive (true by default)</item>
|
|
<item>type - string value in single quotes, specifies full type name to match (empty string by default)</item>
|
|
<item>exactType - boolean value, specifies if expression should have exact type match (false by default)</item>
|
|
</list>
|
|
Examples:
|
|
<list type="bullet">
|
|
<item>$myIdentifier{Identifier, 'my.*', false, 'Namespace.FooType', true}$ - defines identifier placeholder, matching identifiers (ignoring case) starting with 'my' prefix with 'Namespace.FooType' type.</item>
|
|
<item>$myIdentifier{Identifier, 'my.*', true, 'Namespace.FooType', true}$ - defines identifier placeholder, matching identifiers (case sensitively) starting with 'my' prefix with 'Namespace.FooType' type.</item>
|
|
<item>$identFoo{'my.*'}$ - defines identifier placeholder, matching identifiers (case sensitively) starting with 'my' prefix.</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Statement placeholder arguments:
|
|
<list type="bullet">
|
|
<item>minimalOccurrences - minimal number of statements to match (-1 by default)</item>
|
|
<item>maximalOccurrences - maximal number of statements to match (-1 by default)</item>
|
|
</list>
|
|
Examples:
|
|
<list type="bullet">
|
|
<item>$myStmt{Statement, 1, 2}$ - defines statement placeholder, matching 1 or 2 statements.</item>
|
|
<item>$myStmt{Statement}$ - defines statement placeholder, matching any number of statements.</item>
|
|
<item>$stmtFoo{1, 2}$ - defines statement placeholder, matching 1 or 2 statements.</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Argument placeholder arguments:
|
|
<list type="bullet">
|
|
<item>minimalOccurrences - minimal number of arguments to match (-1 by default)</item>
|
|
<item>maximalOccurrences - maximal number of arguments to match (-1 by default)</item>
|
|
</list>
|
|
Examples:
|
|
<list type="bullet">
|
|
<item>$myArg{Argument, 1, 2}$ - defines argument placeholder, matching 1 or 2 arguments.</item>
|
|
<item>$myArg{Argument}$ - defines argument placeholder, matching any number of arguments.</item>
|
|
<item>$argFoo{1, 2}$ - defines argument placeholder, matching 1 or 2 arguments.</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
Member placeholder arguments:
|
|
<list type="bullet">
|
|
<item>docId - string value in single quotes, specifies XML documentation id of the member to match (empty by default)</item>
|
|
</list>
|
|
Examples:
|
|
<list type="bullet">
|
|
<item>$myMember{Member, 'M:System.String.IsNullOrEmpty(System.String)'}$ - defines member placeholder, matching 'IsNullOrEmpty' member of the 'System.String' type.</item>
|
|
<item>$memberFoo{'M:System.String.IsNullOrEmpty(System.String)'}$ - defines member placeholder, matching 'IsNullOrEmpty' member of the 'System.String' type.</item>
|
|
</list>
|
|
</para>
|
|
<para>
|
|
For more information please refer to the <a href="https://www.jetbrains.com/help/resharper/Navigation_and_Search__Structural_Search_and_Replace.html">Structural Search and Replace</a> article.
|
|
</para>
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.SearchTemplate">
|
|
<summary>
|
|
Structural search pattern to use in the code template.
|
|
The pattern includes a textual part, which must contain only identifiers allowed in the target language,
|
|
and placeholders, which allow matching variable parts of the target code blocks.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.Message">
|
|
<summary>
|
|
Message to show when the search pattern was found.
|
|
You can also prepend the message text with "Error:", "Warning:", "Suggestion:" or "Hint:" prefix to specify the pattern severity.
|
|
Code patterns with replace templates produce suggestions by default.
|
|
However, if a replace template is not provided, then warning severity will be used.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.ReplaceTemplate">
|
|
<summary>
|
|
Structural search replace pattern to use in code template replacement.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.ReplaceMessage">
|
|
<summary>
|
|
The replace message to show in the light bulb.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.FormatAfterReplace">
|
|
<summary>
|
|
Apply code formatting after code replacement.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.MatchSimilarConstructs">
|
|
<summary>
|
|
Whether similar code blocks should be matched.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.ShortenReferences">
|
|
<summary>
|
|
Automatically insert namespace import directives or remove qualifiers that become redundant after the template is applied.
|
|
</summary>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.CodeTemplateAttribute.SuppressionKey">
|
|
<summary>
|
|
The string to use as a suppression key.
|
|
By default the following suppression key is used 'CodeTemplate_SomeType_SomeMember',
|
|
where 'SomeType' and 'SomeMember' are names of the associated containing type and member to which this attribute is applied.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.IgnoreSpellingAndGrammarErrorsAttribute">
|
|
<summary>
|
|
Indicates that the string literal, passed as an argument matching this parameter,
|
|
should not be checked on spelling or grammar errors.
|
|
</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.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 the application's Startup with the 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, renaming and other features
|
|
in URI string literals assigned to annotated parameters, fields, or properties.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspRouteConventionAttribute">
|
|
<summary>
|
|
Indicates that the marked method declares routing convention for ASP.NET.
|
|
</summary>
|
|
<remarks>
|
|
The IDE will analyze all usages of methods marked with this attribute,
|
|
and will add all routes to completion, navigation, and other features over URI strings.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspDefaultRouteValuesAttribute">
|
|
<summary>
|
|
Indicates that the marked method parameter contains default route values of routing convention for ASP.NET.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspRouteValuesConstraintsAttribute">
|
|
<summary>
|
|
Indicates that the marked method parameter contains constraints on route values of routing convention for ASP.NET.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspRouteOrderAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter or property contains routing order provided by ASP.NET routing attribute.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspRouteVerbsAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter or property contains HTTP verbs provided by ASP.NET routing attribute.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspAttributeRoutingAttribute">
|
|
<summary>
|
|
Indicates that the marked attribute is used for attribute routing in ASP.NET.
|
|
</summary>
|
|
<remarks>
|
|
The IDE will analyze all usages of attributes marked with this attribute,
|
|
and will add all routes to completion, navigation and other features over URI strings.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspMinimalApiDeclarationAttribute">
|
|
<summary>
|
|
Indicates that the marked method declares an ASP.NET Minimal API endpoint.
|
|
</summary>
|
|
<remarks>
|
|
The IDE will analyze all usages of methods marked with this attribute,
|
|
and will add all routes to completion, navigation and other features over URI strings.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspMinimalApiGroupAttribute">
|
|
<summary>
|
|
Indicates that the marked method declares an ASP.NET Minimal API endpoints group.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspMinimalApiHandlerAttribute">
|
|
<summary>
|
|
Indicates that the marked parameter contains an ASP.NET Minimal API endpoint handler.
|
|
</summary>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.AspMinimalApiImplicitEndpointDeclarationAttribute">
|
|
<summary>
|
|
Indicates that the marked method contains Minimal API endpoint declaration.
|
|
</summary>
|
|
<remarks>
|
|
The IDE will analyze all usages of methods marked with this attribute,
|
|
and will add all declared in attributes routes to completion, navigation and other features over URI strings.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.AspMinimalApiImplicitEndpointDeclarationAttribute.QueryParameters">
|
|
<summary>
|
|
Comma-separated list of query parameters defined for endpoint
|
|
</summary>
|
|
</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.XamlItemsControlAttribute">
|
|
<summary>
|
|
XAML attribute. Indicates the type that has an <c>ItemsSource</c> property and should be treated
|
|
as an <c>ItemsControl</c>-derived type, to enable inner items <c>DataContext</c> type resolution.
|
|
</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 an <c>ItemsControl</c>-derived type. This annotation will
|
|
enable the <c>DataContext</c> type resolve for XAML bindings for such properties.
|
|
</summary>
|
|
<remarks>
|
|
The 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 an <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, or to a 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, or to a DependencyProperty descriptor field otherwise.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.TestSubjectAttribute">
|
|
<summary>
|
|
Specifies the subject being tested by a test class or a test method.
|
|
</summary>
|
|
<remarks>
|
|
The <see cref="T:JetBrains.Annotations.TestSubjectAttribute"/> can be applied to a test class or a test method to indicate what class
|
|
or interface the tests defined in them test. This information can be used by an IDE to provide better navigation
|
|
support or by test runners to group tests by subject and to provide better test reports.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:JetBrains.Annotations.TestSubjectAttribute.Subject">
|
|
<summary>
|
|
Gets the type of the subject being tested.
|
|
</summary>
|
|
</member>
|
|
<member name="M:JetBrains.Annotations.TestSubjectAttribute.#ctor(System.Type)">
|
|
<summary>
|
|
Initializes a new instance of the <see cref="T:JetBrains.Annotations.TestSubjectAttribute"/> class with the specified subject type.
|
|
</summary>
|
|
<param name="subject">The type of the subject being tested.</param>
|
|
</member>
|
|
<member name="T:JetBrains.Annotations.MeansTestSubjectAttribute">
|
|
<summary>
|
|
Signifies a generic argument as the test subject for a test class.
|
|
</summary>
|
|
<remarks>
|
|
The <see cref="T:JetBrains.Annotations.MeansTestSubjectAttribute"/> can be applied to a generic parameter of a base test class to indicate that
|
|
the type passed as the argument is the class being tested. This information can be used by an IDE to provide better
|
|
navigation support or by test runners to group tests by subject and to provide better test reports.
|
|
</remarks>
|
|
<example><code>
|
|
public class BaseTestClass<[MeansTestSubject] T>
|
|
{
|
|
protected T Component { get; }
|
|
}
|
|
|
|
public class CalculatorAdditionTests : BaseTestClass<Calculator>
|
|
{
|
|
[Test]
|
|
public void Should_add_two_numbers()
|
|
{
|
|
Assert.That(Component.Add(2, 3), Is.EqualTo(5));
|
|
}
|
|
}
|
|
</code></example>
|
|
</member>
|
|
</members>
|
|
</doc>
|