C'deki Yöntemler#

2025-04-17

Yöntem, bir dizi deyim içeren bir kod bloğudur. Bir program, yöntemi çağırarak ve gerekli yöntem bağımsız değişkenlerini belirterek deyimlerin yürütülmesine neden olur. C# dilinde, yürütülen her yönerge bir yöntem bağlamında gerçekleştirilir.

Not

Bu makalede adlandırılmış yöntemler ele alınmaktadır. Anonim işlevler hakkında bilgi için bkz . Lambda ifadeleri.

Yöntem imzaları

Yöntemler, class, record veya struct belirtilerek bildirilir:

veya publicgibi private isteğe bağlı bir erişim düzeyi. Varsayılan değer: private.
İsteğe bağlı değiştiriciler, abstract veya sealed gibi.
Yöntem bir değer döndürmüyorsa dönüş değeri veya void.
Yöntem adı.
Herhangi bir yöntem parametresi. Yöntem parametreleri parantez içine alınır ve virgülle ayrılır. Boş ayraçlar yöntemin parametre gerektirmediğini gösterir.

Bu parçalar birlikte yöntem imzasını oluşturur.

Önemli

Yöntemin dönüş türü, yöntemi aşırı yükleme amacıyla yöntemin imzasının bir parçası değildir. Ancak, bir temsilci ile işaret eden yöntem arasındaki uyumluluğu belirlerken yöntemin imzasının bir parçasıdır.

Aşağıdaki örnek, beş yöntem içeren adlı Motorcycle bir sınıfı tanımlar:

namespace MotorCycleExample
{
    abstract class Motorcycle
    {
        // Anyone can call this.
        public void StartEngine() {/* Method statements here */ }

        // Only derived classes can call this.
        protected void AddGas(int gallons) { /* Method statements here */ }

        // Derived classes can override the base class implementation.
        public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

        // Derived classes can override the base class implementation.
        public virtual int Drive(TimeSpan time, int speed) { /* Method statements here */ return 0; }

        // Derived classes must implement this.
        public abstract double GetTopSpeed();
    }

Motorcycle sınıfı aşırı yüklenmiş bir yöntemi içerir: Drive. İki yöntem aynı ada sahiptir, ancak parametre listeleri bunları ayırt eder.

Yöntem çağırma

Yöntemler örnek veya statik olabilir. Bu örnekte bir örnek yöntemini çağırmak için bir nesne örneği oluşturmanız gerekir; bir örnek yöntemi bu örnek ve verileri üzerinde çalışır. Yöntemin ait olduğu türün adına başvurarak statik bir yöntem çağırırsınız; statik yöntemler örnek verileri üzerinde çalışmaz. Bir nesne örneği aracılığıyla statik bir yöntem çağrılmaya çalışılması derleyici hatası oluşturur.

Yöntemi çağırmak, bir alana erişmeye benzer. Nesne adından (bir örnek yöntemini çağırıyorsanız) veya tür adından (yöntem static çağırıyorsanız) sonra nokta, yöntemin adı ve ayraçlar ekleyin. Bağımsız değişkenler parantez içinde listelenir ve virgülle olarak ayrılır.

Yöntem tanımı, gerekli parametrelerin adlarını ve türlerini belirtir. Çağıran yöntemini çağırdığında, her parametre için bağımsız değişkenler olarak adlandırılan somut değerler sağlar. Bağımsız değişkenlerin parametre türüyle uyumlu olması gerekir, ancak çağıran kodda kullanılan bağımsız değişken adının yönteminde tanımlanan parametreyle aynı olması gerekmez. Aşağıdaki örnekte, Square yöntemi, int türünde i adlı tek bir parametre içerir. İlk yöntem çağrısı Square yöntemine int türünde "num" adlı bir değişken geçirir; ikinci yöntem çağrısı sayısal bir sabiti; ve üçüncü yöntem çağrısı ise bir ifadeyi geçirir.

public static class SquareExample
{
    public static void Main()
    {
        // Call with an int variable.
        int num = 4;
        int productA = Square(num);

        // Call with an integer literal.
        int productB = Square(12);

        // Call with an expression that evaluates to int.
        int productC = Square(productA * 3);
    }

