SonarLint is a free IDE extension that lets you fix coding issues before they exist! Like a spell checker, SonarLint highlights Bugs and Security Vulnerabilities as you write code, with clear remediation guidance so you can fix them before the code is even committed. SonarLint in VS Code supports analysis of C, C++, HTML, Java, JavaScript, PHP, Python and TypeScript, and you can install it directly from the VS Code Marketplace!
{
"version": "0.1.0",
// The command is tsc. Assumes that tsc has been installed using npm install -g typescript
"command": "tsc",
// The command is a shell script
"isShellCommand": true,
// Show the output window only if unrecognized errors occur.
"showOutput": "silent",
// args is the HelloWorld program to compile.
"args": ["HelloWorld.ts"],
// use the standard tsc problem matcher to find compile problems
// in the output.
"problemMatcher": "$tsc"
} "args": [
"--target", "ES5",
"--outdir", "js",
"--sourceMap",
"--watch",
"test.ts"
], 
error TS5023: Unknown option 'watch' Use the '--help' flag to see options.
15:33:52 - Compilation complete. Watching for file changes.
public class Student
{
public string FirstName;
public string LastName;
public int TotalPointsEarned;
public void TakeExam(int pointsForExam)
{
TotalPointsEarned += pointsForExam;
}
public void ExtraCredit(int extraPoints)
{
TotalPointsEarned += extraPoints;
}
public int PointsEarned { get { return TotalPointsEarned; } }
} 
using System.Collections.Immutable;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.Diagnostics;
namespace CodingStandards
{
[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class CodingStandardsAnalyzer : DiagnosticAnalyzer
{
public const string DiagnosticId = "CodingStandards";
// You can change these strings in the Resources.resx file. If you do not want your analyzer to be localize-able, you can use regular strings for Title and MessageFormat.
internal static readonly LocalizableString Title = new LocalizableResourceString(nameof(Resources.AnalyzerTitle), Resources.ResourceManager, typeof(Resources));
internal static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(Resources.AnalyzerMessageFormat), Resources.ResourceManager, typeof(Resources));
internal static readonly LocalizableString Description = new LocalizableResourceString(nameof(Resources.AnalyzerDescription), Resources.ResourceManager, typeof(Resources));
internal const string Category = "Naming";
internal static DiagnosticDescriptor Rule =
new DiagnosticDescriptor(
DiagnosticId,
Title,
MessageFormat,
Category,
DiagnosticSeverity.Error,
isEnabledByDefault: true,
description: Description);
public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
{
get { return ImmutableArray.Create(Rule); }
}
public override void Initialize(AnalysisContext context)
{
// TODO: Consider registering other actions that act on syntax instead of or in addition to symbols
context.RegisterSyntaxNodeAction(analyzeFieldDeclaration, SyntaxKind.FieldDeclaration);
}
static void analyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
{
var fieldDeclaration = context.Node as FieldDeclarationSyntax;
if (fieldDeclaration == null) return;
var accessToken = fieldDeclaration
.ChildTokens()
.SingleOrDefault(token => token.Kind() == SyntaxKind.PublicKeyword);
// Note: Not finding protected or internal
if (accessToken.Kind() != SyntaxKind.None)
{
// Find the name of the field:
var name = fieldDeclaration.DescendantTokens()
.SingleOrDefault(token => token.IsKind(SyntaxKind.IdentifierToken)).Value;
var diagnostic = Diagnostic.Create(Rule, fieldDeclaration.GetLocation(), name, accessToken.Value);
context.ReportDiagnostic(diagnostic);
}
}
}
} 
using System.Collections.Immutable;
using System.Composition;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
namespace CodingStandards
{
[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(CodingStandardsCodeFixProvider)), Shared]
public class CodingStandardsCodeFixProvider : CodeFixProvider
{
public sealed override ImmutableArray<string> FixableDiagnosticIds
{
get { return ImmutableArray.Create(CodingStandardsAnalyzer.DiagnosticId); }
}
public sealed override FixAllProvider GetFixAllProvider()
{
return WellKnownFixAllProviders.BatchFixer;
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
// TODO: Replace the following code with your own analysis, generating a CodeAction for each fix to suggest
var diagnostic = context.Diagnostics.First();
var diagnosticSpan = diagnostic.Location.SourceSpan;
// Find the type declaration identified by the diagnostic.
var declaration = root.FindToken(diagnosticSpan.Start)
.Parent.AncestorsAndSelf().OfType<FieldDeclarationSyntax>()
.First();
// Register a code action that will invoke the fix.
context.RegisterCodeFix(
CodeAction.Create("Make Private",
c => makePrivateDeclarationAsync(context.Document, declaration, c)),
diagnostic);
}
async Task<Document> makePrivateDeclarationAsync(Document document, FieldDeclarationSyntax declaration, CancellationToken c)
{
var accessToken = declaration.ChildTokens()
.SingleOrDefault(token => token.Kind() == SyntaxKind.PublicKeyword);
var privateAccessToken = SyntaxFactory.Token(SyntaxKind.PrivateKeyword);
var root = await document.GetSyntaxRootAsync(c);
var newRoot = root.ReplaceToken(accessToken, privateAccessToken);
return document.WithSyntaxRoot(newRoot);
}
}
} 
Jint is a Javascript interpreter for .NET which can run on any modern .NET platform as it supports .NET Standard 2.0 and .NET 4.6.1 targets (and up). Because Jint neither generates any .NET bytecode nor uses the DLR it runs relatively small scripts really fast.
It’s time that we have an deep dive series for ASP.NET Core Identity that learn to use how ASP.NET Core Identity works and how we can use its powerful feature to have an authentication and authorization system.
This is a set of NuGet packages that makes your Blazor apps display the source .razor file name that generated the HTML element under the mouse cursor when entering the Ctrl + Shift + F hotkeys.
Speed up your builds of SDK-style .NET projects
Drew shows how you can dramatically reduce build times for SDK-style .NET projects.
The next major release of the popular data structure server is here. Redis is at the heart of so many data systems nowadays that any major release is big news but 6.0 packs in a lot of new bits and pieces that make it more robust and capable of modern workloads, including:
- Access Control Lists (ACL) for limiting what certain clients can do.
- Diskless replication on replicas.
- Threaded I/O (but Redis itself remains primarily single threaded).
- SSL/TLS support.
- A new client-server protocol, RESP3.
WebApiConfig.Register(GlobalConfiguration.Configuration);
