The first analysis run on a solution does not block Visual Studio and the progress bar is displayed. Every consecutive analysis run fully blocks Visual Studio until the analysis is finished. The progress bar is not displayed either.

This issue is originally reported by Robert Kurtanjek during the Endgame for v0.5.0.

C# Suggestion definition

Description

The suggestion suggests to use var keyword only if the variable is initialized with object creation (new keyword). In other words, suggestion suggests to use var keyword only if the type is directly obvious from the declaration itself.

Usage Examples

• int i = new System.Int32();

• List<int> list = new List<int>(10000);

• List<int> list = new System.Collections.Generic.List<int>(10000);

• System.Collections.Generic.List<int> list = new List<int>(10000);

• MyClass myObject = new MyClass(a, b, c);

• MyClass myObject = new MyClass { A = a, B = b, C = c};

• using (StreamReader file = new StreamReader("C:\\myfile.txt")) {...}

Non-usage Examples

When the explicit type and the type in the object creation is not exactly the same the suggestion should not appear.

• IEnumerable<int> list = new List<int>(10000);

• long l = new int();

Corner Cases

A type named var in the scope

If there is a type named var in the scope, the suggestion should not appear. Because "If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration."
For more info see: http://thehumbleprogrammer.com/the-variform-var/
This corner case can be ignored in the first implementation since it is very unlikely to happen.

Multiple implicitly-typed variables cannot be initialized in the same statement

E. g. this is valid:

int a = 1, b = 2, c = 3;

but this is not:

var a = 1, b = 2, c = 3;

This corner case must be supported in the first implementation. This means the suggestion must not appear in a case like this:

• List<int> first = new List<int>(), second = new List<int>();

References