    static int Square(int i)
    {
        // Store input argument in a local variable.
        int input = i;
        return input * input;
    }
}

En yaygın yöntem çağırma biçimi, konumsal bağımsız değişkenler kullanır; bu, bağımsız değişkenlerin yöntem parametreleriyle aynı sırada sağlanması demektir. Bu nedenle sınıfının yöntemleri Motorcycle aşağıdaki örnekte olduğu gibi çağrılabilir. Örneğin yöntemine yapılan Drive çağrı, yöntemin söz dizimindeki iki parametreye karşılık gelen iki bağımsız değişken içerir. Birincisi, miles parametresinin değeri olur. İkincisi speed parametresinin değeri olur.

class TestMotorcycle : Motorcycle
{
    public override double GetTopSpeed() => 108.4;

    static void Main()
    {
        var moto = new TestMotorcycle();

        moto.StartEngine();
        moto.AddGas(15);
        _ = moto.Drive(5, 20);
        double speed = moto.GetTopSpeed();
        Console.WriteLine($"My top speed is {speed}");
    }
}

Bir yöntemi çağırırken konumsal bağımsız değişkenler yerine adlandırılmış bağımsız değişkenler de kullanabilirsiniz. Adlandırılmış bağımsız değişkenleri kullanırken, parametre adını yazıp ardından iki nokta üst üste (":") ve bağımsız değişkeni belirtirsiniz. Yöntemin argümanları, gerekli tüm argümanlar mevcut olduğu sürece herhangi bir sırada olabilir. TestMotorcycle.Drive yöntemini kullanmak için aşağıdaki örnek, adlandırılmış bağımsız değişkenleri kullanır. Bu örnekte, adlandırılmış bağımsız değişkenler yöntemin parametre listesinden ters sırada geçirilir.

namespace NamedMotorCycle;

class TestMotorcycle : Motorcycle
{
    public override int Drive(int miles, int speed) =>
        (int)Math.Round((double)miles / speed, 0);

    public override double GetTopSpeed() => 108.4;

    static void Main()
    {
        var moto = new TestMotorcycle();
        moto.StartEngine();
        moto.AddGas(15);
        int travelTime = moto.Drive(speed: 60, miles: 170);
        Console.WriteLine($"Travel time: approx. {travelTime} hours");
    }
}
// The example displays the following output:
//      Travel time: approx. 3 hours

Hem konumsal bağımsız değişkenleri hem de adlandırılmış bağımsız değişkenleri kullanarak bir yöntemi çağırabilirsiniz. Ancak, konumsal bağımsız değişkenler yalnızca adlandırılmış bağımsız değişkenler doğru konumlarda olduğunda adlandırılmış bağımsız değişkenleri izleyebilir. Aşağıdaki örnek, bir konumsal bağımsız değişken ve bir adlandırılmış bağımsız değişken kullanarak, önceki örnekten TestMotorcycle.Drive yöntemini çağırır.

int travelTime = moto.Drive(170, speed: 55);

Devralınan ve geçersiz kılınan yöntemler

Bir tür içinde açıkça tanımlanan üyelere ek olarak, bir tür kendi temel sınıflarında tanımlanan üyeleri devralır. Yönetilen tür sistemindeki tüm türler, doğrudan veya dolaylı olarak Object sınıfından devraldığından, tüm türler Equals(Object), GetType() ve ToString() gibi üyelerini devralır. Aşağıdaki örnek bir Person sınıfı tanımlar, iki Person nesnenin örneğini oluşturur ve iki nesnenin Person.Equals eşit olup olmadığını belirlemek için yöntemini çağırır. Ancak Equals yöntemi Person sınıfında tanımlanmamıştır; Object'den miras alınmıştır.

public class Person
{
    public string FirstName = default!;
}

public static class ClassTypeExample
{
    public static void Main()
    {
        Person p1 = new() { FirstName = "John" };
        Person p2 = new() { FirstName = "John" };
        Console.WriteLine($"p1 = p2: {p1.Equals(p2)}");
    }
}
// The example displays the following output:
//      p1 = p2: False

Türler, anahtar sözcüğünü override kullanarak ve geçersiz kılınan yöntem için bir uygulama sağlayarak devralınan üyeleri geçersiz kılabilir. Yöntem imzası geçersiz kılınan yöntemle aynı olmalıdır. Aşağıdaki örnek, Equals(Object) metodunu geçersiz kılması dışında öncekine benzer. (Ayrıca her iki yöntemin tutarlı sonuçlar sağlaması amaçlandığından GetHashCode() yöntemini de geçersiz kılar.)

namespace methods;

public class Person
{
    public string FirstName = default!;

