Actions rapides courantes

Les sections de cette rubrique répertorient certaines des actions rapides courantes applicables au code C# et Visual Basic. Ces actions sont des correctifs de code pour les diagnostics du compilateur ou les analyseurs intégrés de la plateforme du compilateur .NET dans Visual Studio.

Actions qui corrigent les erreurs

Les actions rapides de cette section corrigent les erreurs dans le code qui entraîneraient l’échec d’une build. Lorsque les actions rapides sont disponibles pour corriger une erreur sur une ligne de code, l’icône affichée dans la marge ou sous le bouton rouge est une ampoule avec un rouge « x » sur celle-ci.

Symbole ou mot clé mal orthographié correct

Si vous avez accidentellement mal orthographié un type ou un mot clé dans Visual Studio, cette action rapide la corrige automatiquement pour vous. Vous verrez ces éléments dans le menu ampoule sous la forme « Remplacer le< mot> mal orthographié » par «< mot> correct ». Par exemple:

C#

// Before
private viod MyMethod()
{
}

// Change 'viod' to 'void'

// After
private void MyMethod()
{
}

VB

' Before
Function MyFunction as Intger
End Function

' Change 'Intger' to 'Integer'

' After
Function MyFunction as Integer
End Function

ID d'erreur	Langues applicables
CS0103, BC30002	C# et Visual Basic

Résoudre le conflit de fusion Git

Ces actions rapides vous permettent de résoudre les conflits de fusion Git en « prenant une modification », ce qui supprime le code et les marqueurs en conflit.

// Before
private void MyMethod()
{
    if (false)
    {

    }
}

// Take changes from 'HEAD'

// After
private void MyMethod()
{
    if (true)
    {

    }
}

ID d'erreur	Langues applicables	Version prise en charge
CS8300, BC37284	C# et Visual Basic	Visual Studio 2017 version 15.3 et ultérieure

Actions qui suppriment le code inutile

Supprimer les utilisations inutiles/importations

L’action rapide Supprimer les utilisations inutiles/Importations supprime toutes les directives inutilisées using pour Import le fichier actif. Lorsque vous sélectionnez cet élément, les importations d’espaces de noms inutilisées sont supprimées.

Supprimer le cast inutile

Si vous convertissez un type en un autre type qui ne nécessite pas de cast, l’élément Supprimer un cast rapide de cast inutile supprime le cast inutile.

C#

// before
int number = (int)3;

// Remove Unnecessary Cast

// after
int number = 3;

VB

' Before
Dim number as Integer = CType(3, Integer)

' Remove Unnecessary Cast

' After
Dim number as Integer = 3

Supprimer les variables inutilisées

Cette action rapide vous permet de supprimer des variables qui ont été déclarées mais qui n’ont jamais été utilisées dans votre code.

// Before
public MyMethod()
{
    var unused = 8;
    var used = 1;
    return DoStuff(used);
}

// Remove unused variables

// After
public MyMethod()
{
    var used = 1;
    return DoStuff(used);
}

Identifiant de diagnostic	Langues applicables	Version prise en charge
CS0219, BC42024	C# et Visual Basic	Visual Studio 2017 version 15.3 et ultérieure

Supprimer le type de l’expression de valeur par défaut

Cette action rapide supprime le type valeur d’une expression de valeur par défaut et utilise le littéral par défaut lorsque le compilateur peut déduire le type de l’expression.

// Before
void DoWork(CancellationToken cancellationToken = default(CancellationToken)) { ... }

// Simplify default expression

// After
void DoWork(CancellationToken cancellationToken = default) { ... }

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0034	C# 7.1+	Visual Studio 2017 version 15.3 et ultérieure

Actions qui ajoutent du code manquant

Ajouter des utilisations/importations pour les types dans les assemblys de référence, les packages NuGet ou d’autres types dans votre solution

L’utilisation de types situés dans d’autres projets de votre solution affiche automatiquement l’action rapide, mais les autres doivent être activés à partir de l’onglet > Outils Options > Éditeur > de texte C# ou Visual Basic > Avancé :

