Is root:

[*]

global options

indent-style:

space

tab

if(true) {
··return;
}

indent-size:

if(true) {
··return;
}

end-of-line:

crlf

if(true) {\n
··return;\n
}

trim-trailing-whitespace:

if(true) {
··return;
}

insert-final-newline:

if(true) {
··return;
}\n

max-line-length:

Newline created after
80 characters

file-header-template:

First line in file:

dotnet options

dotnet-code-quality-unused-parameters:

all

non-public

public void A(int a🗲) {
  return 1;
}
private void B(int b🗲) {
  return 1;
}

dotnet-style-coalesce-expression:

var value = obj ?? other;

dotnet-style-prefer-inferred-anonymous-type-member-names:

var obj = new {
  first,
  second
};

dotnet-style-prefer-is-null-check-over-reference-equality-method:

if (obj is null) { }

dotnet-style-qualification-for-property:

PropertyName = ...;

dotnet-style-parentheses-in-other-operators:

always-for-clarity

never-if-unnecessary

var value = (a.b).Length;

dotnet-style-prefer-conditional-expression-over-assignment:

var value = condition
  ? trueValue
  : falseValue;

dotnet-style-parentheses-in-other-binary-operators:

always-for-clarity

never-if-unnecessary

var value = a || (b && c);

dotnet-style-object-initializer:

var obj = new Object {
  Member = true,
};

dotnet-style-readonly-field:

private readonly int f = 0;

dotnet-sort-system-directives-first:

using System;
using A;
using B;

dotnet-style-explicit-tuple-names:

var tuple = (
  first: 1,
  second: 2
);
var first = tuple.first;

dotnet-style-collection-initializer:

List<int> list = [1, 2, 3];

dotnet-style-qualification-for-event:

Event += handler;

dotnet-style-prefer-inferred-tuple-names:

var tuple = (first, second);

dotnet-style-namespace-match-folder:

namespace Proj.Folder.Data
is in /Folder/Data

dotnet-style-prefer-collection-expression:

List<int> list = [1, 2, 3];

dotnet-style-require-accessibility-modifiers:

for-non-interface-members

always

never

omit-if-default

internal class Class() {
  public void Method() { }
}
public interface IFace {
  void Method();
}

dotnet-style-parentheses-in-arithmetic-binary-operators:

always-for-clarity

never-if-unnecessary

var value = a + (b * c);

dotnet-style-predefined-type-for-locals-parameters-members:

private int _member;

dotnet-style-parentheses-in-relational-binary-operators:

always-for-clarity

never-if-unnecessary

var v = (a > b) && (c > d);

dotnet-style-qualification-for-field:

fieldName = ...;

dotnet-style-prefer-simplified-interpolation:

var v = $"{val}";

dotnet-style-prefer-conditional-expression-over-return:

return condition
  ? trueValue
  : falseValue;

dotnet-style-prefer-simplified-boolean-expressions:

return condition;

dotnet-style-null-propagation:

var value = obj?.Member;

dotnet-remove-unnecessary-suppresion-exclusions:

all

none

public class A {
#pragma warning disable IDE0051
  public int a; //in use
#pragma warning restore IDE0051
}

dotnet-style-prefer-auto-properties:

public int Prop { get; set; }

dotnet-separate-import-directive-groups:

using System;
using A;
using B;

dotnet-style-predefined-type-for-member-access:

var value = int.MaxValue;

dotnet-style-prefer-compound-assignment:

a += b;

dotnet-style-qualification-for-method:

Method();

dotnet-style-prefer-foreach-explicit-cast-in-source:

always

when-strongly-typed

var list = new List<object>();
foreach (string item in list.Cast<string>()) { }

csharp options

csharp-space-between-square-brackets:

var x = new int[10];

csharp-style-prefer-local-over-anonymous-function:

Func<int, int> square = x =>  { return x * x; };

csharp-space-before-dot:

var x = y.Method();

csharp-style-var-elsewhere:

bool x = GetVal();

csharp-style-unused-value-expression-statement-preference:

discard-variable

unused-local-variable

_ = GetVal();

csharp-space-around-binary-operators:

before-and-after

none

ignore

var x = a + b;

csharp-style-prefer-readonly-struct:

readonly struct Point
{
  public int x;
}

csharp-style-prefer-tuple-swap:

(x, y) = (y, x);

csharp-style-inlined-variable-declaration:

int.TryParse(s, out int x);

csharp-new-line-before-catch:

try {
  x++;
}
catch(Exception e) {
  x--;
}

csharp-indent-block-contents:

if(true) {
  x++;
}

csharp-space-after-dot:

var x = y.Method();

csharp-style-expression-bodied-lambdas:

true

false

when-on-single-line

Func<int, int> square =
  x => x * x;

csharp-style-var-for-built-in-types:

int x = 0;

csharp-space-between-method-call-name-and-opening-parenthesis:

Method(x, y);

csharp-new-line-before-members-in-anonymous-types:

var x = new {
  A = 1,
  B = 2
};

csharp-space-between-method-declaration-name-and-open-parenthesis:

void Method(int x) {}

csharp-new-line-before-between-query-expression-clauses:

var query = from x in y
           where x > 0
           select x;

csharp-style-expression-bodied-indexers:

true

false

when-on-single-line

public int this[int index]
{
  get { return _values[index]; }
}

csharp-style-unused-value-assignment-preference:

discard-variable

unused-local-variable

_ = GetVal();

csharp-style-pattern-matching-over-as-with-null-check:

if (o is string s)
{
  return s;
}

csharp-space-after-colon-in-inheritance-clause:

class A : B {}

csharp-style-deconstructed-variable-declaration:

var (x, y) = GetPoint();

csharp-style-expression-bodied-accessors:

true

false

when-on-single-line

public string Name
{
  get { return _name; }
  set { _name = value; }
}

csharp-style-prefer-pattern-matching:

if(o is default(int)
   or > (default(int)))

csharp-style-prefer-utf8-string-literals:

var s = new byte[] { 65, 66 };

csharp-new-line-before-members-in-object-initializers:

var x = new Type {
  A = 1,
  B = 2
};

csharp-style-prefer-switch-expression:

var result = value switch
{
  1 => "one",
  2 => "two",
  _ => "unknown"
};

csharp-space-after-cast:

var x = (int) y;

csharp-indent-switch-labels:

switch(x) {
  case 1:
    x++;
    break;
}

csharp-space-between-parentheses:

csharp-new-line-before-finally:

try {
  x++;
}
finally {
  x--;
}

csharp-prefer-braces:

true

false

when-multiline

if (true) { x++; }

csharp-space-after-keywords-in-control-flow-statements:

if (true) {
  x++;
}

csharp-style-prefer-simple-default-expression:

csharp-style-prefer-not-pattern:

if(o is not C c)

csharp-style-prefer-method-group-conversion:

numberStrings
  .Select(int.Parse);

csharp-style-expression-bodied-constructors:

true

false

when-on-single-line

public Person(string name)
{
  Name = name;
}

csharp-prefer-static-local-function:

void Main()
{
  static void LocalFunc() { }
}

csharp-space-before-open-square-brackets:

var x = new int[10];

csharp-new-line-before-else:

if(cond) {
  x++;
}
else {
  x--;
}

csharp-style-expression-bodied-operators:

true

false

when-on-single-line

public static Person operator +(Person a, Person b)
{
  return new Person(a.Name + b.Name);
}

csharp-indent-case-contents:

switch(x) {
  case 1:
    x++;
    break;
}

csharp-style-prefer-null-check-over-type-check:

if (o is null)

csharp-style-throw-expression:

var x = y ?? throw new ArgumentNullException();

csharp-space-before-colon-in-inheritance-clause:

class A : B {}

csharp-style-namespace-declarations:

block-scoped

file-scoped

namespace MyNamespace
{
  class MyClass { }
}

csharp-space-between-method-call-empty-parameter-list-parentheses:

Method();

csharp-style-prefer-readonly-struct-member:

struct Point
{
  public readonly int x;
}

csharp-style-prefer-range-operator:

var x = list[1..3];

csharp-style-implicit-object-creation-when-type-is-apparent:

List<int> x = new();

csharp-using-directive-placement:

inside-namespace

outside-namespace

using System;

namespace MyNamespace
{

csharp-style-prefer-index-operator:

var x = list[0];

csharp-style-pattern-matching-over-is-with-cast-check:

if (o is string s)
{
  return s;
}

csharp-style-prefer-top-level-statements:

Console.WriteLine("Hello");

csharp-space-after-comma:

var list = [1, 2, 3];

csharp-preserve-single-line-statements:

var i = 0; var name = "Test";

csharp-indent-case-contents-when-block:

switch(x) {
  case 1:
    {
      x++;
      break;
    }
}

csharp-style-prefer-extended-property-pattern:

line is
  { Start.Y: 0 }
  or { End.Y: 0 };

csharp-space-after-semicolon-in-for-statement:

for (int i = 0; i < 10; i++) {}

csharp-style-condition-delegate-call:

condition?.Invoke();

csharp-space-between-method-call-parameter-list-parentheses:

Method(x, y);

csharp-preserve-single-line-blocks:

public int X { get; set; }

csharp-space-before-comma:

var list = [1, 2, 3];

csharp-indent-labels:

flush-left

one-less-than-current

no-change

{
  if(cond)
  {
    goto error;
  error:
    log.Error();
  }
}

csharp-style-expression-bodied-methods:

true

false

when-on-single-line

public string GetName()
{
  return Name;
}

csharp-preferred-modifier-order:

csharp-space-between-empty-square-brackets:

var x = new int[] {};

csharp-style-var-when-type-is-apparent:

List<int> x = new List<int>();

csharp-space-between-method-declaration-empty-parameter-list-parentheses:

void Method() {}

csharp-style-prefer-primary-constructors:

class Person(string name) { }

csharp-indent-braces:

if(true)
{
  x++;
}

csharp-space-before-semicolon-in-for-statement:

for (int i = 0; i < 10; i++) {}

csharp-space-around-declaration-statements:

ignore

false

int x = 1;

csharp-new-line-before-open-brace:

csharp-space-between-method-declaration-parameter-list-parentheses:

void Method(int x) {}

csharp-style-expression-bodied-properties:

true

false

when-on-single-line

public string Name
{
  get { return _name; }
}

csharp-prefer-simple-using-statement:

using var stream =
  new FileStream(
    "file.txt",
    FileMode.Open);

csharp-style-expression-bodied-local-functions:

true

false

when-on-single-line

int Square(int x)
{
  return x * x;
}

visual-basic options

visual-basic-preferred-modifier-order:

visual-basic-style-unused-variable-expression-statement-preference:

unused-local-variable

visual-basic-style-unused-value-assignment-preference:

unused-local-variable

visual-basic-style-prefer-isnot-expression:

visual-basic-style-prefer-simplified-object-creation:

Editorconfig Guide

Generate your .editorconfig file with ease.

[*]

global options

dotnet options

csharp options

visual-basic options