    public override bool Equals(object? obj) =>
        obj is Person p2 &&
        FirstName.Equals(p2.FirstName);

    public override int GetHashCode() => FirstName.GetHashCode();
}

public static class Example
{
    public static void Main()
    {
        Person p1 = new() { FirstName = "John" };
        Person p2 = new() { FirstName = "John" };
        Console.WriteLine($"p1 = p2: {p1.Equals(p2)}");
    }
}
// The example displays the following output:
//      p1 = p2: True

Parametreleri geçirme

C# dilindeki türler değer türleri veya başvuru türleridir. Yerleşik değer türlerinin listesi için bkz . Türler. Varsayılan olarak, hem değer türleri hem de başvuru türleri bir yönteme değer tarafından geçirilir.

Parametreleri değere göre geçirme

Değer türü bir yönteme değere göre geçirildiğinde, yöntemine nesnenin kendisi yerine nesnenin bir kopyası geçirilir. Bu nedenle, çağrılan yöntemdeki nesnede yapılan değişikliklerin, denetim çağırana geri döndüğünde özgün nesne üzerinde hiçbir etkisi olmaz.

Aşağıdaki örnek bir değer türünü değere göre bir yönteme geçirir ve çağrılan yöntem değer türünün değerini değiştirmeyi dener. Bir değer türü olan türünde intbir değişken tanımlar, değerini 20 olarak başlatır ve değişkenin değerini 30 olarak değiştiren adlı ModifyValue bir yönteme geçirir. Ancak yöntemi döndürdüğünde değişkenin değeri değişmeden kalır.

public static class ByValueExample
{
    public static void Main()
    {
        var value = 20;
        Console.WriteLine("In Main, value = {0}", value);
        ModifyValue(value);
        Console.WriteLine("Back in Main, value = {0}", value);
    }

    static void ModifyValue(int i)
    {
        i = 30;
        Console.WriteLine("In ModifyValue, parameter value = {0}", i);
        return;
    }
}
// The example displays the following output:
//      In Main, value = 20
//      In ModifyValue, parameter value = 30
//      Back in Main, value = 20

Referans türündeki bir nesne bir yönteme değer aracılığıyla geçirildiğinde, nesnenin referansı değer olarak geçirilir. Başka bir ifadeyle, yöntemi nesnenin kendisini değil, nesnenin konumunu belirten bir bağımsız değişken alır. Bu başvuruyu kullanarak nesnenin bir üyesini değiştirirseniz, denetim çağırma yöntemine döndüğünde değişiklik nesneye yansıtılır. Ancak, yöntemine geçirilen nesnenin değiştirilmesi, denetim çağırana geri döndüğünde özgün nesne üzerinde hiçbir etkisi olmaz.

Aşağıdaki örnekte adlı SampleRefTypebir sınıf (başvuru türü) tanımlanıyor. Bir SampleRefType nesnesi oluşturur, value alanına 44 atanır ve bu nesne ModifyObject metoduna geçirilir. Bu örnek esas olarak önceki örnekle aynı şeyi yapar; bir bağımsız değişkeni değere göre bir metoda iletir. Ancak başvuru türü kullanıldığından sonuç farklıdır. ModifyObject'de yapılan değişiklik, obj.value alanını ve ayrıca value yönteminde, rt bağımsız değişkeninin Main alanını 33 olarak değiştirir, bu durum örnekte gösterildiği gibidir.

public class SampleRefType
{
    public int value;
}

public static class ByRefTypeExample
{
    public static void Main()
    {
        var rt = new SampleRefType { value = 44 };
        ModifyObject(rt);
        Console.WriteLine(rt.value);
    }

