Yaygın Hızlı Eylemler

Bu konudaki bölümlerde hem C# hem de Visual Basic kodu için geçerli olan bazı yaygın Hızlı Eylemler listelenir. Bu eylemler, derleyici tanılamaları veya Visual Studio'daki yerleşik .NET Derleyici Platformu çözümleyicileri için kod düzeltmeleridir.

Hataları düzelten eylemler

Bu bölümdeki Hızlı Eylemler, derlemenin başarısız olmasına neden olabilecek kod hatalarını düzeltir. Bir kod satırındaki hatayı düzeltmek için Hızlı Eylemler kullanılabilir olduğunda, kenar boşluğunda veya kırmızı dalgalı çizginin altında görüntülenen simge üzerinde kırmızı 'x' bulunan bir ampuldür.

Yanlış yazılmış simgeyi veya anahtar sözcüğü düzeltme

Visual Studio'da bir türü veya anahtar sözcüğü yanlışlıkla yanlış yazarsanız, bu Hızlı İşlem bunu sizin için otomatik olarak düzelter. Ampul menüsünde bu öğeleri "Yanlış yazılmış sözcüğü '<doğru sözcük>>' olarak değiştir<" olarak görürsünüz. Örneğin:

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

Git birleştirme çakışmalarını çözme

Bu Hızlı Eylemler, çakışan kodu ve işaretçileri kaldıran "değişiklik yaparak" git birleştirme çakışmalarını çözmenizi sağlar.

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

    }
}

// Take changes from 'HEAD'

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

    }
}

Gereksiz kodu kaldıran eylemler

Gereksiz kullanımı/İçeri Aktarmaları kaldırma

Gereksiz Kullanımları/İçeri Aktarmaları Kaldır Hızlı Eylemi, geçerli dosya için kullanılmayan using ve Import yönergeleri kaldırır. Bu öğeyi seçtiğinizde kullanılmayan ad alanı içeri aktarmaları kaldırılır.

Gereksiz atamayı kaldırma

Tür atama gerektirmeyen başka bir türe yayınlarsanız, Gereksiz Atamayı Kaldır Hızlı İşlem öğesi gereksiz atamayı kaldırır.

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

Kullanılmayan değişkenleri kaldırma

Bu Hızlı Eylem, bildirilen ancak kodunuzda hiç kullanılmayan değişkenleri kaldırmanıza olanak tanır.

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

// Remove unused variables

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

Türü varsayılan değer ifadesinden kaldırma

Bu Hızlı Eylem, varsayılan değer ifadesinden değer türünü kaldırır ve derleyici ifadenin türünü çıkarabildiğinde varsayılan değişmez değeri kullanır.

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

// Simplify default expression

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

Eksik kod ekleyen eylemler

Başvuru derlemelerindeki türler, NuGet paketleri veya çözümünüzdeki diğer türler için usings/imports ekleme

• Başvuru derlemelerindeki türler için kullanımı/içeri aktarmayı önerme
• NuGet paketlerindeki türler için kullanımı/içeri aktarmayı önerme

Etkinleştirildiğinde, şu anda içeri aktarılmayan ancak bir başvuru derlemesinde veya NuGet paketinde bulunan bir ad alanında bir tür kullanırsanız, using veya import yönergesi oluşturulur.

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

Eksik servis talepleri/varsayılan servis talebi/her ikisi de ekleme

C# dilinde bir switch deyim veya Select Case Visual Basic'te deyim oluştururken, eksik servis talebi öğelerini, varsayılan servis talebi deyimini veya her ikisini de otomatik olarak eklemek için Kod Eylemi kullanabilirsiniz.

Aşağıdaki numaralandırmayı ve boş switch veya Select Case deyimini göz önünde bulundurun:

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

Her İkisi De Ekle Hızlı Eylemi kullanıldığında eksik durumlar doldurulur ve varsayılan bir büyük/küçük harf eklenir:

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

Parametreler için null denetimleri ekleme

Bu Hızlı Eylem, bir parametrenin null olup olmadığını söylemek için kodunuzda bir denetim eklemenize olanak tanır.

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

Bağımsız değişken adı ekleme

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

Küme ayraçları ekleme

Küme ayraçları ekle Hızlı Eylemi, ayraçları tek satırlı if deyimler etrafında sarmalar.

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

// Add braces

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

Değiştirici ekleme ve sıralama

Bu Hızlı Eylemler, var olanı sıralamanıza ve eksik erişilebilirlik değiştiricileri eklemenize olanak tanıyarak değiştiricileri düzenlemenize yardımcı olur.

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

