Aracılığıyla paylaş

Atmalar - C# Ile İlgili Temel Bilgiler

Boş değişkenler, uygulama kodunda kasıtlı olarak kullanılmayan yer tutucu değişkenlerdir. Göz ardı edilenler, atanmamış değişkenlere eşdeğerdir; değerlere sahip değildir. Bir atma, niyetinizi derleyiciye ve kodunuzu okuyan diğer kişilere iletir: Bir ifadenin sonucunu göz ardı etmek niyetindesiniz. Bir ifadenin sonucunu, bir küp ifadesinin bir veya daha fazla üyesini, out bir metot parametreyi veya desen eşleştirme ifadesinin hedefini yoksaymak isteyebilirsiniz.

Atmalar kodunuzun amacını net hale getirir. Atma işlemi, kodun değişkeni hiçbir zaman kullanmadığını gösterir. Okunabilirliğini ve sürdürülebilirliğini geliştirir.

Bir değişkenin kullanılmadığını belirtmek için, ad olarak alt çizgi (_) atarsınız. Örneğin, aşağıdaki yöntem çağrısı, birinci ve ikinci değerlerin atıldığı bir tanımlama grubu döndürür. area , GetCityInformation tarafından döndürülen üçüncü bileşene ayarlanmış daha önce bildirilen bir değişkendir.

(_, _, area) = city.GetCityInformation(cityName);

Lambda ifadesinin kullanılmayan giriş parametrelerini belirlemek için 'discard' (_atılabilir_) sözdizimini kullanabilirsiniz. Daha fazla bilgi için Lambda ifadeleri makalesinin Lambda ifadesinin giriş parametreleri bölümüne bakın.

Geçerli bir tasfiye olduğunda _, değerini almaya veya atama işleminde kullanmaya çalışmak, "Mevcut bağlamda '_' adı yok" şeklinde CS0103 derleyici hatasına yol açar. Bu hatanın nedeni _ , bir değer atanmaması ve depolama konumu bile atanmamasıdır. Gerçek bir değişkense, önceki örnekte olduğu gibi birden fazla değeri atamazdınız.

Tuple ve nesne ayrıştırma

Atmalar, uygulama kodunuz bazı tanımlama grubu öğelerini kullandığında ancak diğerlerini yoksaydığında tanımlama kümeleri ile çalışırken yararlıdır. Örneğin, aşağıdaki QueryCityDataForYears yöntem, bir şehrin adı, alanı, bir yıl, o yıl için şehrin nüfusu, ikinci bir yıl ve o ikinci yıl için şehrin nüfusunu içeren bir demet döndürür. Örnekte, bu iki yıl arasındaki nüfus değişikliği gösterilmektedir. Tanımlama grubundaki verilerden şehir alanıyla ilgili bilgimiz yok ve tasarım zamanında şehir adını ve iki tarihi biliyoruz. Sonuç olarak, yalnızca tanımlama grubunda depolanan iki popülasyon değeriyle ilgileniyoruz ve kalan değerlerini atılmış olarak işleyebiliriz.

var (_, _, _, pop1, _, pop2) = QueryCityDataForYears("New York City", 1960, 2010);

Console.WriteLine($"Population change, 1960 to 2010: {pop2 - pop1:N0}");

static (string, double, int, int, int, int) QueryCityDataForYears(string name, int year1, int year2)
{
    int population1 = 0, population2 = 0;
    double area = 0;

    if (name == "New York City")
    {
        area = 468.48;
        if (year1 == 1960)
        {
            population1 = 7781984;
        }
        if (year2 == 2010)
        {
            population2 = 8175133;
        }
        return (name, area, year1, population1, year2, population2);
    }

    return ("", 0, 0, 0, 0, 0);
}
// The example displays the following output:
//      Population change, 1960 to 2010: 393,149

Daha fazla bilgi için demet yapısı bozma ve atlamalar konusuna bakın, demetleri ve diğer türleri yapılandırma.

Deconstruct Sınıfın, yapının veya arabirimin yöntemi, bir nesneden belirli bir veri kümesini almanıza ve kaldırmanıza da olanak tanır. Kaldırılan değerlerin yalnızca bir alt kümesiyle çalışmak istediğinizde atmaları kullanabilirsiniz. Aşağıdaki örnek, bir Person nesneyi dört dizeye (ad ve soyadı, şehir ve eyalet) ayırır, ancak soyadını ve eyaleti atar.

using System;