    static void ModifyObject(SampleRefType obj) => obj.value = 33;
}

Parametreleri referansla geçirme

Bir yöntem içindeki bir bağımsız değişkenin değerini değiştirmek ve bu değişikliğin denetim çağıran yönteme döndüğünde yansıtılmasını sağlamak istediğinizde, parametreyi referansla geçirirsiniz. Bir parametreyi başvuruya göre geçirmek için ref veya out anahtar sözcüğünü kullanırsınız. Değeri kopyalamaktan kaçınıp, ancak yine de değişiklikleri engellemek için in anahtar sözcüğünü kullanarak referans ile geçirebilirsiniz.

Aşağıdaki örnek, önceki örnekle aynıdır; ancak burada değer, ModifyValue yöntemine referans ile geçirilmiştir. yönteminde ModifyValue parametresinin değeri değiştirildiğinde, denetim çağırana geri döndüğünde değerdeki değişiklik yansıtılır.

public static class ByRefExample
{
    public static void Main()
    {
        var value = 20;
        Console.WriteLine("In Main, value = {0}", value);
        ModifyValue(ref value);
        Console.WriteLine("Back in Main, value = {0}", value);
    }

    private static void ModifyValue(ref int i)
    {
        i = 30;
        Console.WriteLine("In ModifyValue, parameter value = {0}", i);
        return;
    }
}
// The example displays the following output:
//      In Main, value = 20
//      In ModifyValue, parameter value = 30
//      Back in Main, value = 30

Başvuru parametreleri tarafından kullanılan yaygın bir desen, değişkenlerin değerlerini değiştirmeyi içerir. Bir metota referansla iki değişken geçirirsiniz ve metot bunların içeriklerini değiştirir. Aşağıdaki örnek tamsayı değerlerini değiştirir.


public static class RefSwapExample
{
    static void Main()
    {
        int i = 2, j = 3;
        Console.WriteLine($"i = {i}  j = {j}");

        Swap(ref i, ref j);

        Console.WriteLine($"i = {i}  j = {j}");
    }

    static void Swap(ref int x, ref int y) =>
        (y, x) = (x, y);
}
// The example displays the following output:
//      i = 2  j = 3
//      i = 3  j = 2

Başvuru türünde bir parametre geçirmek, tek tek öğelerinin veya alanlarının değeri yerine başvurunun kendisinin değerini değiştirmenize olanak tanır.

Parametre koleksiyonları

Bazen, yönteminize kaç parametre gireceğinizi tam olarak belirtmek zorunda kalmanız kısıtlayıcı olabilir. Parametrenin params parametre koleksiyonu olduğunu belirtmek için anahtar sözcüğünü kullanarak yönteminizin değişken sayıda bağımsız değişkenle çağrılmasına izin verirsiniz. anahtar sözcüğüyle params etiketlenen parametre bir koleksiyon türü olmalı ve yöntemin parametre listesindeki son parametre olmalıdır.

Çağıran daha sonra parametresi için params dört yoldan biriyle yöntemini çağırabilir:

İstenen öğe sayısını içeren uygun türde bir koleksiyon geçirerek. Örnek, derleyicinin uygun bir koleksiyon türü oluşturması için bir koleksiyon ifadesi kullanır.
Uygun türde bağımsız değişkenlerin virgülle ayrılmış listesini yönteme geçirerek. Derleyici uygun koleksiyon türünü oluşturur.
geçirerek null.
Parametre koleksiyonuna bir bağımsız değişken sağlamamak.

Aşağıdaki örnek, bir parametre koleksiyonundaki tüm ünlüleri döndüren adlı GetVowels bir yöntemi tanımlar. yöntemi, Main yöntemini çağırmanın dört yolunu da gösterir. Çağıranların değiştiriciyi içeren params parametreler için herhangi bir bağımsız değişken sağlaması gerekmez. Bu durumda parametresi boş bir koleksiyondur.

static class ParamsExample
{
    static void Main()
    {
        string fromArray = GetVowels(["apple", "banana", "pear"]);
        Console.WriteLine($"Vowels from collection expression: '{fromArray}'");

        string fromMultipleArguments = GetVowels("apple", "banana", "pear");
        Console.WriteLine($"Vowels from multiple arguments: '{fromMultipleArguments}'");

        string fromNull = GetVowels(null);
        Console.WriteLine($"Vowels from null: '{fromNull}'");

        string fromNoValue = GetVowels();
        Console.WriteLine($"Vowels from no value: '{fromNoValue}'");
    }

