ReSharper for Visual Studio Code

https://www.jetbrains.com/help/resharper-vscode/
Admin
ReSharper for Visual Studio Code is a code intelligence extension that brings advanced C#...
Tokens:169,041
Snippets:956
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install NuGet Packages with .NET CLI

Source: https://www.jetbrains.com/help/resharper-vscode/Manage_net_projects_solutions

This snippet demonstrates how to install NuGet packages into a .NET project using the .NET Command Line Interface (CLI). It shows the basic command structure and an example with a specific package and version. Ensure you are in the directory containing the .csproj file before executing.

```shell
dotnet add package <package.name>
```

```shell
dotnet add package JetBrains.Annotations --version 2025.1.0
```

--------------------------------

### Install ReSharper Extension

Source: https://www.jetbrains.com/help/resharper-vscode/Get_started

Instructions for installing the ReSharper extension for Visual Studio Code via the Marketplace or by installing a VSIX file for IDEs without marketplace access.

```vscode-command
>Extensions: Install from Marketplace
Search for 'ReSharper' and click Install.
```

```vscode-command
>Extensions: Install from VSIX...
Select the downloaded .vsix file.
```

--------------------------------

### General C# Syntax Example

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Illustrates basic C# arithmetic and logical operations within a method. This serves as a general code example.

```csharp
internal void Calculate() {
  var x = 5 + 3 - 2 * 3 / 4;
  var e = x != null == (y != null);
}
```

--------------------------------

### WeatherService Examples (All Qualified)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Presents a comprehensive example of accessing all static members of WeatherService with explicit qualification.

```csharp
using System;

internal class WeatherService {
    static WeatherService() {
        Console.WriteLine(WeatherService.Name);
        Console.WriteLine(WeatherService.Version);
        WeatherService.GotRequest += (_, _) => { };
    }
    public static string Name = WeatherService.GetString();
    public static Version Version => new(1, 2, 3);
    public static EventHandler GotRequest;
    public static string GetString() {
        return "abc";
    }
}
```

--------------------------------

### StringFormatMethodAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Marks a method that formats a string using a pattern and arguments, similar to System.String.Format. The constructor specifies the format string parameter. Includes an example with a format string warning.

```csharp
[StringFormatMethod("message")]
void ShowError(string message, params object[] args) { /* do something */ }
void Foo() {
ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
}
```

--------------------------------

### StructuredMessageTemplateAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Indicates that a parameter is a message template where placeholders are replaced by subsequent arguments in order. Shows an example of logging with a template and a warning for missing arguments.

```csharp
void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
void Foo() {
LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
}
```

--------------------------------

### WeatherService Examples (Method Access)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Illustrates accessing static members of WeatherService, focusing on method calls with explicit qualification for GetString.

```csharp
using System;

internal class WeatherService {
    static WeatherService() {
        Console.WriteLine(Name);
        Console.WriteLine(Version);
        GotRequest += (_, _) => { };
    }
    public static string Name = WeatherService.GetString();
    public static Version Version => new(1, 2, 3);
    public static EventHandler GotRequest;
    public static string GetString() {
        return "abc";
    }
}
```

--------------------------------

### C# Class Formatting Example

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Demonstrates how ReSharper can format C# classes by adjusting method visibility and return type styles. This example shows the transformation from a less structured format to a more standardized internal class structure.

```csharp
class Preview {
    void VoidReturningMethod(DB db) { Drop(db); }
    int Assignment(int value) { return Property = value; }
    Action ReturnStatementBodiedLambda() { return () => { Foo(); }; }
}
```

```csharp
internal class Preview {
    private void VoidReturningMethod(DB db) { Drop(db); }
    private int Assignment(int value) { return Property = value; }
    private Action ReturnStatementBodiedLambda() { return () => { Foo(); }; }
}
```

--------------------------------

### WeatherService Examples (None)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Demonstrates the default usage of the WeatherService class, showing static member access without explicit qualification.

```csharp
using System;

internal class WeatherService {
    static WeatherService() {
        Console.WriteLine(Name);
        Console.WriteLine(Version);
        GotRequest += (_, _) => { };
    }
    public static string Name = GetString();
    public static Version Version => new(1, 2, 3);
    public static EventHandler GotRequest;
    public static string GetString() {
        return "abc";
    }
}
```

--------------------------------

### WeatherService Examples (Event Access)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Demonstrates accessing static members of WeatherService, specifically focusing on event subscription with explicit qualification for GotRequest.