• Suggérer des utilisations/importations pour les types dans les assemblys de référence
• Suggérer des utilisations/importations pour les types dans les packages NuGet

Lorsque cette option est activée, si vous utilisez un type dans un espace de noms qui n’est actuellement pas importé, mais qui existe dans un assembly de référence ou un package NuGet, la directive using ou import est créée.

C#

// Before
Debug.WriteLine("Hello");

// using System.Diagnostics;

// After
using System.Diagnostics;

Debug.WriteLine("Hello");

VB

' Before
Debug.WriteLine("Hello")

' Imports System.Diagnostics

' After
Imports System.Diagnostics

Debug.WriteLine("Hello")

Identifiant de diagnostic	Langues applicables
CS0103, BC30451	C# et Visual Basic

Ajouter des cas manquants/cas par défaut/les deux

Lorsque vous créez une switch instruction en C#, ou Select Case une instruction en Visual Basic, vous pouvez utiliser une action de code pour ajouter automatiquement des éléments de cas manquants, une instruction case par défaut ou les deux.

Considérez l’énumération et l’instruction vides switch suivantes Select Case :

C#

enum MyEnum
{
    Item1,
    Item2,
    Item3
}

...

MyEnum myEnum = MyEnum.Item1;

switch(myEnum)
{
}

VB

Enum MyEnum
    Item1
    Item2
    Item3
End Enum

...

Dim myEnum as MyEnum = MyEnum.Item1

Select Case myEnum
End Select

L’utilisation de l’action rapide Ajouter les deux remplit les cas manquants et ajoute un cas par défaut :

C#

switch(myEnum)
{
    case MyEnum.Item1:
        break;
    case MyEnum.Item2:
        break;
    case MyEnum.Item3:
        break;
    default:
        break;
}

VB

Select Case myEnum
    Case MyEnum.Item1
        Exit Select
    Case MyEnum.Item2
        Exit Select
    Case Else
        Exit Select
End Select

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0010	C# et Visual Basic	Visual Studio 2017 version 15.3 et ultérieure

Ajouter des vérifications Null pour les paramètres

Cette action rapide vous permet d’ajouter une vérification dans votre code pour indiquer si un paramètre a la valeur Null.

// Before
class MyClass
{
    public string MyProperty { get; set; }

    public MyClass(string myProperty) // cursor inside myProperty
    {
        MyProperty = myProperty;
    }
}

// Add null check

// After
class MyClass
{
    public string MyProperty { get; set; }

    public MyClass(string myProperty)
    {
        MyProperty = myProperty ?? throw new ArgumentNullException(nameof(myProperty));
    }
}

Langues applicables	Version prise en charge
C# et Visual Basic	Visual Studio 2017 version 15.3 et ultérieure

Ajouter un nom d’argument

// Before
var date = new DateTime(1997, 7, 8);

// Include argument name 'year' (include trailing arguments)

// After
var date = new DateTime(year: 1997, month: 7, day: 8);

Langues applicables	Version prise en charge
C# et Visual Basic	Visual Studio 2017 version 15.3 et ultérieure

Ajouter des accolades

L’action rapide Ajouter des accolades encapsule les accolades autour des instructions monolignes if .

// Before
if (true)
    return "hello,world";

// Add braces

// After
if (true)
{
    return "hello,world";
}

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0011	C#	Visual Studio 2017 et versions ultérieures

Ajouter et commander des modificateurs

Ces actions rapides vous permettent d’organiser les modificateurs en vous permettant de trier les modificateurs d’accessibilité existants et d’ajouter des modificateurs d’accessibilité manquants.

// Before
enum Color
{
    Red, White, Blue
}

// Add accessibility modifiers

// After
internal enum Color
{
    Red, White, Blue
}

// Before
static private int thisFieldIsPublic;

// Order modifiers