    static string GetVowels(params IEnumerable<string>? input)
    {
        if (input == null || !input.Any())
        {
            return string.Empty;
        }

        char[] vowels = ['A', 'E', 'I', 'O', 'U'];
        return string.Concat(
            input.SelectMany(
                word => word.Where(letter => vowels.Contains(char.ToUpper(letter)))));
    }
}

// The example displays the following output:
//     Vowels from array: 'aeaaaea'
//     Vowels from multiple arguments: 'aeaaaea'
//     Vowels from null: ''
//     Vowels from no value: ''

C# 13'e params geçmeden önce değiştirici yalnızca tek boyutlu bir diziyle kullanılabilir.

İsteğe bağlı parametreler ve bağımsız değişkenler

Yöntem tanımı, parametrelerinin gerekli olduğunu veya isteğe bağlı olduğunu belirtebilir. Varsayılan olarak parametreler gereklidir. İsteğe bağlı parametreler, parametrenin varsayılan değeri yöntem tanımına eklenerek belirtilir. yöntemi çağrıldığında, isteğe bağlı bir parametre için bağımsız değişken sağlanmazsa, bunun yerine varsayılan değer kullanılır.

Parametrenin varsayılan değerini aşağıdaki ifade türlerinden biriyle atarsınız:

Bir sabit, örneğin bir dize veya sayı.
form default(SomeType)ifadesi; burada SomeType bir değer türü veya başvuru türü olabilir. Bu bir başvuru türüyse, null belirtilmesiyle etkili bir şekilde aynıdır. Derleyici, parametrenin bildiriminden türü çıkarabildiği için literal değeri kullanabilirsiniz.
formunun new ValType()ifadesi, burada ValType bir değer türüdür. Bu ifade, değer tipinin aslında tipin bir üyesi olmayan örtük parametresiz kurucusunu çağırır.

Not

Form new ValType() ifadesi bir değer türünün açıkça tanımlanmış parametresiz oluşturucuyu çağırdığında, varsayılan parametre değerinin derleme zamanı sabiti olması gerektiğinden derleyici bir hata oluşturur. Varsayılan parametre değerini sağlamak için default(ValType) ifadesini veya default değişmez değerini kullanın. Parametresiz oluşturucular hakkında daha fazla bilgi için Yapı türleri makalesinin Yapı başlatma ve varsayılan değerler bölümüne bakın.

Bir yöntem hem gerekli hem de isteğe bağlı parametreler içeriyorsa, isteğe bağlı parametreler tüm gerekli parametrelerden sonra parametre listesinin sonunda tanımlanır.

Aşağıdaki örnek, ExampleMethodbir gerekli ve iki isteğe bağlı parametresi olan bir yöntemi tanımlar.

public class Options
{
    public void ExampleMethod(int required, int optionalInt = default,
                              string? description = default)
    {
        var msg = $"{description ?? "N/A"}: {required} + {optionalInt} = {required + optionalInt}";
        Console.WriteLine(msg);
    }
}

Çağıranın, bağımsız değişkenin sağlandığı son isteğe bağlı parametreye kadar tüm isteğe bağlı parametreler için bir bağımsız değişken sağlaması gerekir. ExampleMethod yönteminde, örneğin, eğer çağıran, description parametresi için bir bağımsız değişken sağlarsa, optionalInt parametresi için de bir bağımsız değişken sağlaması gerekir. opt.ExampleMethod(2, 2, "Addition of 2 and 2"); geçerli bir yöntem çağrısıdır; opt.ExampleMethod(2, , "Addition of 2 and 0"); bir "Eksik bağımsız değişken" derleyici hatası oluşturur.

Adlandırılmış bağımsız değişkenler veya konumsal ve adlandırılmış bağımsız değişkenlerin birleşimi kullanılarak bir yöntem çağrılırsa, çağıran yöntem çağrısındaki son konumsal bağımsız değişkeni izleyen bağımsız değişkenleri atlayabilir.

Aşağıdaki örnekte ExampleMethod metodu üç kez çağrılır. İlk iki yöntem çağrısı konumsal argümanları kullanır. İlki isteğe bağlı bağımsız değişkenlerin ikisini de atlar, ikincisi ise son bağımsız değişkeni atlar. Üçüncü yöntem çağrısı, gerekli parametre için konumsal bir bağımsız değişken sağlar, ancak description bağımsız değişkenini atlayarak optionalInt parametreye bir değer sağlamak için adlandırılmış bir bağımsız değişken kullanır.

public static class OptionsExample
{
    public static void Main()
    {
        var opt = new Options();
        opt.ExampleMethod(10);
        opt.ExampleMethod(10, 2);
        opt.ExampleMethod(12, description: "Addition with zero:");
    }
}
// The example displays the following output:
//      N/A: 10 + 0 = 10
//      N/A: 10 + 2 = 12
//      Addition with zero:: 12 + 0 = 12

İsteğe bağlı parametrelerin kullanılması aşırı yükleme çözümlemesini veya C# derleyicisinin yöntem çağrısı için hangi aşırı yüklemeyi çağırılacağını belirleme biçimini aşağıdaki gibi etkiler:

Bir öğe, parametrelerinin her biri adı veya konumuyla tek bir bağımsız değişkene karşılık geliyorsa çalıştırılma adayıdır. Ayrıca, verilen argüman parametrenin türüne dönüştürülebilir.
Birden fazla aday bulunursa, açıkça belirtilen bağımsız değişkenlere uygulanan tercih edilen dönüştürmeler için aşırı yükleme çözümleme kuralları geçerli olur. İsteğe bağlı parametreler için girilmeyen bağımsız değişkenler yoksayılır.
İki aday eşit derecede iyi olarak değerlendirilirse, çağrıda bağımsız değişkenlerin atlandığı isteğe bağlı parametreleri olmayan aday tercih edilir.

Dönüş değerleri

Yöntemler çağırana bir değer döndürebilir. Dönüş türü (yöntem adından önce listelenen tür) değilse void, yöntemi anahtar sözcüğünü return kullanarak değeri döndürebilir. Anahtar sözcüğünü ve return ardından dönüş türüyle eşleşen bir değişken, sabit veya ifade içeren bir deyim, bu değeri yöntem çağırana döndürür. Nonvoid dönüş türüne sahip yöntemlerin bir değer döndürmek için return anahtar sözcüğünü kullanmaları gereklidir. anahtar return sözcüğü, yönteminin yürütülmesini de durdurur.

Dönüş türü void ise, değeri olmayan bir return deyimi yine de yöntemin yürütülmesini durdurmada faydalıdır. return anahtar sözcüğü olmadan, yöntem kod bloğunun sonuna ulaştığında yürütmeyi durdurur.

Örneğin, bu iki yöntem tamsayıları döndürmek için anahtar sözcüğünü return kullanır:

class SimpleMath
{
    public int AddTwoNumbers(int number1, int number2) =>
        number1 + number2;

