ReSharper Platform SDK

https://www.jetbrains.com/help/resharper/sdk
Admin
The ReSharper Platform SDK is the primary source of documentation for extending .NET related...
Tokens:150,732
Snippets:1,792
Trust Score:10
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install ReSharper Plugin Template

Source: https://www.jetbrains.com/help/resharper/sdk/creating_plugin.html

Install the plugin template from a local .nupkg file. Ensure the file path is correct.

```bash
dotnet new --install JetBrains.ReSharper.SamplePlugin.*.nupkg
```

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

### CSS Example Input File

Source: https://www.jetbrains.com/help/resharper/sdk/Lexing_Testing.html

An example CSS file used as input for lexer testing.

```css
h1 { color: red }
```

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

### Icon Retrieval Example

Source: https://www.jetbrains.com/help/resharper/sdk/PSI_Icons.html

An example demonstrating how to retrieve an icon for a declared element, falling back to a dummy image if necessary.

```APIDOC
## Icon Retrieval Example

### Description
This example shows the typical pattern for retrieving an icon for a declared element, ensuring a fallback icon is used if the primary retrieval fails.

### Code
```csharp
var iconId = manager.GetImage(CLRDeclaredElementType.CONSTRUCTOR) ?? manager.GetDummyImage();
```

### Usage
This pattern is recommended when calling `GetImage` to handle cases where a specific icon might not be available.
```

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

### Xaml Implementation Context Search Example

Source: https://www.jetbrains.com/help/resharper/sdk/Navigation.html

An example of a context search that extends ReSharper's 'Go To Implementation' for XAML. It overrides IsAvailable and IsApplicable to define when and how the search should be performed.

```csharp
[FeaturePart]
public class XamlImplementationContextSearch : ContextNavigation.ContextSearches.BaseSearches.ImplementationContextSearch
{
  protected override bool IsAvailable(IDataContext dataContext)
  {
    return true;
  }

  public override bool IsApplicable(IDataContext dataContext)
  {
    return ContextNavigationUtil.CheckDefaultApplicability<XamlLanguage>(dataContext);
  }

  protected override SearchImplementationsRequest CreateSearchRequest(IDataContext dataContext, IDeclaredElement declaredElement)
  {
    // Your custom logic here...
  }
}
```

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

### CSS Example Gold File Output

Source: https://www.jetbrains.com/help/resharper/sdk/Lexing_Testing.html

The expected output (token types) for the example CSS input file.

```text
IDENTIFIER
WHITE_SPACE
LBRACE
WHITE_SPACE
IDENTIFIER
COLON
WHITE_SPACE
IDENTIFIER
WHITE_SPACE
RBRACE
```

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

### Launch Rider with Plugin

Source: https://www.jetbrains.com/help/resharper/sdk/Rider.html

Instructions on how to launch an experimental Rider installation with the developed plugin using the `runIde` task.

```bash
gradlew :runIde
```

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

### Gold File Example for CSS Parser Output

Source: https://www.jetbrains.com/help/resharper/sdk/Parsing_Testing.html

An example .gold file representing the expected PSI tree structure for a CSS file. It details nodes, tokens, and whitespace.

```text
ICssFile
  CssComment(type:COMMENT, text:/* {caret} */)
  CssNewLineToken(type:NEW_LINE, text:\n) spaces:"\n"
  ICssFileSection
    IRuleset
      IRulesetDeclarationList
        IRulesetDeclaration:body
          ISimpleSelector:body
            ITypeSelector:body
              CssIdentifierToken(type:IDENTIFIER, text:body)
      CssNewLineToken(type:NEW_LINE, text:\n) spaces:"\n"
      ICssPropertyBlock
        CssGenericToken(type:LBRACE, text:{)
        CssNewLineToken(type:NEW_LINE, text:\n) spaces:"\n"
        CssWhitespaceToken(type:WHITE_SPACE, text:  ) spaces:"  "
        ICssPropertyStatement
          ICssProperty
            CssIdentifierToken(type:IDENTIFIER, text:margin)
            CssGenericToken(type:COLON, text::)
            CssWhitespaceToken(type:WHITE_SPACE, text: ) spaces:" "
            ICssPropertyValue
              ICssLiteralExpression
                CssLiteralToken(type:INTEGER_LITERAL, text:0)
          CssGenericToken(type:SEMICOLON, text:;)
        CssNewLineToken(type:NEW_LINE, text:\n) spaces:"\n"
        CssGenericToken(type:RBRACE, text:})

```

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

### CSS File Example for Parsing

Source: https://www.jetbrains.com/help/resharper/sdk/Parsing_Testing.html

An example CSS file used for parser testing. It includes a caret marker for identifying the test location.

```css
/* {caret} */
body
{
  margin: 0;
}
```

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

### GetPsiLanguageType Method Implementation Example

Source: https://www.jetbrains.com/help/resharper/sdk/ProjectFileLanguageService.html

