Actions rapides courantes

Les sections de cette rubrique répertorient quelques-unes des Actions rapides courantes qui sont applicables à la fois au code C# et au code Visual Basic. Ces actions sont des corrections du code pour les diagnostics du compilateur ou pour les analyseurs .NET Compiler Platform intégrés dans Visual Studio.

Actions permettant de résoudre des erreurs

Les actions rapides de cette section corrigent les erreurs dans le code qui provoquent un échec de génération. Quand des actions rapides sont disponibles pour corriger une erreur sur une ligne de code, l’icône qui s’affiche dans la marge ou en dessous de la ligne ondulée rouge est une ampoule avec un « x » rouge dessus.

Symbole ou mot clé mal orthographié correct

Si par erreur vous orthographiez mal un type ou un mot clé dans Visual Studio, cette action rapide le corrige automatiquement pour vous. Vous voyez ces éléments dans le menu Ampoule comme « Remplacer « <mot mal orthographié> » par « <mot correct> » ». Par exemple :

// Before
private viod MyMethod()
{
}

// Change 'viod' to 'void'

// After
private void MyMethod()
{
}

' Before
Function MyFunction as Intger
End Function

' Change 'Intger' to 'Integer'

' After
Function MyFunction as Integer
End Function

Résoudre un conflit de fusion Git

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

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

    }
}

// Take changes from 'HEAD'

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

    }
}

Actions permettant de supprimer du code inutile

Supprimer les Usings inutiles/les importations superflues

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

Supprimer le cast inutile

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

// before
int number = (int)3;

// Remove Unnecessary Cast

// after
int number = 3;

' 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 les variables qui ont été déclarées, mais jamais 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);
}

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

Cette action rapide permet de supprimer le type de valeur d’une expression de valeur par défaut et utilise le littéral par défaut quand 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) { ... }

Actions permettant d’ajouter du code manquant

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

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

Quand ces options sont activées, si vous utilisez un type dans un espace de noms qui n’est pas importé, mais qui existe dans un assembly de référence ou un package NuGet, la directive using ou import est créée.

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

// using System.Diagnostics;

// After
using System.Diagnostics;

Debug.WriteLine("Hello");

' Before
Debug.WriteLine("Hello")

' Imports System.Diagnostics

' After
Imports System.Diagnostics

Debug.WriteLine("Hello")

Ajouter les instructions case manquantes/une instruction case par défaut/les deux

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

Considérons l’énumération et l’instruction switch ou Select Case vide suivantes :

enum MyEnum
{
    Item1,
    Item2,
    Item3
}

...

MyEnum myEnum = MyEnum.Item1;

switch(myEnum)
{
}

Enum MyEnum
    Item1
    Item2
    Item3
End Enum

...

Dim myEnum as MyEnum = MyEnum.Item1

Select Case myEnum
End Select

Utilisez l’action rapide Ajouter les deux pour renseigner à la fois les instructions case manquantes et une instruction case par défaut :

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

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

Ajouter des contrôles de valeurs Null pour les paramètres

Cette action rapide vous permet d’ajouter un contrôle dans votre code pour déterminer si un paramètre est 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));
    }
}

Ajouter le nom de l’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);

Ajouter des accolades

L’action rapide Ajouter des accolades place des accolades autour des instructions if sur une seule ligne.

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

// Add braces

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

Ajouter et trier des modificateurs

Ces actions rapides facilitent l’organisation des modificateurs en vous permettant de trier les modificateurs 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;

Transformations de code

Convertir une construction « if » en « switch »

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

// 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;
}

' 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

Convertir en chaîne interpolée

Les chaînes interpolées représentent un moyen simple d’exprimer des chaînes avec des variables incorporées, similaire à la méthode String.Format. Cette action rapide reconnaît les chaînes concaténées ou l’utilisation de String.Format et met une chaîne interpolée à la place.

// 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";

' 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"

Utiliser des initialiseurs d’objets

Cette Action rapide permet d’utiliser des initialiseurs d’objets au lieu d’appeler le constructeur et d’avoir des lignes supplémentaires d’instructions d’assignation.

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

// Object initialization can be simplified

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

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

' Object initialization can be simplified

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

Utiliser des initialiseurs de collections

Cette action rapide vous permet d’utiliser des initialiseurs de collection au lieu de plusieurs appels à la méthode Add de votre classe.

// 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 };

' 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}

Convertir une 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.

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

// Convert to full property

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

' 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

Convertir un corps de bloc en membre expression-bodied

Cette action rapide vous permet de convertir des corps de bloc en membres expression-bodied pour des méthodes, des constructeurs, des opérateurs, des propriétés, des indexeurs et des 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);
}

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 »

Cette action rapide suggère l’utilisation de critères spéciaux plutôt que le modèle de codage ReferenceEquals, dans la mesure du possible.

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

// Use 'is null' check

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

Introduire des critères spéciaux

Cette action rapide suggère l’utilisation de critères spéciaux avec des casts et des contrôles de valeur 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)
{
    ...
}

Changer 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 convertir un nombre en un format hexadécimal ou binaire.

// Before
int countdown = 2097152;

// Convert to hex

// After
int countdown = 0x200000;

' Before
Dim countdown As Integer = 2097152

' Convert to hex

' After
Dim countdown As Integer = &H200000

Insérer des séparateurs numériques dans les littéraux

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

// Before
int countdown = 1000000;

// Separate thousands

// After
int countdown = 1_000_000;

' Before
Dim countdown As Integer = 1000000

' Separate thousands

' After
Dim countdown As Integer = 1_000_000

Utiliser des noms de tuples explicites

Cette action rapide identifie les zones où le nom de tuple explicite peut être utilisé au lieu de Item1, Item2, etc.

// 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;

' 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

Utiliser des noms déduits

Cette action rapide indique quand du code peut être simplifié de façon à utiliser des noms de membre inférés dans les types anonymes ou des noms d’éléments inférés dans les 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);

Déconstruire la déclaration de tuple

Cette action rapide permet de déconstruire les déclarations de variables de 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}");

Rendre la méthode synchrone

Lors de l’utilisation du mot clé async ou Async sur une méthode, le mot clé await ou Await doit également être utilisé dans cette méthode. Cependant, si ce n’est pas le cas, une action rapide apparaît, qui vous permet de rendre la méthode synchrone en supprimant le mot clé async ou Async, et en changeant le type de retour. Utilisez l’option Rendre la méthode synchrone dans le menu Actions rapides.

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

// Make method synchronous

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

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

' Make method synchronous

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

Rendre la méthode asynchrone

Si le mot clé await ou Await est utilisé dans une méthode, cette méthode doit se retrouver marquée du mot clé async ou Async. Toutefois, si ce n’est pas le cas, une Action rapide apparaît, qui rend la méthode asynchrone. Utilisez l’option Make method/Function asynchronous (Rendre la méthode/fonction asynchrone) dans le menu Actions rapides.

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

// Make method asynchronous

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

' 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

Voir aussi

• Actions rapides