    public int SquareANumber(int number) =>
        number * number;
}

Yukarıdaki örnekler, gövdeli ifade üyeleridir. Gövdeli ifade üyeleri, ifade tarafından döndürülen değeri döndürür.

Yöntemlerinizi deyim gövdesi ve return deyimiyle tanımlamayı da seçebilirsiniz:

class SimpleMathExtension
{
    public int DivideTwoNumbers(int number1, int number2)
    {
        return number1 / number2;
    }
}

Yöntemden döndürülen bir değeri kullanmak için dönüş değerini bir değişkene atayabilirsiniz:

int result = obj.DivideTwoNumbers(6,2);
// The result is 3.
Console.WriteLine(result);

Çağıran yöntem, aynı türdeki bir değerin yeterli olacağı her yerde yöntem çağrısının kendisini de kullanabilir. Örneğin, aşağıdaki iki kod örneği aynı hedefi gerçekleştirir:

int result = obj.AddTwoNumbers(1, 2);
result = obj.SquareANumber(result);
// The result is 9.
Console.WriteLine(result);

result = obj.SquareANumber(obj.AddTwoNumbers(1, 2));
// The result is 9.
Console.WriteLine(result);

Bazen yönteminizin tek bir değerden daha fazlasını döndürmesini istersiniz. Birden çok değer döndürmek için küme türlerini ve küme değişmez değerlerini kullanırsınız. Tuple türü, tuple'ın öğelerinin veri türlerini tanımlar. Demet değişmezleri, döndürülen demetin gerçek değerlerini sağlar. Aşağıdaki örnekte, (string, string, string, int) ile GetPersonalInfo yöntemi tarafından döndürülen tanımlama grubu türü tanımlanır. İfade (per.FirstName, per.MiddleName, per.LastName, per.Age), kartıl dizisi literalidir; yöntem, bir PersonInfo nesnesinin ilk, orta ve soyadını, yaşıyla birlikte döndürür.

public (string, string, string, int) GetPersonalInfo(string id)
{
    PersonInfo per = PersonInfo.RetrieveInfoById(id);
    return (per.FirstName, per.MiddleName, per.LastName, per.Age);
}

Çağıran daha sonra aşağıdaki kodu kullanarak döndürülen demeti kullanabilir.

var person = GetPersonalInfo("111111111");
Console.WriteLine($"{person.Item1} {person.Item3}: age = {person.Item4}");

Tuple türü tanımındaki tuple öğelerine de isim verilebilir. Aşağıdaki örnekte, yönteminin GetPersonalInfo adlandırılmış öğeleri kullanan alternatif bir sürümü gösterilmektedir:

public (string FName, string MName, string LName, int Age) GetPersonalInfo(string id)
{
    PersonInfo per = PersonInfo.RetrieveInfoById(id);
    return (per.FirstName, per.MiddleName, per.LastName, per.Age);
}

Daha önce GetPersonalInfo yöntemine yapılan çağrı daha sonra aşağıdaki gibi değiştirilebilir:

var person = GetPersonalInfo("111111111");
Console.WriteLine($"{person.FName} {person.LName}: age = {person.Age}");

Bir yöntem bir diziyi parametre olarak alır ve tek tek öğelerin değerini değiştirirse, yöntemin diziyi döndürmesi gerekmez. C# tüm başvuru türlerini değere göre aktarır ve dizi başvurusunun değeri diziyi gösteren işaretçidir. Aşağıdaki örnekte, values yönteminde yapılan DoubleValues dizisinin içeriğindeki değişiklikler, diziye başvurusu olan herhangi bir kod tarafından gözlemlenebilir.


public static class ArrayValueExample
{
    static void Main()
    {
        int[] values = [2, 4, 6, 8];
        DoubleValues(values);
        foreach (var value in values)
        {
            Console.Write("{0}  ", value);
        }
    }