Provides an example implementation of the GetPsiLanguageType method. It returns the appropriate PsiLanguageType for a given project file, handling cases where the language feature might be disabled by returning UnknownLanguage.Instance.

```csharp
public PsiLanguageType GetPsiLanguageType(IProjectFile projectFile)
{
  // Return UnknownLanguage if the actual language instance is null
  // This can happen if the language feature is disabled
  if (projectFile.LanguageType.Is<CssProjectFileType>()) 
    return (PsiLanguageType) CssLanguage.Instance ?? UnknownLanguage.Instance;
  return UnknownLanguage.Instance;
}
```

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

### Initialize LexerDictionary with Keywords

Source: https://www.jetbrains.com/help/resharper/sdk/UtilityClasses.html

Initializes a LexerDictionary with TokenNodeType instances for keywords. This setup is typically done in a static constructor.

```csharp
public partial class MyLexer
{
  public static LexerDictionary<TokenNodeType> myKeywords = new LexerDictionary<TokenNodeType>();

  public static MyLexer()
  {
    foreach (var tokenNodeType in KEYWORDS.OfType(typeof(TokenNodeType)))
      myKeywords[tokenNodeType.TokenRepresentation] = tokenNodeType;
  }

  private TokenNodeType FindKeywordByCurrentToken()
  {
    return keywords.GetValueSafe(myBuffer, yy_buffer, yy_buffer_start, yy_buffer_end);
  }
}
```

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

### Lexer Output Example

Source: https://www.jetbrains.com/help/resharper/sdk/Parsing_Lexing.html

This shows the stream of tokens generated from a C# expression by a lexer.

```text
IDENTIFIER
WHITESPACE
EQUALS
WHITESPACE
INTEGER_LITERAL
SEMI_COLON
```

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

### Example XML Tag Header Usage

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Illustrates how IXmlTagHeader represents opening XML tags, including self-closing ones.

```csharp
The text `<foo baz="quux">` will be an instance of `IXmlTagHeader`. The `StartNode` and `EndNode` properties represent the `<` and `>` characters, and will be instances of the `IXmlTagStartTokenNode` and `IXmlTagEndTokenNode` marker interfaces.
The text `<bar baz="quux" />` will also be an instance of `IXmlTagHeader`, but will return an instance of `IXmlTagEnd1TokenNode` to represent the closing `/>`. It will also return `true` to the `IsClosed` property.
The `Name` property retrieves the `IXmlIdentifier` token that represents the name of the tag. The text for the name can then be retrieved using `Name.XmlName` and `Name.XmlNamespace` properties.
Attributes are accessible via the inherited `IXmlAttributeContainer` interface.
```

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

### Register a Custom Navigation Provider

Source: https://www.jetbrains.com/help/resharper/sdk/Navigation.html

Decorate your custom provider class with `[ShellFeaturePart]` to register it. This example shows a basic structure for a custom provider.

```csharp
[ShellFeaturePart]
class GoToYouTrackIssueProvider : IGotoEverythingProvider
{
  // ...
}
```

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

### CreatePathReferences Method Signature

Source: https://www.jetbrains.com/help/resharper/sdk/PathReferences.html

The generic static method signature for creating path references. It requires owner and token nodes, a base qualifier, and delegate functions for creating folder and file references, getting string values, and their start offsets.

```csharp
public static IPathReference[] CreatePathReferences<TOwner,TToken>(
  TOwner owner, TToken token, IQualifier baseQualifier,
  Func<TOwner, IQualifier, TToken, TreeTextRange, IPathReference> createFolderReferenceDelegate,
  Func<TOwner, IQualifier, TToken, TreeTextRange, IPathReference> createFileReferenceDelegate,
  Func<TToken, string> getStringValueDelegate,
  Func<TToken, int> getValueStartOffset
)
  where TOwner : ITreeNode
  where TToken : class, ITreeNode
{
  // ...
}
```

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

### Implement IGotoEverythingProvider Interface

Source: https://www.jetbrains.com/help/resharper/sdk/Navigation.html

Implement this interface to provide navigation items and define their priority. It includes a sorting function for ordering displayed elements.

```csharp
public interface IGotoEverythingProvider : IOccurrenceNavigationProvider
{
  Func<int, int> ItemsPriorityFunc { get; }
}
```

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

### GetPsiLanguageType Method Example

Source: https://www.jetbrains.com/help/resharper/sdk/ProjectFileLanguageService.html

An example implementation of the `GetPsiLanguageType` method, demonstrating how to return the appropriate `PsiLanguageType` or `UnknownLanguage.Instance`.