```csharp
using System;

internal class WeatherService {
    static WeatherService() {
        Console.WriteLine(Name);
        Console.WriteLine(Version);
        GotRequest += (_, _) => { };
    }
    public static string Name = GetString();
    public static Version Version => new(1, 2, 3);
    public static EventHandler GotRequest;
    public static string GetString() {
        return "abc";
    }
}
```

--------------------------------

### Invoke Live Template with Shortcut

Source: https://www.jetbrains.com/help/resharper-vscode/Templates__Applying_Templates__Creating_Source_Code_Using_Live_Templates

Demonstrates invoking a live template by typing its shortcut. This example uses 'psvm' to generate a public static void Main method signature.

```C#
psvm
```

--------------------------------

### Main method declaration C#

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Declares the standard `public static void Main(string[] args)` method. The caret is positioned after the method signature to start coding the entry point.

```csharp
public static void Main( string[] args ) { $END$ }
```

--------------------------------

### C# Logging Function Example

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

A simple C# method that logs a string to the console if it is not null. This example demonstrates basic C# syntax and conditional logic.

```csharp
public void Log(string? text) { if (text is not null) Console.WriteLine(text); }
```

--------------------------------

### Wrap Before First Method Call Example (C#)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_LineBreaksPageSchema

Demonstrates the effect of wrapping code before the first method call in a chain. The 'true' example shows wrapping, while 'false' keeps it on a single line if possible.

```csharp
obj .Method() .Method() .Method() .Method() .Method() .Method() .Method() .Method() .Method() .Method();
```

```csharp
obj.Method() .Method() .Method() .Method() .Method() .Method() .Method() .Method() .Method() .Method();
```

--------------------------------

### Install JetBrains.Annotations Package (.NET CLI)

Source: https://www.jetbrains.com/help/resharper-vscode/Code_Analysis__Annotations_in_Source_Code

Installs the JetBrains.Annotations NuGet package into your .NET project. This package provides attributes for enhancing code analysis with ReSharper. Ensure you are in the directory containing your .csproj file before running.

```dotnetcli
dotnet add package JetBrains.Annotations
```

--------------------------------

### WeatherService Examples (Field Access)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Illustrates accessing static members of WeatherService, specifically focusing on field access with explicit qualification.

```csharp
using System;

internal class WeatherService {
    static WeatherService() {
        Console.WriteLine(WeatherService.Name);
        Console.WriteLine(Version);
        WeatherService.GotRequest += (_, _) => { };
    }
    public static string Name = GetString();
    public static Version Version => new(1, 2, 3);
    public static EventHandler GotRequest;
    public static string GetString() {
        return "abc";
    }
}
```

--------------------------------

### WeatherService Examples (Property Access)

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Shows accessing static members of WeatherService, with an emphasis on property access and explicit qualification for the Version property.

```csharp
using System;

internal class WeatherService {
    static WeatherService() {
        Console.WriteLine(Name);
        Console.WriteLine(WeatherService.Version);
        GotRequest += (_, _) => { };
    }
    public static string Name = GetString();
    public static Version Version => new(1, 2, 3);
    public static EventHandler GotRequest;
    public static string GetString() {
        return "abc";
    }
}
```

--------------------------------

### LINQ From Clause (C#)

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Creates a C# LINQ 'from' clause to start a query. It requires a variable name and a collection to query from. Supports C# 3.0+ expressions and queries.

```C#
from $VAR$ in $COLLECTION$ $END$
```

--------------------------------

### C# Code Formatting: Bitwise Inclusive Or

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Illustrates code formatting adjustments for bitwise inclusive OR operations. The example shows how parentheses might be added or removed to clarify the order of operations.

```C#
void Calculate() { var x = 12 - ((3 % 4) * 12); var y = ((9 >> ((12 + x) - 1)) << (2 + 1)) & ((6 + (4 * 12)) - 1); var z = ((2 | 7) + 1) & y; var a = 12 - 3 % 4 * 12; var b = 9 >> 12 + a - 1 << 2 + 1 & 6 + 4 * 12 - 1; var c = (2 | 7) + 1 & b; var d = x > 5 && y < 6 || z == 7; }
```