    public static void DoubleValues(int[] arr)
    {
        for (var ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
        {
            arr[ctr] *= 2;
        }
    }
}
// The example displays the following output:
//       4  8  12  16

Genişletme yöntemleri

Normalde, mevcut bir türe yöntem eklemenin iki yolu vardır:

Bu türün kaynak kodunu değiştirin. Yöntemi desteklemek için özel veri alanları da eklerseniz, kaynağı değiştirmek kırıcı bir değişikliğe yol açar.
Türetilmiş bir sınıfta yeni yöntemi tanımlayın. Bir yöntem, yapılar ve numaralandırmalar gibi diğer türler için devralma kullanılarak bu şekilde eklenemez. Korumalı bir sınıfa bir yöntemi "eklemek" için de kullanılamaz.

Uzantı üyeleri, türün kendisini değiştirmeden veya devralınan bir türdeki yeni yöntemi uygulamadan mevcut bir türe üye eklemenize olanak sağlar. Uzantı üyesinin, genişlettiği türle aynı derlemede bulunması gerekmez. Uzantı yöntemini, türün tanımlı bir üyesiymiş gibi çağırırsınız.

Daha fazla bilgi için bkz . Uzantı üyeleri.

Asenkron Yöntemler

Asenkron özelliğini kullanarak, açık geri çağırmalar kullanmadan veya kodunuzu birden çok yönteme ya da lambda ifadesine elle bölmeden asenkron yöntemleri çağırabilirsiniz.

Bir metodu async değiştirici ile işaretlerseniz, metotta await işlecini kullanabilirsiniz. Denetim, zamansal uyumsuzluk yöntemi içinde bir await ifadeye ulaştığında, eğer beklenen görev tamamlanmamışsa denetim çağırana geri döner ve beklenen görev tamamlanana kadar await anahtar kelimesiyle belirtilen yöntem içindeki ilerleme askıya alınır. Görev tamamlandığında, işlem yöntemde devam edebilir.

Not

Eşzamansız yöntem, ya henüz tamamlanmamış olan ilk beklenen nesneyle karşılaştığında ya da eşzamansız yöntemin sonuna ulaştığında, hangisi daha önce gerçekleşirse, çağırana geri döner.

Zaman uyumsuz bir yöntem genellikle Task<TResult>, Task, IAsyncEnumerable<T> veya void türünde bir dönüşe sahiptir. Öncelikle bir void dönüş türünün gerekli olduğu durumlarda olay işleyicilerini tanımlamak için void dönüş türü kullanılır. void döndüren bir zaman uyumsuz yöntem beklenemez ve void döndüren bir yöntemi çağıran, bu yöntemin attığı özel durumları yakalayamaz. Zaman uyumsuz bir yöntem herhangi bir görev benzeri dönüş türüne sahip olabilir.

Aşağıdaki örnekte, DelayAsync bir tamsayı döndüren bir dönüş deyimine sahip zaman uyumsuz bir metottur. Zaman uyumsuz bir metod olduğundan, metod bildiriminin Task<int> dönüş türü olmalıdır. Çünkü dönüş türü Task<int>, await ifadesinin DoSomethingAsync içinde değerlendirilmesi, aşağıdaki int result = await delayTask deyiminin gösterdiği gibi bir tamsayı ürettiğini belirtir.

class Program
{
    static Task Main() => DoSomethingAsync();