```APIDOC
## Method: GetPsiLanguageType

### Description
Returns the `PsiLanguageType` derived instance that represents the custom language of the given project file. Returns `UnknownLanguage.Instance` if the language feature is disabled or the language instance is null.

### Example Implementation
```csharp
public PsiLanguageType GetPsiLanguageType(IProjectFile projectFile)
{
  // Return UnknownLanguage if the actual language instance is null
  // This can happen if the language feature is disabled
  if (projectFile.LanguageType.Is<CssProjectFileType>())
    return (PsiLanguageType) CssLanguage.Instance ?? UnknownLanguage.Instance;
  return UnknownLanguage.Instance;
}
```

### Notes
This method can involve more complex logic, such as checking project types (e.g., `JavaScriptProjectFileLanguageService` checking for Windows JavaScript applications).
```

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

### Action to Open a Tool Window

Source: https://www.jetbrains.com/help/resharper/sdk/CreateToolWindows.html

An example action class that retrieves necessary components and instantiates/shows the custom tool window. Ensure all required components are obtained before creating the tool window instance.

```csharp
[Action("ActionOpenMyToolWindow", "Open a sample tool window", Id = 543211)]
public class ActionOpenMyToolWindow : SampleAction, IInsertLast<MainMenuFeaturesGroup>
{
    protected override void RunAction(IDataContext context, DelegateExecute nextExecute)
    {
        var lifetime = context.GetComponent<Lifetime>();
        var toolWindowManager = context.GetComponent<ToolWindowManager>();
        var toolWindowDescriptor = context.GetComponent<MyToolWindowDescriptor>();
        var environment = context.GetComponent<IUIApplication>();
        var toolWindow = new MyToolWindow(lifetime, toolWindowManager, toolWindowDescriptor, environment);
        toolWindow.Show();
    }
}
```

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

### Acquire Solution Component using Service Locator

Source: https://www.jetbrains.com/help/resharper/sdk/Platform_ComponentModel.html

Demonstrates how to retrieve a solution component using the Service Locator pattern via extension methods on `ISolution`. Ensure the `SOLUTION` constant is available in the current context.

```csharp
var solution = context.GetData(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
var dtm = solution.GetComponent<DocumentTransactionManager>();
```

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

### ResolveWithoutCache Implementation Example

Source: https://www.jetbrains.com/help/resharper/sdk/ReferenceProviders.html

An example implementation of ResolveWithoutCache for a TestCaseSourceAttribute reference. It filters symbols by name and retrieves a resolve result.

```csharp
public override ResolveResultWithInfo ResolveWithoutCache()
{
  return GetReferenceSymbolTable(true).GetResolveResult(GetName());
}
```

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

### WebForms .aspx File Example

Source: https://www.jetbrains.com/help/resharper/sdk/HtmlLike.html

Demonstrates the structure of a WebForms .aspx file, showcasing custom tag delimiters and ASP.NET specific syntax.

```aspx
<%@ Page Title="Home Page" Langauge="C#" MasterPageFile="~/Site.Master" %>

<asp:Content runat="server" ID="BodyContent" ContentPlaceHolderID="MainContent">
  <h2><%: Title %></h2>

  <div>
    <!-- ... -->
  </div>
</asp:Content>
```

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

### Basic IProperty Usage in ReSharper

Source: https://www.jetbrains.com/help/resharper/sdk/WorkWithIProperty.html

Demonstrates how to create and use IProperty for tracking integer values. It shows how to advise on value changes and cancel changes before they occur. Ensure a Lifetime is provided for proper disposal.

```csharp
public class PropertyProvider
{
    public IProperty<int> SomeIntProperty;

    public PropertyProvider(Lifetime lifetime)
    {
        SomeIntProperty = new Property<int>(lifetime, "PropertyProvider.SomeIntProperty");
    }
}


public class PropertyTester
{
    private readonly PropertyProvider _propertyProvider;

    public PropertyTester(Lifetime lifetime, PropertyProvider propertyProvider)
    {
        _propertyProvider = propertyProvider;
        _propertyProvider.SomeIntProperty.BeforeChange.Advise(lifetime, args =>
        {
            if (args.New < 0)
                args.Cancel = true;
        });

        _propertyProvider.SomeIntProperty.Change.Advise(lifetime, 
            val => MessageBox.ShowInfo($"New property value is {val}"));
    }


    public void ChangePropertyValue(int value)
    {
        _propertyProvider.SomeIntProperty.Value = value;
    }
}
```

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

### CssScopeProvider Example with Creators

Source: https://www.jetbrains.com/help/resharper/sdk/Scopes.html

Demonstrates how a derived scope provider like `CssScopeProvider` can initialize its `Creators` list. This allows for custom instantiation of scope points based on type names.

```csharp
public class CssScopeProvider : ScopeProvider
{
  public CssScopeProvider()
  {
    Creators.AddRange(new List<Func<string, ITemplateScopePoint>> 
    {
      s => TryToCreate<InCssFile>(s),
      s => TryToCreate<InCssExpression>(s),
      s => TryToCreate<InCssStatement>(s),
    });
  }

  // ...
}
```

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

### Generate Basic HTML Structure with Style

Source: https://www.jetbrains.com/help/resharper/sdk/HelperClasses.html