namespace Discards
{
    public class Person
    {
        public string FirstName { get; set; }
        public string MiddleName { get; set; }
        public string LastName { get; set; }
        public string City { get; set; }
        public string State { get; set; }

        public Person(string fname, string mname, string lname,
                      string cityName, string stateName)
        {
            FirstName = fname;
            MiddleName = mname;
            LastName = lname;
            City = cityName;
            State = stateName;
        }

        // Return the first and last name.
        public void Deconstruct(out string fname, out string lname)
        {
            fname = FirstName;
            lname = LastName;
        }

        public void Deconstruct(out string fname, out string mname, out string lname)
        {
            fname = FirstName;
            mname = MiddleName;
            lname = LastName;
        }

        public void Deconstruct(out string fname, out string lname,
                                out string city, out string state)
        {
            fname = FirstName;
            lname = LastName;
            city = City;
            state = State;
        }
    }
    class Example
    {
        public static void Main()
        {
            var p = new Person("John", "Quincy", "Adams", "Boston", "MA");

            // Deconstruct the person object.
            var (fName, _, city, _) = p;
            Console.WriteLine($"Hello {fName} of {city}!");
            // The example displays the following output:
            //      Hello John of Boston!
        }
    }
}

Atmalarla kullanıcı tanımlı türlerin yapısını kaldırma hakkında daha fazla bilgi için bkz. Tanımlama demetlerini ve diğer türleri yapılandırma.

switch ile desen eşleştirme

Atma deseniswitch ifadesiyle eşleşme deseninde kullanılabilir. Her ifade, null dahil olmak üzere, her zaman atma deseni ile eşleşir.

Aşağıdaki örnek, bir ProvidesFormatInfo nesnenin bir switch uygulama sağlayıp sağlamadığını belirlemek ve nesnenin IFormatProviderolup olmadığını test etmek için bir ifade kullanan bir null yöntemi tanımlar. Ayrıca, null olmayan herhangi bir türdeki nesneleri işlemek için atma desenini kullanır.

object?[] objects = [CultureInfo.CurrentCulture,
                   CultureInfo.CurrentCulture.DateTimeFormat,
                   CultureInfo.CurrentCulture.NumberFormat,
                   new ArgumentException(), null];
foreach (var obj in objects)
    ProvidesFormatInfo(obj);

static void ProvidesFormatInfo(object? obj) =>
    Console.WriteLine(obj switch
    {
        IFormatProvider fmt => $"{fmt.GetType()} object",
        null => "A null object reference: Its use could result in a NullReferenceException",
        _ => "Some object type without format information"
    });
// The example displays the following output:
//    System.Globalization.CultureInfo object
//    System.Globalization.DateTimeFormatInfo object
//    System.Globalization.NumberFormatInfo object
//    Some object type without format information
//    A null object reference: Its use could result in a NullReferenceException

out parametreleriyle yöntem çağrıları

Kullanıcı tanımlı bir türün (bir sınıf, yapı veya arabirim örneği) yapısını çıkarmak için Deconstruct yöntemini çağırma sırasında, tek tek out değişkenlerin değerlerini atabilirsiniz. Ancak herhangi bir out parametre ile bir yöntemi çağırırken out bağımsız değişkenlerin değerini de yok sayabilirsiniz.

Aşağıdaki örnek, bir tarihin dize gösteriminin geçerli kültürde geçerli olup olmadığını belirlemek için DateTime.TryParse(String, out DateTime) yöntemini çağırır. Örnek yalnızca tarih dizesini doğrulamakla ilgilendiğinden ve tarihi ayıklamak için ayrıştırmayla ilgilenmediğinden, out yöntemine sağlanan parametre göz ardı edilir.

string[] dateStrings = ["05/01/2018 14:57:32.8", "2018-05-01 14:57:32.8",
                      "2018-05-01T14:57:32.8375298-04:00", "5/01/2018",
                      "5/01/2018 14:57:32.80 -07:00",
                      "1 May 2018 2:57:32.8 PM", "16-05-2018 1:00:32 PM",
                      "Fri, 15 May 2018 20:10:57 GMT"];