// After
private static int thisFieldIsPublic;

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0036	C# et Visual Basic	Visual Studio 2017 version 15.5 et ultérieure
IDE0040	C# et Visual Basic	Visual Studio 2017 version 15.5 et ultérieure

Transformations de code

Convertir la construction 'if' en 'switch'

Cette action rapide vous permet de convertir une construction if-then-else en construction switch .

C#

// Before
if (obj is string s)
{
  Console.WriteLine("obj is a string: " + s);
}

else if (obj is int i && i > 10)
{
  Console.WriteLine("obj is an int greater than 10");
}

// Convert to switch

// After
switch (obj)
{
  case string s:
    Console.WriteLine("Obj is a string: " + s);
    break;
  case int i when i > 10:
    Console.WriteLine("obj is an int greater than 10");
    break;
}

VB

' Before
If TypeOf obj Is String s Then
    Console.WriteLine("obj is a string: " + s)
Else If TypeOf obj Is Integer i And i > 10 Then
    Console.WriteLine("obj is an int greater than 10")
End If

' Convert to switch

' After
Select Case obj
  Case String s
    Console.WriteLine("Obj is a string: " + s)
    Exit Sub
  Case Integer i when i > 10
    Console.WriteLine("obj is an int greater than 10")
    Exit Sub
End Select

Langues applicables	Version prise en charge
C# et Visual Basic	Visual Studio 2017 version 15.3 et ultérieure

Convertir en chaîne interpolée

Les chaînes interpolées sont un moyen simple d’exprimer des chaînes avec des variables incorporées, comme la méthode String.Format . Cette action rapide reconnaît les cas où les chaînes sont concaténées ou à l’aide de String.Format et modifient l’utilisation en chaîne interpolée.

C#

// Before
int num = 3;
string s = string.Format("My string with {0} in the middle", num);

// Convert to interpolated string

// After
int num = 3;
string s = $"My string with {num} in the middle";

VB

' Before
Dim num as Integer = 3
Dim s as String = String.Format("My string with {0} in the middle", num)

' Convert to interpolated string

' After
Dim num as Integer = 3
Dim s As String = $"My string with {num} in the middle"

Langues applicables	Version prise en charge
C# 6.0+ et Visual Basic 14+	Visual Studio 2017 et versions ultérieures

Utiliser des initialiseurs d’objets

Cette action rapide vous permet d’utiliser des initialiseurs d’objets plutôt que d’appeler le constructeur et d’avoir des lignes supplémentaires d’instructions d’affectation.

C#

// Before
var c = new Customer();
c.Age = 21;

// Object initialization can be simplified

// After
var c = new Customer() { Age = 21 };

VB

' Before
Dim c = New Customer()
c.Age = 21

' Object initialization can be simplified

' After
Dim c = New Customer() With {.Age = 21}

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0017	C# et Visual Basic	Visual Studio 2017 et versions ultérieures

Utiliser des initialiseurs de collections

Cette action rapide vous permet d’utiliser des initialiseurs de collection plutôt que plusieurs appels à la Add méthode de votre classe.

C#

// Before
var list = new List<int>();
list.Add(1);
list.Add(2);
list.Add(3);

// Collection initialization can be simplified

// After
var list = new List<int> { 1, 2, 3 };

VB

' Before
Dim list = New List(Of Integer)
list.Add(1)
list.Add(2)
list.Add(3)

' Collection initialization can be simplified

' After
Dim list = New List(Of Integer) From {1, 2, 3}

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0028	C# et Visual Basic	Visual Studio 2017 et versions ultérieures

Convertir la propriété automatique en propriété complète

Cette action rapide vous permet de convertir une propriété automatique en propriété complète, et vice versa.

C#

// Before
private int MyProperty { get; set; }

// Convert to full property

// After
private int MyProperty
{
    get { return _myProperty; }
    set { _myProperty = value; }
}

VB

' Before
Public Property Name As String

' Convert to full property

' After
Private _Name As String