Use this method to create a basic HTML structure including the standard style template defined in XmlDocHtmlUtil.QUICK_DOC_HTML_STYLE. This is a foundational step for generating QuickDoc HTML.

```csharp
return "<html><head>\n" +
  "<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">
" +
  XmlDocHtmlUtil.QUICK_DOC_HTML_STYLE +
  "  </head><body>\n" +
  body +
  "</body></html>";
```

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

### Example ElementProblemAnalyzer Implementation

Source: https://www.jetbrains.com/help/resharper/sdk/Daemons.html

An example implementation of an `ElementProblemAnalyzer` that checks for the use of `Int64.MaxValue` literal. It highlights expressions that meet this condition using `UseOfInt64MaxValueLiteralHighlighting`.

```csharp
[ElementProblemAnalyzer(new[] { typeof(IExpression) },
  HighlightingTypes = new[] { typeof(UseOfInt64MaxValueLiteralHighlighting) })]
public class UseOfInt64MaxValueLiteralChecker : ElementProblemAnalyzer<IExpression>
{
  protected override void Run(IExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
  {
    var value = element.ConstantValue;
    if (!value.IsLong())
      return;

    long number = Convert.ToInt64(value.Value);
    if (number != Int64.MaxValue)
      return;

    consumer.AddHighlighting(new UseOfInt64MaxValueLiteralHighlighting(element),
      element.GetDocumentRange(), element.GetContainingFile());
  }
}
```

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

### C# Local Variable Usage Example

Source: https://www.jetbrains.com/help/resharper/sdk/Analysis_Testing.html

This is an example of C# code used as input for highlighting tests. The caret position is irrelevant for these tests.

```csharp
class C
{
  public void foo (bool cond)
  {
    int counter = 0;
    while(cond)
      counter++;
  }
}
```

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

### IXmlProcessingInstruction Interface Definition

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Represents an XML declaration, typically at the start of an XML file. Provides access to start and end tokens, the name identifier, and attributes.

```csharp
public interface IXmlProcessingInstruction :
  IXmlAttributeContainer,
  IXmlTreeNode,
  ITreeNode
{
  IXmlToken EndNode { get; }
  IXmlIdentifier Name { get; }
  IXmlToken StartNode { get; }
}
```

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

### Arrange Quick-Fixes with Severity

Source: https://www.jetbrains.com/help/resharper/sdk/QuickFixes.html

Demonstrates how to arrange quick-fixes by selecting pairs of bulb actions and their severities.

```csharp
menu.ArrangeQuickFixes(_items.Select(_ => Pair.Of(_, severity)));
```

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

### CSS Parser Test Example

Source: https://www.jetbrains.com/help/resharper/sdk/Parsing_Testing.html

Example of a CSS parser test class using ParserTestBase. It specifies the relative test data path and uses DoNamedTest for parsing.

```csharp
[TestFileExtension(CssProjectFileType.CSS_EXTENSION)]
public class CssParserTest : ParserTestBase<CssLanguage>
{
  protected override string RelativeTestDataPath { get { return @"parsing\css"; } }

  [Test] public void test01() { DoNamedTest(); }
  // ...[snip]...
}
```

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

### Chained Navigator Usage Example

Source: https://www.jetbrains.com/help/resharper/sdk/StronglyTypedNavigation.html

Demonstrates how to use navigator classes in combination to reach a specific node, such as navigating from an if statement to a class declaration by chaining navigators.

```csharp
public IClassDeclaration GetByIfStatement(IIfStatement ifStatement)
{
  var methodBody = BlockNavigator.GetByStatement(ifStatement);
  var methodDeclaration = MethodDeclaratioNavigator.GetByBody(methodBody);
  return ClassDeclarationNavigator.GetByMethodDeclaration(methodDeclaration);
}
```

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

### Setting and Getting Test Settings

Source: https://www.jetbrains.com/help/resharper/sdk/Plugins_Testing.html

Demonstrates how to define a setting with a value in test data and retrieve it using the GetSetting() method within a test.

```plaintext
${settingname:<value>}
```

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

### IXmlProcessingInstruction

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Represents an XML declaration, typically at the start of an XML file. Provides access to the start and end tokens, the name identifier, and attributes via derived interfaces.

```APIDOC
## Interface IXmlProcessingInstruction

### Description
Represents the XML declaration at the start of an XML file, usually of the form: `<?xml version="1.0" encoding="utf-8" ?>`. The `StartNode` and `EndNode` properties provide the `IXmlPistartTokenNode` and `IXmlPiendTokenNode` tokens. The `Name` property gets the `IXmlIdentifier` node that represents the `xml` in the declaration. Access to the attributes is available via the derived `IXmlAttributeContainer` interface members.

### Members
- `EndNode` (IXmlToken): Gets the processing instruction end token.
- `Name` (IXmlIdentifier): Gets the identifier node representing the name of the processing instruction.
- `StartNode` (IXmlToken): Gets the processing instruction start token.
```

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