foreach (string dateString in dateStrings)
{
    if (DateTime.TryParse(dateString, out _))
        Console.WriteLine($"'{dateString}': valid");
    else
        Console.WriteLine($"'{dateString}': invalid");
}
// The example displays output like the following:
//       '05/01/2018 14:57:32.8': valid
//       '2018-05-01 14:57:32.8': valid
//       '2018-05-01T14:57:32.8375298-04:00': valid
//       '5/01/2018': valid
//       '5/01/2018 14:57:32.80 -07:00': valid
//       '1 May 2018 2:57:32.8 PM': valid
//       '16-05-2018 1:00:32 PM': invalid
//       'Fri, 15 May 2018 20:10:57 GMT': invalid

Bağımsız atma

İhmal etmeye seçtiğiniz herhangi bir değişkeni belirtmek için bağımsız bir ihmal kullanabilirsiniz. Tipik kullanımlardan biri, bir bağımsız değişkenin null olmadığından emin olmak için atama kullanmaktır. Aşağıdaki kod, atamayı zorlamak için bir atma kullanır. Null birleşim işleci, bağımsız değişken System.ArgumentNullException olduğunda bir null oluşturmak için atamanın sağ tarafında kullanılır. Kod atamanın sonucuna ihtiyaç duymadığından atılır. İfade null kontrolü yapmaya zorlar. Atma, amacınızı netleştirir: atamanın sonucu gerekli değildir veya kullanılmaz.

public static void Method(string arg)
{
    _ = arg ?? throw new ArgumentNullException(paramName: nameof(arg), message: "arg can't be null");

    // Do work with arg.
}

Aşağıdaki örnek, zaman uyumsuz bir işlem tarafından döndürülen Task nesneyi yoksaymak için bağımsız bir atılma kullanır. Görevin atanması, işlemin tamamlanmak üzere olduğu sırada attığı özel durumu bastırma etkisine sahiptir. Amacınızı netleştirir: Task öğesini atmak ve bu zaman uyumsuz işlemden kaynaklanan hataları gözardı etmek istiyorsunuz.

private static async Task ExecuteAsyncMethods()
{
    Console.WriteLine("About to launch a task...");
    _ = Task.Run(() =>
    {
        var iterations = 0;
        for (int ctr = 0; ctr < int.MaxValue; ctr++)
            iterations++;
        Console.WriteLine("Completed looping operation...");
        throw new InvalidOperationException();
    });
    await Task.Delay(5000);
    Console.WriteLine("Exiting after 5 second delay");
}
// The example displays output like the following:
//       About to launch a task...
//       Completed looping operation...
//       Exiting after 5 second delay

Görevi ataya atamadan aşağıdaki kod bir derleyici uyarısı oluşturur:

private static async Task ExecuteAsyncMethods()
{
    Console.WriteLine("About to launch a task...");
    // CS4014: Because this call is not awaited, execution of the current method continues before the call is completed.
    // Consider applying the 'await' operator to the result of the call.
    Task.Run(() =>
    {
        var iterations = 0;
        for (int ctr = 0; ctr < int.MaxValue; ctr++)
            iterations++;
        Console.WriteLine("Completed looping operation...");
        throw new InvalidOperationException();
    });
    await Task.Delay(5000);
    Console.WriteLine("Exiting after 5 second delay");

Uyarı

Bir hata ayıklayıcısı kullanarak önceki iki örnekten birini çalıştırırsanız, özel durum oluştuğunda hata ayıklayıcı programı durdurur. Bir hata ayıklayıcı eklenmediğinde, her iki durumda da istisna sessizce yoksayılır.

_ aynı zamanda geçerli bir tanımlayıcıdır. Desteklenen bir bağlamın dışında kullanıldığında, _ bir atma olarak değil, geçerli bir değişken olarak değerlendirilir. Adlı _ bir tanımlayıcı zaten kapsamdaysa, _'in tek başına bir atma olarak kullanılması aşağıdakilere neden olabilir:

  • Hedeflenen atma değerini atayarak kapsam _ içi değişkenin değerinin yanlışlıkla değiştirilmesi. Örneğin:
    private static void ShowValue(int _)
{
   byte[] arr = [0, 0, 1, 2];
   _ = BitConverter.ToInt32(arr, 0);
   Console.WriteLine(_);
}
 // The example displays the following output:
 //       33619968
  • Tür güvenliğini ihlal ettiği için derleyici hatası. Örneğin:
    private static bool RoundTrips(int _)
{
   string value = _.ToString();
   int newValue = 0;
   _ = Int32.TryParse(value, out newValue);
   return _ == newValue;
}
// The example displays the following compiler error:
//      error CS0029: Cannot implicitly convert type 'bool' to 'int'

Ayrıca bakınız