Public Property Name As String
    Get
        Return _Name
    End Get
    Set
        _Name = Value
    End Set
End Property

Langues applicables	Version prise en charge
C# et Visual Basic	Visual Studio 2017 version 15.5 et ultérieure

Convertir le corps de bloc en membre expression-bodied

Cette action rapide vous permet de convertir des corps de blocs en membres expression-bodied pour les méthodes, constructeurs, opérateurs, propriétés, indexeurs et accesseurs.

//Before
class MyClass4
{
    private int _myProperty;

    public int MyProperty
    {
        get { return _myProperty; }
        set
        {
            _myProperty = value;
        }
    }

    public MyClass4(int myProperty)
    {
        MyProperty = myProperty;
    }

    public void PrintProperty()
    {
        Console.WriteLine(MyProperty);
    }
}

// Use expression body for accessors/constructors/methods

// After
class MyClass4
{
    private int _myProperty;

    public int MyProperty
    {
        get => _myProperty;
        set => _myProperty = value;
    }

    public MyClass4(int myProperty) => MyProperty = myProperty;

    public void PrintProperty() => Console.WriteLine(MyProperty);
}

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0021-27	C# 6.0+	Visual Studio 2017 et versions ultérieures

Convertir une fonction anonyme en fonction locale

Cette action rapide convertit les fonctions anonymes en fonctions locales.

// Before
Func<int, int> fibonacci = null;
fibonacci = (int n) =>
{
    return n <= 1 ? 1 : fibonacci(n - 1) + fibonacci(n - 2);
};

// Use local function

// After
int fibonacci(int n)
{
    return n <= 1 ? 1 : fibonacci(n-1) + fibonacci(n-2);
}

Convertir 'ReferenceEquals' en 'is null'

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0041	C# 7.0+	Visual Studio 2017 version 15.5 et ultérieure

Cette action rapide suggère l’utilisation de la mise en correspondance de modèles plutôt que du modèle de codage, dans la mesure du ReferenceEquals possible.

// Before
var value = "someString";
if (object.ReferenceEquals(value, null))
{
    return;
}

// Use 'is null' check

// After
var value = "someString";
if (value is null)
{
    return;
}

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0039	C# 7.0+	Visual Studio 2017 version 15. et versions ultérieures

Introduire la mise en correspondance des modèles

Cette action rapide suggère l’utilisation de la correspondance de modèle avec des casts et des vérifications null en C#.

// Before
if (o is int)
{
    var i = (int)o;
    ...
}

// Use pattern matching

// After
if (o is int i)
{
    ...
}

// Before
var s = o as string;
if (s != null)
{
    ...
}

// Use pattern matching

// After
if (o is string s)
{
    ...
}

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0020	C# 7.0+	Visual Studio 2017 et versions ultérieures
IDE0019	C# 7.0+	Visual Studio 2017 et versions ultérieures

Modifier la base des littéraux numériques

Cette action rapide vous permet de convertir un littéral numérique d’un système numérique de base en un autre. Par exemple, vous pouvez modifier un nombre en hexadécimal ou au format binaire.

C#

// Before
int countdown = 2097152;

// Convert to hex

// After
int countdown = 0x200000;

VB

' Before
Dim countdown As Integer = 2097152

' Convert to hex

' After
Dim countdown As Integer = &H200000

Langues applicables	Version prise en charge
C# 7.0+ et Visual Basic 14+	Visual Studio 2017 version 15.3 et ultérieure

Insérer des séparateurs de chiffres dans des littéraux

Cette action rapide vous permet d’ajouter des caractères de séparation dans des valeurs littérales.

C#

// Before
int countdown = 1000000;

// Separate thousands

// After
int countdown = 1_000_000;

VB

' Before
Dim countdown As Integer = 1000000

' Separate thousands

' After
Dim countdown As Integer = 1_000_000

Langues applicables	Version prise en charge
C# 7.0+ et Visual Basic 14+	Visual Studio 2017 version 15.3 et ultérieure