```C#
internal void Calculate() { var x = 12 - 3 % 4 * 12; var y = 9 >> 12 + x - 1 << 2 + 1 & 6 + 4 * 12 - 1; var z = (2 | 7) + 1 & y; var a = 12 - 3 % 4 * 12; var b = 9 >> 12 + a - 1 << 2 + 1 & 6 + 4 * 12 - 1; var c = (2 | 7) + 1 & b; var d = (x > 5 && y < 6) || z == 7; }
```

--------------------------------

### DefaultEqualityUsage Attribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Demonstrates the use of the DefaultEqualityUsage attribute in C# for types that rely on default equality implementations, often highlighting potential warnings when these defaults are used implicitly.

```C#
struct StructWithDefaultEquality { }
class MySet<[DefaultEqualityUsage] T> { }
static class Extensions {
public static MySet<T> ToMySet<[DefaultEqualityUsage] T>(this IEnumerable<T> items) => new();
}
class MyList<T> { public int IndexOf([DefaultEqualityUsage] T item) => 0; }
class UsesDefaultEquality {
void Test() {
var list = new MyList<StructWithDefaultEquality>();
list.IndexOf(new StructWithDefaultEquality()); // Warning: Default equality of struct 'StructWithDefaultEquality' is used
var set = new MySet<StructWithDefaultEquality>(); // Warning: Default equality of struct 'StructWithDefaultEquality' is used
var set2 = new StructWithDefaultEquality[1].ToMySet(); // Warning: Default equality of struct 'StructWithDefaultEquality' is used
}
}
```

--------------------------------

### C# Code Formatting: Conditional AND

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Shows code formatting applied to conditional AND (`&&`) operations. The example highlights how explicit parentheses can be added around conditions for improved clarity.

```C#
void Calculate() { var x = 12 - ((3 % 4) * 12); var y = ((9 >> ((12 + x) - 1)) << (2 + 1)) & ((6 + (4 * 12)) - 1); var z = ((2 | 7) + 1) & y; var a = 12 - 3 % 4 * 12; var b = 9 >> 12 + a - 1 << 2 + 1 & 6 + 4 * 12 - 1; var c = (2 | 7) + 1 & b; var d = x > 5 && y < 6 || z == 7; }
```

```C#
internal void Calculate() { var x = 12 - 3 % 4 * 12; var y = 9 >> 12 + x - 1 << 2 + 1 & 6 + 4 * 12 - 1; var z = (2 | 7) + 1 & y; var a = 12 - 3 % 4 * 12; var b = 9 >> 12 + a - 1 << 2 + 1 & 6 + 4 * 12 - 1; var c = (2 | 7) + 1 & b; var d = ((x > 5) && (y < 6)) || z == 7; }
```

--------------------------------

### Parameter Name Hints Example (C#)

Source: https://www.jetbrains.com/help/resharper-vscode/Inline_Parameter_Name_Hints

Demonstrates how ReSharper for VS Code displays parameter names as inlay hints for method calls, improving code clarity. This feature helps understand arguments without needing to consult method signatures.

```C#
AddCheckbox(true, true, "AutoFill", null);
```

--------------------------------

### C# Positional Argument Formatting Example

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Demonstrates how C# code can be automatically formatted to use positional arguments consistently. This feature helps in standardizing code style for better readability and maintainability.

```csharp
public class Arguments {
    public void Style() {
        Bar(1, d, true, "abc", Fx.F1, () => Bar(1));
        Bar(1, d, true, "abc", Fx.F1, action: () => Bar(1));
        Bar(1, d, true, "abc", e: Fx.F1, action: () => Bar(1));
        Bar(1, d, true, s: "abc", e: Fx.F1, action: () => Bar(1));
        Bar(1, d, b: true, s: "abc", e: Fx.F1, action: () => Bar(1));
        Bar(1, y: d, b: true, s: "abc", e: Fx.F1, action: () => Bar(1));
        Bar(x: 1, y: d, b: true, s: "abc", e: Fx.F1, action: () => Bar(1));
    }

    public void Bar(int x, int y, bool b, string s, Fx e, Action action = null) {
    }

    private enum Fx {
        F1,
        F2,
        F3
    }
}
```

--------------------------------

### ValueProviderAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Specifies a type containing static or const fields to provide values for annotated properties/fields/parameters, improving completion suggestions. Demonstrates usage with a constants class.

```csharp
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*/
}
}
}
```

--------------------------------

### C# Named Argument Formatting Example

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Illustrates the automatic formatting of C# code to utilize named arguments. This formatting style enhances clarity by explicitly stating the parameter name for each argument passed, especially useful for optional parameters or when arguments are out of order.