Kod dönüştürmeleri

'if' yapısını 'switch' olarak dönüştürme

Bu Hızlı Eylem, if-then-else yapısını bir anahtar yapısına dönüştürmenizi sağlar.

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

İlişkili dizeye dönüştür

İlişkili dizeler, String.Format yöntemine benzer şekilde eklenmiş değişkenlerle dizeleri ifade etmenin kolay bir yoludur. Bu Hızlı Eylem, dizelerin birleştirildiği veya String.Format kullanıldığı durumları tanır ve kullanımı ilişkilendirilmiş bir dizeye değiştirir.

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

Nesne başlatıcıları kullanma

Bu Hızlı Eylem, oluşturucuyu çağırmak ve ek atama deyimleri satırlarına sahip olmak yerine nesne başlatıcıları kullanmanızı sağlar.

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

Koleksiyon başlatıcılarını kullanma

Bu Hızlı Eylem, sınıfınızın yöntemine birden çok çağrı yerine koleksiyon başlatıcılarını kullanmanıza Add olanak tanır.

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

Otomatik özelliği tam özelliğe dönüştürme

Bu Hızlı İşlem, bir otomatik özelliği tam özelliğe dönüştürmenize olanak tanır ve tam tersi de geçerlidir.

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

Blok gövdesini ifade gövdeli üyeye dönüştürme

Bu Hızlı Eylem, blok gövdelerini yöntemler, oluşturucular, işleçler, özellikler, dizin oluşturucular ve erişimciler için ifade gövdeli üyelere dönüştürmenizi sağlar.

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

Anonim işlevi yerel işleve dönüştürme

Bu Hızlı Eylem anonim işlevleri yerel işlevlere dönüştürür.

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

'ReferenceEquals' değerini 'is null' olarak dönüştürün

Bu Hızlı Eylem, mümkün olduğunca kodlama deseni yerine desen eşleştirmenin ReferenceEquals kullanılmasını önerir.

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

// Use 'is null' check

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

Desen eşleştirmeyi tanıtma

Bu Hızlı Eylem, C# dilinde atamalar ve null denetimlerle desen eşleştirmenin kullanılmasını önerir.

// 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)
{
    ...
}

Sayısal değişmez değerlerin tabanını değiştirme

Bu Hızlı Eylem, bir sayısal değişmez değeri bir temel sayısal sistemden diğerine dönüştürmenizi sağlar. Örneğin, bir sayıyı onaltılık veya ikili biçime değiştirebilirsiniz.

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

Değişmez değerlere basamak ayırıcıları ekleme

Bu Hızlı Eylem, değişmez değerlere ayırıcı karakterler eklemenize olanak tanır.

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

Açık tanımlama grubu adlarını kullanma

Bu Hızlı Eylem, Öğe1, Öğe2 vb. yerine açık tanımlama grubu adının kullanılabildiği alanları tanımlar.

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

Çıkarsanan adları kullanma

Bu Hızlı Eylem, kodun anonim türlerde çıkarılmış üye adlarını veya tanımlama gruplarındaki çıkarılmış öğe adlarını kullanmak için ne zaman basitleştirilebileceğini gösterir.

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

Tanımlama grubu bildirimini kaldırma

Bu Hızlı Eylem, tanımlama grubu değişken bildirimlerinin yapılandırılmasını sağlar.

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

Yöntemi zaman uyumlu hale getirme

Bir yöntemde veya Async anahtar sözcüğü kullanılırkenasync, bu yöntemin içinde veya Await anahtar sözcüğü de await kullanılması beklenir. Ancak bu durum geçerli değilse, veya Async anahtar sözcüğünü kaldırıp async dönüş türünü değiştirerek yöntemi zaman uyumlu hale getiren bir Hızlı Eylem görüntülenir. Hızlı Eylemler menüsündeki Yöntemi zaman uyumlu yap seçeneğini kullanın.

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

Yöntemi zaman uyumsuz yapma

Bir yöntemin await içinde veya Await anahtar sözcüğünü kullanırken, yöntemin veya Async anahtar sözcüğüyle async işaretlenmesi beklenir. Ancak, durum bu değilse, yöntemi zaman uyumsuz hale getiren bir Hızlı İşlem görüntülenir. Hızlı Eylemler menüsünden Yöntemi/İşlevi zaman uyumsuz yap seçeneğini kullanın.

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

Ayrıca bkz.

• Hızlı Eylemler