### Get Selected Tree Node using IDataContext

Source: https://www.jetbrains.com/help/resharper/sdk/GetTreeNodeUnderCaret.html

Use this method when implementing context navigation to get the currently selected tree node. Requires an IDataContext object.

```csharp
// ...

public IEnumerable<ContextNavigation> CreateWorkflow(IDataContext dataContext)
{
    var node = dataContext.GetSelectedTreeNode<ITreeNode>();
    // ...
}
```

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

### Run ReSharper Plugin with Gradle on Windows

Source: https://www.jetbrains.com/help/resharper/sdk/running_plugin.html

Use this command to launch ReSharper in an experimental Visual Studio instance from the command-line on Windows.

```bash
.\gradlew.bat :runIde
```

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

### Subscribing to Solution Opened Event with Advise

Source: https://www.jetbrains.com/help/resharper/sdk/TrackSolutionLoadingStatus.html

Subscribes to the AfterSolutionOpened signal to execute a callback when a solution is opened. Ensure a valid lifetime is provided for the subscription.

```csharp
solutionStateTracker.AfterSolutionOpened.Advise(lifetime, () => {/*do somehting...*/});
```

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

### Emit and Listen to Signals (C#)

Source: https://www.jetbrains.com/help/resharper/sdk/WorkWithSignals.html

Demonstrates how to create a signal emitter and a listener. The emitter fires a signal with a boolean argument, and the listener subscribes using a lifetime to receive notifications. Ensure a Lifetime object is provided when creating signals and advising listeners.

```csharp
public class SignalEmitter
{
    public ISignal<bool> SomethingHappened { get; }

    public SignalEmitter(Lifetime lifetime)
    {
        SomethingHappened = new Signal<bool>(lifetime, "SignalEmitter.SomethingHappened");
    }

    public void MakeItHappen(bool arg)
    {
        SomethingHappened.Fire(arg);
    }

}


public class SignalListener
{
    public SignalListener(Lifetime lifetime, SignalEmitter signalEmitter)
    {
        signalEmitter.SomethingHappened.Advise(lifetime, arg => MessageBox.ShowInfo($"Something happened and it's {arg}"));
    }
}
```

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

### CSS Filtering Lexer Example

Source: https://www.jetbrains.com/help/resharper/sdk/FilteringLexers.html

This example demonstrates how to implement the `Skip` method for a CSS filtering lexer, specifically to filter out comment tokens. This allows the parser to ignore comments.

```csharp
public class CssFilteringLexerBase : FilteringLexer
{
  public CssFilteringLexerBase(ILexer lexer) : base(lexer)
  {
  }

  protected override bool Skip(TokenNodeType tokenType)
  {
    return tokenType.IsComment;
  }
}
```

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

### Example of Custom Angular Interpolation Syntax

Source: https://www.jetbrains.com/help/resharper/sdk/ExtendingHtml.html

This example shows a typical Angular interpolation expression within an HTML button element. It is used to illustrate the need for custom syntax support.

```html
<button disabled="{{isDisabled}}">{{disabledValue}}</button>
```

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

### IProjectFileExtensions Interface

Source: https://www.jetbrains.com/help/resharper/sdk/ProjectFileType.html

The IProjectFileExtensions interface provides methods to get the ProjectFileType from a file extension and to get all extensions associated with a ProjectFileType. It also exposes a signal that is raised when this mapping information changes.

```APIDOC
## Interface: IProjectFileExtensions

### Description
Provides functionality to map file extensions to project file types and retrieve associated extensions.

### Methods
#### GetFileType
- **Signature**: `ProjectFileType GetFileType(string extension)`
- **Description**: Retrieves the `ProjectFileType` for a given file extension (e.g., ".cs").

#### GetExtensions
- **Signature**: `IEnumerable<string> GetExtensions(ProjectFileType fileType)`
- **Description**: Retrieves a collection of all file extensions associated with a specific `ProjectFileType`.

### Properties
#### Changed
- **Signature**: `ISimpleSignal Changed { get; }`
- **Description**: A signal that is raised when the file extension mapping information changes.
```

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

### Reference Assemblies with Environment Variables

Source: https://www.jetbrains.com/help/resharper/sdk/ExternalAnnotations_Testing.html

Reference assemblies using paths that include environment variables. Override the `SetUp` method to programmatically set these environment variables before they are resolved.

```csharp
[TestReferences(@"%MY_ASSEMBLY_PATH%\myAssembly.dll")]
public class MyAssemblyAnnotationsTest : ExternalAnnotationsTestBase2
{
  public override void SetUp()
  {
    base.SetUp();

    Environment.SetEnvironmentVariable("MY_ASSEMBLY_PATH", BaseTestDataPath.Combine("lib"));
  }
}
```

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

### Track Solution Loading Status with C#

Source: https://www.jetbrains.com/help/resharper/sdk/TrackSolutionLoadingStatus.html