```csharp
public class Arguments {
    public void Style() {
        Bar(1, d, true, "abc", Fx.F1, action: () => Bar(1));
        Bar(1, d, true, "abc", Fx.F1, action: () => Bar(1));
        Bar(1, d, true, "abc", e: Fx.F1, action: () => Bar(1));
        Bar(1, d, true, s: "abc", e: Fx.F1, action: () => Bar(1));
        Bar(1, d, b: true, s: "abc", e: Fx.F1, action: () => Bar(1));
        Bar(1, y: d, b: true, s: "abc", e: Fx.F1, action: () => Bar(1));
        Bar(x: 1, y: d, b: true, s: "abc", e: Fx.F1, action: () => Bar(1));
    }

    public void Bar(int x, int y, bool b, string s, Fx e, Action action = null) {
    }

    private enum Fx {
        F1,
        F2,
        F3
    }
}
```

--------------------------------

### Expression Selection Examples

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Illustrates how ReSharper's expression selection feature works by capturing parts of code based on context. The '{caret}' symbol indicates the cursor position.

```text
Example: `value > 42.{caret}` captures `42`
```

```text
Example: `_args = args.{caret}` captures `args`
```

```text
Example: `value > 42.{caret}` captures `value > 42`
```

```text
Example: `_args = args.{caret}` captures whole assignment
```

--------------------------------

### C# Indexer Snippet

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Generates a C# indexer definition with placeholders for access modifier, type, index type, and caret position. Includes basic get and set accessors. Available for C# 2.0+ type members.

```C#
$access$ $type$ this[$indextype$ index] {
    get {$END$
        /* return the specified index here */
    }
    set {
        /* set the specified index to value here */
    }
}
```

--------------------------------

### C# Source Template Example

Source: https://www.jetbrains.com/help/resharper-vscode/Source_Templates

Demonstrates the creation of a C# source template using the [SourceTemplate] attribute. This template, defined as an extension method for IEnumerable<T>, iterates over a collection using a foreach loop. It includes special template parameters like $END$ for caret placement.

```csharp
using JetBrains.Annotations;

public static class MySourceTemplates
{
    [SourceTemplate]
    public static void iterateCollection<T>(this IEnumerable<T> x)
    {
        foreach (var i in x)
        {
            // Do something useful here
            //$ $END$
        }
    }
}
```

--------------------------------

### C# Instance Member Qualification: Members

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Configures which instance members (fields, properties, events, methods) should be qualified with 'this.' or 'Me.'. Options range from no qualification to qualifying all members. Examples show the effect of each setting.

```csharp
using System;

internal class Person {
    public Person(string name, int age) {
        _id = GenerateId();
            Name = name;
            Age = age;
            AgeChanged += (_, newAge) => Age = newAge;
    }

    private readonly int _id;
    public string Name { get; }
    public int Age { get; private set; }
    public event EventHandler<int> AgeChanged;

    public int GenerateId() {
        return 42;
    }
}
```

```csharp
using System;

internal class Person {
    public Person(string name, int age) {
        this._id = GenerateId();
            Name = name;
            Age = age;
            AgeChanged += (_, newAge) => Age = newAge;
    }

    private readonly int _id;
    public string Name { get; }
    public int Age { get; private set; }
    public event EventHandler<int> AgeChanged;

    public int GenerateId() {
        return 42;
    }
}
```

```csharp
using System;

internal class Person {
    public Person(string name, int age) {
        _id = GenerateId();
            this.Name = name;
            this.Age = age;
            AgeChanged += (_, newAge) => Age = newAge;
    }

    private readonly int _id;
    public string Name { get; }
    public int Age { get; private set; }
    public event EventHandler<int> AgeChanged;

    public int GenerateId() {
        return 42;
    }
}
```

```csharp
using System;

internal class Person {
    public Person(string name, int age) {
        _id = GenerateId();
            Name = name;
            Age = age;
            this.AgeChanged += (_, newAge) => Age = newAge;
    }

    private readonly int _id;
    public string Name { get; }
    public int Age { get; private set; }
    public event EventHandler<int> AgeChanged;

    public int GenerateId() {
        return 42;
    }
}
```

```csharp
using System;

internal class Person {
    public Person(string name, int age) {
        _id = this.GenerateId();
            Name = name;
            Age = age;
            AgeChanged += (_, newAge) => Age = newAge;
    }

    private readonly int _id;
    public string Name { get; }
    public int Age { get; private set; }
    public event EventHandler<int> AgeChanged;

    public int GenerateId() {
        return 42;
    }
}
```