    static async Task DoSomethingAsync()
    {
        Task<int> delayTask = DelayAsync();
        int result = await delayTask;

        // The previous two statements may be combined into
        // the following statement.
        //int result = await DelayAsync();

        Console.WriteLine($"Result: {result}");
    }

    static async Task<int> DelayAsync()
    {
        await Task.Delay(100);
        return 5;
    }
}
// Example output:
//   Result: 5

Zaman uyumsuz bir yöntem herhangi bir in, ref veya out parametresini bildiremez, ancak bu tür parametreleri olan yöntemleri çağırabilir.

Asenkron yöntemler hakkında daha fazla bilgi için bkz Asenkron programlama: async ve await ile ve Asenkron dönüş türleri.

İfade gövdeli üyeler

Bir ifadenin sonucuyla hemen döndürülen veya yöntemin gövdesi olarak tek bir deyimi olan yöntem tanımları yaygındır. Bu tür yöntemleri => kullanarak tanımlamak için bir söz dizimi kısayolu vardır.

public Point Move(int dx, int dy) => new Point(x + dx, y + dy);
public void Print() => Console.WriteLine(First + " " + Last);
// Works with operators, properties, and indexers too.
public static Complex operator +(Complex a, Complex b) => a.Add(b);
public string Name => First + " " + Last;
public Customer this[long id] => store.LookupCustomer(id);

Yöntem void döndürüyor veya zaman uyumsuz bir yöntemse, yöntemin gövdesi bir ifade ifadesi (lambda'larla aynı şekilde) olmalıdır. Özellikler ve dizin oluşturucular salt okunur olmalı ve erişimci anahtar sözcüğünü get kullanmamalısınız.

Yineleyiciler

Yineleyici, liste veya dizi gibi bir koleksiyon üzerinde özel bir yineleme gerçekleştirir. Yineleyici, her öğeyi birer birer döndürmek için yield return deyimini kullanır. Bir yield return deyime ulaşıldığında, çağıranın dizideki bir sonraki öğeyi isteyebilmesi için geçerli konum hatırlanır.

Yineleyicinin dönüş türü , , IEnumerable, IEnumerable<T>IAsyncEnumerable<T>veya IEnumeratorolabilirIEnumerator<T>.

Daha fazla bilgi için bkz . Yineleyiciler.

Aracılığıyla paylaş