nuget updates
This commit is contained in:
StellaOps Bot
@@ -0,0 +1,47 @@
|
||||
{
|
||||
"runtimeTarget": {
|
||||
"name": ".NETStandard,Version=v2.0/",
|
||||
"signature": ""
|
||||
},
|
||||
"compilationOptions": {},
|
||||
"targets": {
|
||||
".NETStandard,Version=v2.0": {},
|
||||
".NETStandard,Version=v2.0/": {
|
||||
"JetBrains.Annotations/2021.2": {
|
||||
"dependencies": {
|
||||
"NETStandard.Library": "2.0.3"
|
||||
},
|
||||
"runtime": {
|
||||
"JetBrains.Annotations.dll": {}
|
||||
}
|
||||
},
|
||||
"Microsoft.NETCore.Platforms/1.1.0": {},
|
||||
"NETStandard.Library/2.0.3": {
|
||||
"dependencies": {
|
||||
"Microsoft.NETCore.Platforms": "1.1.0"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"libraries": {
|
||||
"JetBrains.Annotations/2021.2": {
|
||||
"type": "project",
|
||||
"serviceable": false,
|
||||
"sha512": ""
|
||||
},
|
||||
"Microsoft.NETCore.Platforms/1.1.0": {
|
||||
"type": "package",
|
||||
"serviceable": true,
|
||||
"sha512": "sha512-kz0PEW2lhqygehI/d6XsPCQzD7ff7gUJaVGPVETX611eadGsA3A877GdSlU0LRVMCTH/+P3o2iDTak+S08V2+A==",
|
||||
"path": "microsoft.netcore.platforms/1.1.0",
|
||||
"hashPath": "microsoft.netcore.platforms.1.1.0.nupkg.sha512"
|
||||
},
|
||||
"NETStandard.Library/2.0.3": {
|
||||
"type": "package",
|
||||
"serviceable": true,
|
||||
"sha512": "sha512-st47PosZSHrjECdjeIzZQbzivYBJFv6P2nv4cj2ypdI204DO+vZ7l5raGMiX4eXMJ53RfOIg+/s4DHVZ54Nu2A==",
|
||||
"path": "netstandard.library/2.0.3",
|
||||
"hashPath": "netstandard.library.2.0.3.nupkg.sha512"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,823 @@
|
||||
<?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>
|
||||
Reference in New Issue
Block a user