```csharp
using System;

internal class Person {
    public Person(string name, int age) {
        this._id = this.GenerateId();
            this.Name = name;
            this.Age = age;
            this.AgeChanged += (_, newAge) => this.Age = newAge;
    }

    private readonly int _id;
    public string Name { get; }
    public int Age { get; private set; }
    public event EventHandler<int> AgeChanged;

    public int GenerateId() {
        return 42;
    }
}
```

--------------------------------

### Open Solution in ReSharper

Source: https://www.jetbrains.com/help/resharper-vscode/Get_started

Steps to open a .NET solution folder in Visual Studio Code to enable ReSharper's solution exploration features.

```vscode-command
File | Open Folder
Choose the directory containing your .sln, .slnx, or .slnf file.
```

--------------------------------

### Insert New GUID (C#)

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Generates and inserts a new Globally Unique Identifier (GUID) at the current cursor position. This template can be used anywhere in the code.

```C#
$GUID$
```

--------------------------------

### ValueRangeAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Indicates that an integral value falls within specified intervals, which can be non-intersecting. Boundary values are inclusive. Shows an example with a value range check.

```csharp
void Foo([ValueRange(0, 100)] int value) {
if (value == -1) { // Warning: Expression is always 'false'
...
}
}
```

--------------------------------

### using Statement

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Creates a `using` statement for managing disposable resources. Includes placeholders for the resource and the code block to execute.

```csharp
using($resource$) {
  $SELECTION$$END$
}
```

--------------------------------

### Contract Annotation Syntax and Usage

Source: https://www.jetbrains.com/help/resharper-vscode/Contract_Annotations

Defines the syntax for contract annotations using the [ContractAnnotationAttribute]. It specifies input-output dependencies for parameters and return values, including handling nullability, boolean logic, and special return states like 'halt'. Examples cover various scenarios like single parameters, no parameters, multiple conditions, reversed conditions, and out parameters.

```APIDOC
[ContractAnnotation("[paramName:][input] =>
output [; [paramName:][input] => output]", [forceFullStates:true])]

Input can be: null/notnull (reference types), true/false (booleans).
Output can be: null/notnull/canbenull (reference types), true/false (booleans), halt/stop/void/nothing (non-normal return).
```

```C#
/* Example: Null argument yields null return */
[ContractAnnotation("input:null => null")]
public string Adjust(string input)
```

```C#
/* Example: Function always halts execution */
[ContractAnnotation("=> halt")]
public void TerminationMethod()
```

```C#
/* Example: Multiple conditions for a parameter */
[ContractAnnotation("input:null => null; input:notnull=>notnull")]
public object Transform(object input, bool flag)
```

```C#
/* Example: Reversed condition (output <= input) */
[ContractAnnotation("null <= surname:null")]
public string GetName(string surname)
```

```C#
/* Example: Specifying return value and out parameter */
[ContractAnnotation("s:null => false,result:null")]
public bool TryParse(string s, out object result)
```

--------------------------------

### Creating and Managing .NET Projects and Solutions

Source: https://www.jetbrains.com/help/resharper-vscode/Manage_net_projects_solutions

This section covers essential .NET CLI commands for creating new projects, solutions, and managing their relationships. These commands are crucial for setting up a .NET development environment within VS Code.

```APIDOC
Creating .NET Projects and Solutions:

1. Create a new .NET project (e.g., console application):
   Command: dotnet new console -o <ProjectName>
   Description: Initializes a new .NET console application project in a specified directory.
   Parameters:
     - ProjectName: The name of the project directory to create.
   Example:
     dotnet new console -o MyConsoleApp

2. Create a new .NET solution:
   Command: dotnet new sln --name <SolutionName>
   Description: Creates a new solution file (.sln) to organize multiple projects.
   Parameters:
     - SolutionName: The desired name for the solution file.
   Example:
     dotnet new sln --name TestSolution

3. Add a project to a solution:
   Command: dotnet sln add <ProjectPath>
   Description: Adds an existing .NET project to the specified solution file.
   Parameters:
     - ProjectPath: The path to the .csproj file of the project to add.
   Example:
     dotnet sln add MyConsoleApp/MyConsoleApp.csproj

4. Create a new .NET class library project:
   Command: dotnet new classlib -o <ProjectName>
   Description: Initializes a new .NET class library project in a specified directory.
   Parameters:
     - ProjectName: The name of the project directory to create.
   Example:
     dotnet new classlib -o TestLib

Related Commands:
  - dotnet new list: Lists available project templates.
  - dotnet sln remove <ProjectPath>: Removes a project from a solution.
  - dotnet sln list: Lists projects within a solution.
```