This C# code demonstrates how to implement a shell component that tracks solution opening and closing events using ReSharper's component model and signals. It requires the ReSharper SDK and relevant interfaces.

```csharp
[ShellComponent]
public class SolutionStateTracker : ISolutionStateTracker
{
    public ISolution Solution { get; private set; }
    public ISignal<ISolution> AfterSolutionOpened { get; }
    public ISignal<ISolution> BeforeSolutionClosed { get; }

    public SolutionStateTracker([NotNull] Lifetime lifetime)
    {
        AfterSolutionOpened = new Signal<ISolution>(lifetime, "SolutionStateTracker.AfterSolutionOpened");
        BeforeSolutionClosed = new Signal<ISignal<ISolution>>("SolutionStateTracker.BeforeSolutionClosed");
    }

    private void HandleSolutionOpened(ISolution solution)
    {
        Solution = solution;
        AfterSolutionOpened.Fire(solution);
    }

    private void HandleSolutionClosed()
    {
        if (Solution == null)
            return;

        BeforeSolutionClosed.Fire(Solution);
        Solution = null;
    }


    [SolutionComponent]
    private class SolutionStateNotifier
    {
        public SolutionStateNotifier([NotNull] Lifetime lifetime,
            [NotNull] ISolution solution,
            [NotNull] ISolutionLoadTasksScheduler scheduler,
            [NotNull] SolutionStateTracker solutionStateTracker)
        {
            if (lifetime == null)
                throw new ArgumentNullException("lifetime");
            if (solution == null)
                throw new ArgumentNullException("solution");
            if (scheduler == null)
                throw new ArgumentNullException("scheduler");
            if (solutionStateTracker == null)
                throw new ArgumentNullException("solutionStateTracker");

            scheduler.EnqueueTask(new SolutionLoadTask("SolutionStateTracker",
                SolutionLoadTaskKinds.Done, () => solutionStateTracker.HandleSolutionOpened(solution)));

            lifetime.AddAction(solutionStateTracker.HandleSolutionClosed);
        }
    }
}
```

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

### Walking Down the Tree (Children)

Source: https://www.jetbrains.com/help/resharper/sdk/ManualNavigation.html

Iterate through the immediate children of a node starting with FirstChild and then using NextSibling. For reverse order, start with LastChild and use PrevSibling. Avoid deep recursion for very nested trees.

```csharp
public void WalkChildren(ITreeNode root)
{
  var child = root.FirstChild;
  while(child != null)
  {
    // Process child node
    child = child.NextSibling;
  }
}
```

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

### Create ReSharper Test Environment

Source: https://www.jetbrains.com/help/resharper/sdk/TestEnvironment.html

Define a test zone and a setup fixture to create an in-memory ReSharper test environment. This class derives from `ExtensionTestEnvironmentAssembly` and is marked with `[SetUpFixture]`.

```csharp
namespace Foo.Tests
{
  // See Zones below
  [ZoneDefinition]
  public interface IMyTestZone : ITestsZone, IRequire<PsiFeatureTestZone>
  {
  }

  [SetUpFixture]
  public class TestEnvironment : ExtensionTestEnvironmentAssembly<IMyTestZone>
  {
  }
}
```

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

### XmlAttributeContainerExtensions

Source: https://www.jetbrains.com/help/resharper/sdk/Utils.html

Gets an attribute from an instance of `IXmlAttributeContainer`.

```APIDOC
## XmlAttributeContainerExtensions

Gets an attribute from an instance of `IXmlAttributeContainer` either of a specific derived type, or matching a predicate, or based on name (including namespace prefix, if specified).

### Methods

*   `GetAttribute<TAttribute>(this IXmlAttributeContainer container)`: Gets an attribute of a specific derived type.
*   `GetAttribute(this IXmlAttributeContainer container, this Predicate<IXmlAttribute> predicate)`: Gets an attribute matching a given predicate.
*   `GetAttribute(this IXmlAttributeContainer container, this string fullName)`: Gets an attribute by its full name (including namespace prefix, if specified).
```

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

### Run ReSharper Plugin with Gradle on macOS/Linux

Source: https://www.jetbrains.com/help/resharper/sdk/running_plugin.html

Use this command to launch ReSharper in an experimental Visual Studio instance from the command-line on macOS or Linux.

```bash
./gradlew :runIde
```

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

### IXmlPistartTokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the processing instruction start token '<?'.

```APIDOC
## Interface IXmlPistartTokenNode

### Description
Marker interface for the processing instruction start token `<?`.
```

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

### Using IProperty for Global Options

Source: https://www.jetbrains.com/help/resharper/sdk/WorkWithIProperty.html

Illustrates how IProperty can be used to synchronize UI elements with application settings. Changes to a setting are reflected in a text property, which can then be bound to a UI control. The `Advise_HasNew` method is used for efficient updates.