• Implicitly Typed Local Variables (C# Programming Guide)
• The Variform Var

Acceptance Criteria

• Smoke tests are written and passing for all:
  • Usage Examples
  • Non-usage Examples
  • Corner Cases

• Expanding items in the item list causes lagging.It takes some time to expand in some cases.The number of items were more than some close or more than 1000s (Eg: 6377,13092,857 etc..) .
• Few times white screen is seen for a while on repeated clicking.
  Once it opens up,the behaviour is fine

As a .NET developer I would love to use this extension in VS4Mac and VS Code.

Alternatively, some kind of cross-platform CLI interface could be useful.

Hi I tried installing into VS2019 but was giving me a dependency alert: Visual Studio MPF 15.0, this is despite the fact I already have Visual Studio MPF 16.0 which I checked in the C:\Program Files (x86)\Microsoft Visual Studio\2019\Preview\Common7\IDE\CommonExtensions\Platform\Visual Studio MPF directory.

Is there reason why it wont accept v16.0? Is it hard coded to use v15.0?

Need to update Sharpen.VisualStudioExtension.csproj to use relative paths of the packages folder in the project.

As of now, the entry for \packages\Microsoft.VisualStudio.Threading.Analyzers.15.7.18 refers to C:\p\Sharpen we need to change this to ../packages/

"On my machine" double clicking an item goes to the referenced line in the code and makes selected text in Sharpen Results window unreadable. I haven't modified any display settings in Visual Studio.

Suggestion: verify that the contrast between background and text is sufficient and tweak accordingly.

The About Dialog should roughly look like this:

The dialog cannot change its window size. Pick up a size that is not too small and not too big and can fit on a 14" laptop screen ;-)

About Tab

If there is an internet connection fetch the data from GitHub and VS Marketplace and display them. If not or if any error happens during fetching do not display anything.

This might be useful:

• https://developer.github.com/v4/

Version History Tab

The Version History tab lists the versions on one side and when a version is selected the details for that version are displayed on the left:

To render the details use WPF Documents.

The whole content of the Version History tab should be generated on the fly based on the content of the Changelog file.

This might be useful:

• https://docs.microsoft.com/en-us/windows/communitytoolkit/controls/markdowntextblock
• https://docs.microsoft.com/en-us/windows/communitytoolkit/parsers/markdownparser

While developing About dialog i came to the following issue:

I didn't pay much attention to Target framework when starting on the project and came to an interesting issue. Process.Start(url) in .Net Core 3.0 doesn't work (by design, it seems https://github.com/dotnet/corefx/issues/33714)

Process.Start(url) is used in Sharpen tool when opening links using CTRL key modifier.

Currently, this is not a bug but it could be overlooked if project's target framework changes.

The command/menu item will appear in its own commad group/menu item group.

Sharpen should appear only under the version 2017. Both in the search and on the Sharpen page it is listed under 2017 and 2019 which is wrong.

This is great extension, much easier to use than laggy ReSharper! Will there be support for Visual Studio 2022 and C# 10 features?

E.g. if the project sets the C# language version to 5.0 in its settings, the suggestions for e.g. version 7.0 will also be provided in the Sharpen Results window. We need a mechanism to provide visual information to users that the particular suggestion cannot be applied because the project settings use a lower version of the compiler.

We need a more detailed UX/UI concept how to do this.

Currently, when user hoovers over C# language version, "What is new in C# X.Y?" tip displays to the right of it. It would be an improvement if the tip would be displayed (as well) when hovering over tip displaying location.

The same is true for suggestions and "Learn more..." tip.

It would be nice to be able to ignore classes and/or methods marked with the CompilerGenerated attribute, since this code cannot be improved, without it being regenerated with the previous syntax.

The color used to be black with white text on the Dark VS Theme. It is gray now and the text is not visible:

It looks like this happened when we switched to tree view instead of list view.
Analyse the changes between 2f4fddd and 9b63ac2.

The command/menu item will appear in its own commad group/menu item group.

Hi there, have started using this with Visual Studio 2017, regarding the apply solution found here on your wiki page:

https://raw.githubusercontent.com/ironcev/sharpen/master/images/code-refactoring-on-arbitrary-scale.png

When I mouse over to try to get the ability to "apply suggestions" I cant get that option dropdown? How can I apply all rather then individually?

See if there is already an abstraction for it in the Roslyn or VS API.

File on the Microsoft VS Store doesn't include VSIX file and the packaged extension you can get in VS is not signed.

Steps to reproduce:

• Run an analysis that produces results in several C# versions.
• Move through the results and collapse and expand the nodes using the keyboard keys (up, down, left, ...).

The moving sometimes works and sometimes not. It appears like the down movement simple gets stuck.

Hey man, great extension.
Do you have any plans to update it to C# 9?

The command/menu item will appear in its own commad group/menu item group.

Users can select one or more files.

The command/menu item will appear in its own commad group/menu item group.

I'm seeing a lot of C# 8 Nullable Reference Type issues.

Issue 1

These issues remind me to turn on nullable context, which is already enabled project wide in the csproj.

Issue 2

See Example 1 for a constructor issue, declaring a property as nullable in an API indicates you intend for the consumer to pass nulls. In this case we don't (and throw exceptions).

Issue 3

See example 2, There's no way to declare a var as nullable and the target of the foreach is non-null.

Issue 4

See example 3, There's no way to declare a var as nullable.

Code snippets are from OAT which triggers many of the same types of issues: https://github.com/microsoft/OAT

For context, I do have nullable reference types enabled project wide.

Example 1

This code triggers "Enable Nullable Context and declare constructor parameters as nullable. I explicitly don't want nulls passed in, but am already handling nulls. Setting these parameters to be nullable would indicate to consumers that they may expect reasonable behavior if they pass in nulls. This is explicitly an API you may not pass nulls to.

public Violation(string description, Rule rule, Clause[] clauses)
{
    this.description = description ?? throw new ArgumentNullException(nameof(description), $"{nameof(description)} may not be null");
    this.rule = rule ?? throw new ArgumentNullException(nameof(rule), $"{nameof(rule)} may not be null");
    this.clauses = clauses ?? throw new ArgumentNullException(nameof(clauses), $"{nameof(clauses)} may not be null");
}

Example 2

This is a false positive. The target is both not null and there's no way to declare a "var" as nullable.

Example 3

This is another false positive. There's no way to declare a var as nullable. It's fine that this is may be null here.

public bool Applies(Rule rule, object? state1 = null, object? state2 = null)
{
    if (rule != null)
    {
        var sample = state1 is null ? state2 : state1;

Acceptance Criteria

• Create icon (#).
• Add icon to Sharpen's menu on the Tools menu.
• Add icon to Sharpen Results window:
  • Visible on View -> Other Windows -> Sharpen Results.
  • Visible when switching open documents and windows with Ctrl + Tab.
• It could be that the icon will be visible on Tools -> Sharpen -> Sharpen Results. This we don't want.

Resources

• https://docs.microsoft.com/de-de/visualstudio/extensibility/extensibility-in-visual-studio
• https://msdn.microsoft.com/en-us/library/xc52cke4(v=vs.110).aspx
• https://github.com/Microsoft/VSSDK-Extensibility-Samples
• https://www.visualstudio.com/vs/extend/
• http://www.visualstudioextensibility.com/overview/vs/
• https://blogs.msdn.microsoft.com/codefx/2010/11/26/all-in-one-visual-studio-extensibility-code-samples/
• https://madskristensen.net/
• https://channel9.msdn.com/events/Build/2018/THR2002?term=Visual%20Studio%20extensibility

The issue is explained in detail in: https://github.com/sharpenrocks/Sharpen/tree/master/lab/RoslynDependenciesAtBuildAndRuntime

Here is a short summary:

• At compile-time we compile Sharpen Engine with a certain version of Roslyn. At the moment, this is a very old v2.4.0.0.
  This way we do not have access to the new Roslyn API like e.g. IOperation but we assume that most of the analyzers can be comfortably written using this old Roslyn version.
• At runtime, VS will bind Sharpen Engine to the version of Roslyn coming with that particular instance of VS. This can be anything between v2.4.0.0 and the newest version of Roslyn.
• Here we face two issues:
  • If there are breaking changes in the API between the v2.4.0.0 and the actual runtime version, Sharpen will crash.
  • If the newer version supports some language constructs required for the proper analysis, we cannot use them.
    E.g. , IsNullableContextEnabled(...) method can simply return false in VS2017 but must do some actual work in VS2019. This is the reason for the issue #38.

So, we want to achieve the following:

• Have just a single VSIX that supports VS2017+ and different versions of Roslyn.
• Be able to develop the analyzers by using the newer language feature when available at runtime, and using the appropriate fallbacks when they are not available. E.g. IsNullableContextEnabled(...) method has different implementations for Roslyn version older than v3.0.0.0 (C# 8.0) and newer or equal then v3.0.0.0.

Proposed solution and its alterantives are described in detail here: https://github.com/sharpenrocks/Sharpen/tree/master/lab/RoslynDependenciesAtBuildAndRuntime

Here is the summary of the proposed solution:

• Create an abstract interface of the Sharpen.Engine. Put it in the Sharpen.Engine.Abstractions and compile against v2.4.0.0 of Roslyn. This interface will require only the very basic Roslyn types like SyntaxTree and Workspace.
• Create a shared project called Sharpen.Engine. Put all the common code here. Implement the Sharpen.Engine.Abstractions here.
• Create separate project for each supported version of Roslyn, reference the shared Sharpen Engine project, and compile it against the specific version of Roslyn. Add Roslyn version-specific code to those projects.
• In the VS Extension, link to Engine DLLs produced by each of the projects and copy them to the VSIX as files.
• In the VS Extension, load the closest of those DLLs at runtime based on the exact Roslyn version used at runtime.

The proof-of-concept of the approach can be seen here: https://github.com/sharpenrocks/Sharpen/tree/master/lab/RoslynDependenciesAtBuildAndRuntime/solution-04

Questions:

• Is this the final way to go?
• Are there any better alternatives?