--------------------------------

### C# Unity CreateAssetMenu Attribute

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Generates the Unity `CreateAssetMenu` attribute for C# scripts. It includes parameters for filename, menu name, and order, with placeholders for customization.

```C#
[UnityEngine.CreateAssetMenu(fileName = $FILENAME$, menuName = $MENUNAME$, order = $ORDER$)]
```

--------------------------------

### NotNullAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Indicates that the marked element's value can never be null. Shows an example of a method returning null when marked as NotNull, triggering a warning.

```csharp
[NotNull] object Foo() {
return null; // Warning: Possible 'null' assignment
}
```

--------------------------------

### Apply Quick Fixes and Context Actions

Source: https://www.jetbrains.com/help/resharper-vscode/Get_started

Using keyboard shortcuts to apply code fixes, resolve issues, and transform code with context actions provided by ReSharper.

```keyboard-shortcut
⌥ ⌘
```

--------------------------------

### ItemCanBeNullAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Applied to collections or Task/Lazy types to indicate that individual items, Task results, or Lazy values can be null. Shows an example of iterating a list of strings marked with ItemCanBeNull.

```csharp
public void Foo([ItemCanBeNull]List<string> books)
{
foreach (var book in
books)
{
// Warning: Possible 'System.NullReferenceException'
Console.WriteLine(book.ToUpper());
}
}
```

--------------------------------

### ContractAnnotationAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Code_Analysis__Code_Annotations

Illustrates the use of ContractAnnotationAttribute to define function contracts, enabling specific code inspections. This example shows how to specify that a function always returns false when its input is null.

```C#
[ContractAnnotation("input:null => false")]
bool Foo(object input) { /* implementation */ }
```

--------------------------------

### C# Static Main Method Snippet

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Creates a static `int Main` method signature, commonly used as the entry point for C# console applications. Includes a return statement and caret position placeholder. Available for C# 2.0+ type members.

```C#
static int Main(string[] args) {
$END$
    return 0;
}
```

--------------------------------

### ASP.NET MVC Action Selector Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Demonstrates the usage of the `AspMvcActionSelectorAttribute` (aliased as `ActionName` in the example) to specify an MVC action name. It shows how the IDE can resolve action references and identify potential errors when actions are not found.

```C#
[ActionName("Foo")]
public ActionResult Login(string returnUrl) {
    ViewBag.ReturnUrl = Url.Action("Foo"); // OK
    return RedirectToAction("Bar"); // Error: Cannot resolve action
}
```

--------------------------------

### MessageBox.Show

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Inserts a call to `System.Windows.Forms.MessageBox.Show` with a placeholder for the message string.

```csharp
System.Windows.Forms.MessageBox.Show("$string$");
```

--------------------------------

### Study Symbol Details with Quick Documentation

Source: https://www.jetbrains.com/help/resharper-vscode/coding-assistance-csharp