```csharp
Text = new Property<string>(lifetime, "OptionsExampleViewModel.Text");

var checkMeOption =
    settingsStore.BindToContextLive(lifetime, ContextRange.ApplicationWide)
        .GetValueProperty(lifetime, (MySettingsKey key) => key.CheckMe);

checkMeOption.Change.Advise_HasNew(lifetime, v =>
{
    Text.Value = v.New ? "checked" : "not checked";
});
```

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

### Navigate to Class Constructor Action (C#)

Source: https://www.jetbrains.com/help/resharper/sdk/AddYourNavigationActionToNavigateToMenu.html

Implement INavigateFromHereProvider and mark the class with ContextNavigationProvider attribute to add a custom navigation item to the 'Navigate To' menu. This example navigates to the constructor of the current class.

```csharp
[ContextNavigationProvider]
public class NavigateToCtorProvider : INavigateFromHereProvider
{
    public IEnumerable<ContextNavigation> CreateWorkflow(IDataContext dataContext)
    {
        var node = dataContext.GetSelectedTreeNode<ITreeNode>();
        var typeDeclaration = node?.GetParentOfType<IClassDeclaration>();
        var constructor = typeDeclaration?.ConstructorDeclarations.FirstNotNull();

        if (constructor != null)
        {
            yield return new ContextNavigation("Constructor", null, NavigationActionGroup.Other, () =>
            {
                constructor.NavigateToTreeNode(true);
            });
        }
    }
}
```

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

### IXmlCdataStartTokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the CDATA start token `<![CDATA[`.