Utiliser des noms de tuples explicites

Cette action rapide identifie les zones où le nom de tuple explicite peut être utilisé plutôt que Item1, Item2, etc.

C#

// Before
(string name, int age) customer = GetCustomer();
var name = customer.Item1;

// Use explicit tuple name

// After
(string name, int age) customer = GetCustomer();
var name = customer.name;

VB

' Before
Dim customer As (name As String, age As Integer) = GetCustomer()
Dim name = customer.Item1

' Use explicit tuple name

' After
Dim customer As (name As String, age As Integer) = GetCustomer()
Dim name = customer.name

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0033	C# 7.0+ et Visual Basic 15+	Visual Studio 2017 et versions ultérieures

Utiliser des noms déduits

Cette action rapide indique quand le code peut être simplifié pour utiliser des noms de membres déduits dans des types anonymes ou des noms d’éléments déduits dans des tuples.

// Before
var anon = new { age = age, name = name };

// Use inferred member name

// After
var anon = new { age, name };

// Before
var tuple = (age: age, name: name);

// Use inferred tuple element name

// After
var tuple = (age, name);

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0037	C#	Visual Studio 2017 version 15.5 et ultérieure
IDE0037	C# 7.1+	Visual Studio 2017 version 15.5 et ultérieure

Déconstructez la déclaration de tuple

Cette action rapide permet de déconstructer les déclarations de variables tuple.

// Before
var person = GetPersonTuple();
Console.WriteLine($"{person.name} {person.age}");

(int x, int y) point = GetPointTuple();
Console.WriteLine($"{point.x} {point.y}");

//Deconstruct variable declaration

// After
var (name, age) = GetPersonTuple();
Console.WriteLine($"{name} {age}");

(int x, int y) = GetPointTuple();
Console.WriteLine($"{x} {y}");

Identifiant de diagnostic	Langues applicables	Version prise en charge
IDE0042	C# 7.0+	Visual Studio 2017 version 15.5 et ultérieure

Make, méthode synchrone

Lorsque vous utilisez le ou Async le async mot clé sur une méthode, il est attendu qu’à l’intérieur de cette méthode, le ou Await le await mot clé est également utilisé. Toutefois, si ce n’est pas le cas, une action rapide apparaît qui rend la méthode synchrone en supprimant le ou Async le async mot clé et en modifiant le type de retour. Utilisez l’option Rendre la méthode synchrone dans le menu Actions rapides.

C#

// Before
async Task<int> MyAsyncMethod()
{
    return 3;
}

// Make method synchronous

// After
int MyAsyncMethod()
{
    return 3;
}

VB

' Before
Async Function MyAsyncMethod() As Task(Of Integer)
    Return 3
End Function

' Make method synchronous

' After
Function MyAsyncMethod() As Integer
    Return 3
End Function

ID d'erreur	Langues applicables
CS1998, BC42356	C# et Visual Basic

Rendre la méthode asynchrone

Lorsque vous utilisez le mot clé ou Await l’intérieur await d’une méthode, il est attendu que la méthode soit marquée avec le mot clé ou Async le async mot clé. Toutefois, si ce n’est pas le cas, une action rapide apparaît qui rend la méthode asynchrone. Utilisez l’option asynchrone Make method/Function dans le menu Actions rapides.

C#

// Before
int MyAsyncMethod()
{
    return await Task.Run(...);
}

// Make method asynchronous

// After
async Task<int> MyAsyncMethod()
{
    return await Task.Run(...);
}

VB

' Before
Function MyAsyncMethod() as Integer
    Return  Await Task.Run(...)
End Function

' Make method asynchronous

' After
Async Function MyAsyncMethod() As Task(Of Integer)
    Return Await Task.Run(...)
End Function

ID d'erreur	Langues applicables	Version prise en charge
CS4032, BC37057	C# et Visual Basic	Visual Studio 2017 et versions ultérieures

Voir aussi

• Actions rapides