Quickly review symbol documentation directly in the editor. Supports formatted documentation (e.g., XML-docs for C#) or basic symbol information like signatures and visibility if no specific documentation is found. Access by hovering.

```IDE Interaction
Hover mouse over symbol
```

--------------------------------

### C# Integer Analysis: Division and Range Example

Source: https://www.jetbrains.com/help/resharper-vscode/Code_Analysis__Integral_Values

Illustrates ReSharper's ability to infer value ranges for integers. In this example, it deduces that `input` is within -100 to 100 before division, helping to identify potential issues or redundancies in subsequent operations.

```csharp
int TestDivision(int input, int delta)
{
const int divider = 500;
if(input < -100 || input > 100)
return input;
input = input / divider;
// do something
return delta + input; // Addition of 0
}
```

--------------------------------

### NonNegativeValueAttribute Example

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Indicates that an integral value will never be less than zero. This is a specific case of ValueRangeAttribute.

```csharp
void ProcessValue([NonNegativeValue] int count) {
// count is guaranteed to be >= 0
}
```

--------------------------------

### Transform Code with Context Actions

Source: https://www.jetbrains.com/help/resharper-vscode/coding-assistance-csharp

Context actions allow for quick, local code transformations. Hundreds of context actions are available for various scenarios, accessible via a dedicated shortcut.

```IDE Shortcut
⌥ ⏎
```

--------------------------------

### Replace logical expression with equal expression

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Options__Languages__CSharp__Context_Actions

Inverts a logical expression, often simplifying conditions. For example, replacing `!(a == b)` with `a != b`.

```C#
// Before:
if (!(x == 5))
{
    // ...
}

// After:
if (x != 5)
{
    // ...
}
```

--------------------------------

### Initialize Field from Constructor Parameter

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Options__Languages__CSharp__Context_Actions

Optionally creates and initializes a field from a constructor parameter. This is a common pattern for setting up object state during instantiation.

```C#
/*
  Feature: Initialize field from constructor parameter
  Description: Optionally creates and initializes field from constructor parameter.
*/
```

--------------------------------

### Property with Get/PrivateSet

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Defines a C# property with a public 'get' accessor and a private 'set' accessor, a common pattern for immutable properties after initialization.

```csharp
public $type$ $property$ {
  get;
  private set;
}
```

--------------------------------

### Reference Qualification and 'using' Directives

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpCodeStylePageImplSchema

Configuration options for managing how references are qualified and where 'using' directives are placed within C# code.

```APIDOC
Group: Reference Qualification
Property names:
  [resharper_]csharp_prefer_qualified_reference
  [resharper_]prefer_qualified_reference

Possible values:
  - true: Prefer fully qualified references (e.g., 'System.Console.WriteLine').
  - false: Prefer unqualified references when a 'using' directive is present.

Group: 'using' Directives Placement
Property names:
  [resharper_]csharp_add_imports_to_deepest_scope
  [resharper_]add_imports_to_deepest_scope

Possible values:
  - true: Add 'using' directives to the deepest possible scope.
  - false: Add 'using' directives to the top of the file.
```

--------------------------------

### Expand Public Static Void Main Template (psvm)

Source: https://www.jetbrains.com/help/resharper-vscode/Code_completion_in_CSharp

Demonstrates the expansion of the 'psvm' live template, which generates a standard 'public static void Main' method signature in C# after being invoked from the completion list.

```csharp
public static void Main(string[] args)
{
}
```

--------------------------------

### ReSharper Build Settings

Source: https://www.jetbrains.com/help/resharper-vscode/Build_projects

Configuration options for ReSharper's build process in Visual Studio Code. These settings allow customization of build paths, output verbosity, package restoration, and the use of ReSharper's optimized build engine.

```APIDOC
ReSharperBuildSettings:
  CustomDotnetCliPath:
    description: "The path to the [.NET CLI tools](https://docs.microsoft.com/en-us/dotnet/core/tools/) executable. Detected automatically, but can be specified for custom installations."
    type: "string"
  CustomMonoPath:
    description: "Path for the Mono executable. Detected automatically by default, but can be specified for non-standard locations."
    type: "string"
  CustomMsbuildPath:
    description: "Path to the MSBuild executable. Uses the latest installed version by default, but can be specified for alternative versions or non-standard locations."
    type: "string"
  OutputVerbosityLevel:
    description: "Controls the verbosity of build-related output messages."
    type: "enum (e.g., Quiet, Minimal, Normal, Detailed, Diagnostic)"
  RestorePackagesOnBuild:
    description: "Restores NuGet packages automatically before initiating a build."
    type: "boolean"
  SmartNugetRestore:
    description: "Runs NuGet restore on build only if it is deemed necessary."
    type: "boolean"
  UseReSharperBuild:
    description: "Enables ReSharper Build for optimizing the build process by tracking changes and rebuilding only modified projects and their dependencies. If disabled, ReSharper delegates the entire solution build to MSBuild.exe. Disable this if your solution has custom build steps."
    type: "boolean"
    default: "true"
```

--------------------------------

### Study Method Signatures with Parameter Info

Source: https://www.jetbrains.com/help/resharper-vscode/coding-assistance-csharp

This feature displays details for allowed arguments across all overloads of a function call. It shows public signatures, parameters, and descriptions from XML documentation when available. It can show the currently used or shortest signature.

```IDE Shortcut
⌘ I
```

--------------------------------

### Disable Redundant Argument Inspection

Source: https://www.jetbrains.com/help/resharper-vscode/Code_inspection_list_CSharp

An example showing how to disable a specific C# code inspection, 'Redundant argument with default value', by setting its EditorConfig property to 'none'.

```EditorConfig
resharper_redundant_argument_default_value_highlighting=none
```

--------------------------------

### C# Static Void Main Method Snippet

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Creates a static `void Main` method signature, another common entry point for C# applications. Includes a placeholder for the caret position. Available for C# 2.0+ type members.

```C#
static void Main(string[] args) {
$END$
}
```

--------------------------------

### Custom Placeholders with Arguments

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Code_Annotation_Attributes

Defines how to create custom placeholders with specific types and arguments for advanced pattern matching in Structural Search and Replace.

```APIDOC
Custom Placeholder Syntax: $name{type, arguments}$

- name: The name of your placeholder.
- type: The type of your placeholder (Expression, Type, Identifier, Statement, Argument, Member).
- arguments: A list of arguments for the placeholder type.

Expression Placeholder Arguments:

- expressionType: string value in single quotes, specifies full type name to match (e.g., 'Namespace.FooType'). Defaults to empty string.
- exactType: boolean value, specifies if expression should have exact type match. Defaults to false.

Examples:
- $myExpr{Expression, 'Namespace.FooType', true}$: Matches expressions of 'Namespace.FooType' with exact type matching.
- $myExpr{Expression, 'Namespace.FooType'}$: Matches expressions of 'Namespace.FooType' or implicitly convertible types.
- $myExpr{Expression}$: Matches expressions of any type.
- $exprFoo{'Namespace.FooType', true}$: Shorthand for expression placeholder with exact type match.

Type Placeholder Arguments:

- type: string value in single quotes, specifies the full type name to match (e.g., 'Namespace.FooType'). Defaults to empty string.
- exactType: boolean value, specifies whether the expression should have the exact type match. Defaults to false.

Examples:
- $myType{Type, 'Namespace.FooType', true}$: Matches 'Namespace.FooType' types with exact matching.
- $myType{Type, 'Namespace.FooType'}$: Matches 'Namespace.FooType' types or implicitly convertible types.
- $myType{Type}$: Matches any type.
- $typeFoo{'Namespace.FooType', true}$: Shorthand for type placeholder with exact type match.

Identifier Placeholder Arguments:

- nameRegex: string value in single quotes, specifies regex to use for matching (e.g., "^My"). Defaults to empty string.
- nameRegexCaseSensitive: boolean value, specifies if name regex is case-sensitive. Defaults to true.
- type: string value in single quotes, specifies full type name to match (e.g., 'System.String'). Defaults to empty string.
- exactType: boolean value, specifies if expression should have exact type match. Defaults to false.

Examples:
- $myIdent{Identifier, "^My.*", false}$: Matches identifiers starting with 'My' case-insensitively.
- $myIdent{Identifier, "^My.*", true, 'System.Int32', true}$: Matches identifiers starting with 'My' case-sensitively, which are of type 'System.Int32' exactly.
```

--------------------------------

### Outdent Binary Operators in C#

Source: https://www.jetbrains.com/help/resharper-vscode/EditorConfig_CSHARP_CSharpIndentStylePageSchema

Determines if binary operators at the start of a new line in a multiline expression should be outdented. This can affect the visual flow and indentation of long expressions.

```csharp
{ var a = someOperand + operand2 + operand3 + operand4; var b = someOperand + operand2 + operand3 + operand4; }
```

--------------------------------

### Set Possible NullReferenceException to Error

Source: https://www.jetbrains.com/help/resharper-vscode/Code_inspection_list_CSharp

An example of configuring a specific C# code inspection, 'Possible 'System.NullReferenceException'', to have an 'error' severity level using its corresponding EditorConfig property.

```EditorConfig
resharper_possible_null_reference_exception_highlighting=error
```

--------------------------------

### Postfix .new: Produces instantiation expression for type in C#

Source: https://www.jetbrains.com/help/resharper-vscode/Postfix_Templates

Applies the .new postfix template to generate an instantiation expression for a given type. This simplifies object creation syntax.

```csharp
new SomeType()
```

--------------------------------

### do-while Loop

Source: https://www.jetbrains.com/help/resharper-vscode/Reference__Templates_Explorer__Live_Templates_CSHARP

Creates a do-while loop structure, ensuring the body executes at least once before checking the condition. Includes placeholders for the condition, selected text, and final caret position.

```csharp
do {
  $SELECTION$$END$
} while ($expression$);
```
Tokens:
Raw