```APIDOC
## Interface IXmlCdataStartTokenNode

### Description
Marker interface for the CDATA start token `<![CDATA[`.
```

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

### Basic build.gradle for Rider Plugin

Source: https://www.jetbrains.com/help/resharper/sdk/Rider.html

Sets up the `build.gradle` file to use and extend the `intellij` task from the `gradle-intellij-plugin` for Rider development.

```gradle
plugins {
    id 'java'
    id 'org.jetbrains.kotlin.jvm' version '1.2.50'
    id 'org.jetbrains.intellij' version '0.3.2'
}

version = version != 'unspecified' ? version : '0.0.0.1'
if (!project.hasProperty('configuration')) ext.configuration = 'Debug'

sourceCompatibility = 1.8
targetCompatibility = 1.8

compileKotlin {
    kotlinOptions { jvmTarget = "1.8" }
}

intellij {
    type = 'RD'
    // Download a version of Rider to compile and run with. Either set `version` to
    // 'LATEST-TRUNK-SNAPSHOT' or 'LATEST-EAP-SNAPSHOT' or a known version.
    // This will download from www.jetbrains.com/intellij-repository/snapshots or
    // www.jetbrains.com/intellij-repository/releases, respectively.
    version = "2018.2-SNAPSHOT"
    // Sources aren't available for Rider
    downloadSources = false
}

prepareSandbox {
    from("$projectDir/../$gradle.pluginName/bin/${gradle.pluginName}.RD/$configuration", {
        into "$intellij.pluginName/dotnet"
        include "$gradle.pluginName*"
    })
}
```

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

### Implement RangeOccurrencePresenter

Source: https://www.jetbrains.com/help/resharper/sdk/Navigation.html

Example implementation of an OccurrencePresenter that checks if an occurrence is a RangeOccurrence.

```csharp
[OccurrencePresenter(Priority=0.0)]
public class RangeOccurrencePresenter : IOccurrencePresenter
{
  public virtual bool IsApplicable(IOccurrence occurrence)
  {
    return occurrence is RangeOccurrence;
  }
  // other members omitted
}
```

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

### IXmlTagStartTokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the start token of an opening XML tag (`</`).

```APIDOC
## Interface IXmlTagStartTokenNode

### Description
Marker interface for the start token of an opening XML tag (`</`).

### See also
- IXmlToken
- IXmlTreeNode
```

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

### Build HTML with Dynamic Content and Navigation

Source: https://www.jetbrains.com/help/resharper/sdk/HelperClasses.html

Call XmlDocHtmlUtil.BuildHtml to generate complete HTML, including standard scripts for interactive elements. Pass a function to append the body content and specify the desired navigation style (e.g., 'Go to', 'Read more').

```csharp
BuildHtml(sb => sb.Append(body), NavigationStyle.All);
```

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

### IXmlTagStart1TokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the start token of a closing XML tag (`</`).

```APIDOC
## Interface IXmlTagStart1TokenNode

### Description
Marker interface for the start token of a closing XML tag (`</`).

### See also
- IXmlToken
- IXmlTreeNode
```

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

### Example Zone Activator Implementation

Source: https://www.jetbrains.com/help/resharper/sdk/Activation.html

Demonstrates a concrete implementation of a `[ZoneActivator]` class that activates multiple zones by implementing `IActivate<TZone>` for each. The `ActivatorEnabled` method returns true, unconditionally enabling all specified zones.

```csharp
[ZoneActivator]
class DotPeekZoneActivator :
  IActivate<DotPeekProductZone>,
  IActivate<ExternalSourcesZone>,
  IActivate<NavigationZone>,
  IActivate<DaemonZone>,
  IActivate<ILanguageCSharpZone>
{
  public bool ActivatorEnabled()
  {
    return true;
  }
}
```

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

### IXmlCommentStartTokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the XML comment start token `<!--`.

```APIDOC
## Interface IXmlCommentStartTokenNode

### Description
Marker interface for the XML comment start token `<!--`.
```

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

### IXmlAttlistStartTokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodesDTD.html

Represents the start token for an attribute list declaration in XML/DTD.

```APIDOC
## IXmlAttlistStartTokenNode

```csharp
public interface IXmlAttlistStartTokenNode :
  IXmlToken,
  IXmlTreeNode,
  ITokenNode,
  ITreeNode
{
}
```

* See also: IXmlToken, IXmlTreeNode
```

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

### Combinatorial Testing DSL: Simple Options

Source: https://www.jetbrains.com/help/resharper/sdk/OptionsIterator.html

Illustrates the basic usage of the JavaScript-like DSL for specifying options in combinatorial testing. This example sets specific values for `TagAttributesFormat` and `MaxSingleLineTagLength`.

```javascript
{
  TagAttributesFormat: OnSingleLine,
  MaxSingleLineTagLength: 10
}
```

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

### IXmlTagStartTokenNode Interface

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the start token of an opening XML tag (`</`).

```csharp
public interface IXmlTagStartTokenNode :
  IXmlToken,
  IXmlTreeNode,
  ITokenNode,
  ITreeNode
{
}
```

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

### Implement a Simple Action to Show a Message Box

Source: https://www.jetbrains.com/help/resharper/sdk/CreateMenuItemsUsingActions.html

Implement the `IExecutableAction` interface to create a custom action. The `Update` method determines if the menu item is enabled, and `Execute` performs the action's logic. Use the `Action` attribute to define the action's properties.

```csharp
public abstract class SampleAction : IExecutableAction
{
    public bool Update(IDataContext context, ActionPresentation presentation, DelegateUpdate nextUpdate)
    {
        return true;    // function result indicates whether the menu item is enabled or disabled
    }

    public void Execute(IDataContext context, DelegateExecute nextExecute)
    {
        RunAction(context, nextExecute);
    }

    protected abstract void RunAction(IDataContext context, DelegateExecute nextExecute);
}

[Action("ActionShowMessageBox", "Show message box", Id = 543210)]
public class ActionShowMessageBox : SampleAction, IInsertLast<MainMenuFeaturesGroup>
{
    protected override void RunAction(IDataContext context, DelegateExecute nextExecute)
    {
        var solution = context.GetData(JetBrains.ProjectModel.DataContext.ProjectModelDataConstants.SOLUTION);
        MessageBox.ShowInfo(solution?.SolutionFile != null
            ? $"{solution.SolutionFile?.Name} solution is opened"
            : "No solution is opened");
    }
}
```

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

### IXmlTagStart1TokenNode Interface

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the start token of a closing XML tag (`</`).

```csharp
public interface IXmlTagStart1TokenNode :
  IXmlToken,
  IXmlTreeNode,
  ITokenNode,
  ITreeNode
{
}
```

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

### Create Bulk Quick Fix for Caret Position

Source: https://www.jetbrains.com/help/resharper/sdk/Bulk.html

Instantiates a `BulkQuickFixInFileWithCommonPsiTransaction` for quick-fixes that operate at the caret position. Requires a project file, a display string, and the file processing action.

```csharp
var inFileFix = new BulkQuickFixInFileWithCommonPsiTransaction(projectFile, RemoveUnusedDirectivesString, processFileAction);
```

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

### IXmlPistartTokenNode Interface Definition

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the processing instruction start token '<?'.

```csharp
public interface IXmlPistartTokenNode :
  IXmlToken,
  IXmlTreeNode,
  ITokenNode,
  ITreeNode
{
}
```

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

### IXmlDtdStartTokenNode

Source: https://www.jetbrains.com/help/resharper/sdk/TreeNodes.html

Marker interface for the start token (`<!DOCTYPE`) of an inline DTD declaration.

```APIDOC
## Interface IXmlDtdStartTokenNode

### Description
Marker interface for the start token (`<!DOCTYPE`) of an inline DTD declaration.
```

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

### Generate HTML QuickDoc with XmlDocHtmlPresenter

Source: https://www.jetbrains.com/help/resharper/sdk/HelperClasses.html

Use the Run method of XmlDocHtmlPresenter to generate HTML QuickDoc content from an XML node. This method requires the XML node, an IPsiModule, an IDeclaredElement, a PsiLanguageType, navigation style preferences, and a delegate for processing code references.

```csharp
var html = XmlDocHtmlPresenter.Run(node, module, element, language, navigationStyle, processCRef);
```
Tokens:
Raw