C'deki Yöntemler#
Yöntem, bir dizi deyim içeren bir kod bloğudur. Program, yöntemini ç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 konuda 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 , recordveya struct belirterek bildirilirclass:
- veya
privategibipublicisteğe bağlı bir erişim düzeyi. Varsayılan değer:private. - veya
sealedgibiabstractisteğe bağlı değiştiriciler. - Dönüş değeri veya
voidyöntemin değeri yok. - 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 türlerine göre ayırt edilir.
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 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 yöntemi i Square adlı tek bir parametre int içerir. İlk yöntem çağrısı yöntemine Square num adlı türünde int bir değişken geçirir; ikinci, sayısal sabit; üçüncü yöntem ise bir ifadedir.
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;
}
}
Kullanılan konumsal bağımsız değişkenlerin en yaygın yöntem çağırma biçimi; bağımsız değişkenleri yöntem parametreleriyle aynı sırada sağlar. 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 parametresinin miles değeri olur. İkincisi parametresinin speed 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 {0}", 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ı ve ardından iki nokta üst üste (":") ve bağımsız değişkenini belirtirsiniz. Yöntemin bağımsız değişkenleri, gerekli tüm bağımsız değişkenler mevcut olduğu sürece herhangi bir sırada görünebilir. Aşağıdaki örnek, yöntemini çağırmak TestMotorcycle.Drive için 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(miles: 170, speed: 60);
Console.WriteLine("Travel time: approx. {0} hours", travelTime);
}
}
// 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 yöntemini çağırır TestMotorcycle.Drive .
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 sınıfından devraldığındanObject, tüm türler , GetType()ve ToString()gibi Equals(Object)ü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. Equals Ancak yöntemi sınıfında tanımlanmamıştırPerson; öğesinden Objectdevralını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: {0}", 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, yöntemini geçersiz kılması dışında öncekine Equals(Object) benzer. (İki yöntemin GetHashCode() tutarlı sonuçlar sağlaması amaçlandığından 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: {0}", 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
Başvuru türündeki bir nesne bir yönteme değere göre geçirildiğinde, nesneye başvuru değere göre 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 nesne örneği oluşturur, alanına 44 value atar ve nesnesini yöntemine ModifyObject geçirir. Bu örnek temelde önceki örnekle aynı şeyi yapar; bir bağımsız değişkeni değere göre bir yönteme geçirir. Ancak başvuru türü kullanıldığından sonuç farklıdır. alanında yapılan ModifyObject obj.value değişiklik, örnekte gösterildiği gibi yöntemindeki Main bağımsız değişkeninin rtalanını da 33 olarak değiştirirvalue.
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 başvuruya göre geçirme
Bir yöntemdeki bağımsız değişkenin değerini değiştirmek ve denetim çağıran yönteme döndüğünde bu değişikliği yansıtmak istediğinizde, parametreyi başvuruya göre geçirirsiniz. Bir parametreyi başvuruya göre geçirmek için veya out anahtar sözcüğünü ref kullanırsınız. Ayrıca, anahtar sözcüğünü kullanarak kopyalamayı önlemek ancak yine de değişiklikleri önlemek için başvuruya in göre bir değer geçirebilirsiniz.
Aşağıdaki örnek, değerin yöntemine başvuruyla geçirilmesi dışında önceki örnekle ModifyValue aynıdır. 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 yönteme başvuruya göre iki değişken geçirirsiniz ve yöntemi bunların içeriğini 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 = {0} j = {1}", i, j);
Swap(ref i, ref j);
Console.WriteLine("i = {0} j = {1}", i, 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ü parametresi geçirmek, tek tek öğelerinin veya alanlarının değeri yerine başvurunun değerini değiştirmenize olanak tanır.
Parametre koleksiyonları
Bazen, yönteminiz için tam bağımsız değişken sayısını belirtmeniz zorunluluğu 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 bağımsız değişken sağlamayarak.
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:
Sabit değer dizesi veya sayı gibi bir sabit.
form
default(SomeType)ifadesi; buradaSomeTypebir değer türü veya başvuru türü olabilir. Bu bir başvuru türüyse, etkili bir şekilde belirtilmesiylenullaynıdır. Derleyici, parametrenindefaultbildiriminden türü çıkaraabildiği için değişmez değeri kullanabilirsiniz.formunun
new ValType()ifadesi, buradaValTypebir değer türüdür. Bu ifade, değer türünün türün gerçek bir üyesi olmayan örtük parametresiz oluşturucuyu çağırır.Not
C# 10 ve sonraki sürümlerde, formun
new ValType()bir 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.default(ValType)Varsayılan parametre değerini sağlamak için ifadesini veyadefaultdeğ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. Örneğin yönteminde ExampleMethod çağıran parametre için description bir bağımsız değişken sağlarsa, parametre için optionalInt 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 "Bağımsız değişken eksik" 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 yöntemi üç kez çağrılır ExampleMethod . İlk iki yöntem çağrısı konumsal bağımsız değişkenleri 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 bağımsız değişkeni atlarken optionalInt parametreye bir değer sağlamak için description 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:
- Yöntem, dizin oluşturucu veya oluşturucu, parametrelerinin her biri ada veya konuma göre tek bir bağımsız değişkene karşılık geliyorsa ve bu bağımsız değişken parametrenin türüne dönüştürülebiliyorsa yürütme adayıdır.
- Birden fazla aday bulunursa, açıkça belirtilen bağımsız değişkenlere tercih edilen dönüştürmeler için aşırı yükleme çözümleme kuralları uygulanır. İsteğe bağlı parametreler için atlanan bağımsız değişkenler yoksayılır.
- İki aday eşit derecede iyi olarak değerlendirilirse tercih, çağrıda bağımsız değişkenlerin atlandığı isteğe bağlı parametreleri olmayan bir adaya gider.
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. Bir değer döndürmek için anahtar sözcüğünü return kullanmak için, nonvoid dönüş türüne sahip yöntemler gereklidir. anahtar return sözcüğü, yönteminin yürütülmesini de durdurur.
Dönüş türü ise void, değeri olmayan bir return deyim yine de yönteminin yürütülmesini durdurmak için yararlı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 SimpleMathExtnsion
{
public int DivideTwoNumbers(int number1, int number2)
{
return number1 / number2;
}
}
Bir yöntemden döndürülen bir değeri kullanmak için çağıran yöntem, aynı türdeki bir değerin yeterli olduğu her yerde yöntem çağrısının kendisini kullanabilir. Dönüş değerini bir değişkene de atayabilirsiniz. Örneğin, aşağıdaki üç 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);
result = obj2.DivideTwoNumbers(6,2);
// The result is 3.
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 tanımlama grubu türlerini ve tanımlama grubu değişmez değerlerini kullanırsınız. Tanımlama grubu türü, tanımlama grubu öğelerinin veri türlerini tanımlar. Tanımlama grubu değişmez değerleri, döndürülen tanımlama grubunun gerçek değerlerini sağlar. Aşağıdaki örnekte, (string, string, string, int) yöntemi tarafından GetPersonalInfo döndürülen tanımlama grubu türünü tanımlar. İfade (per.FirstName, per.MiddleName, per.LastName, per.Age) tanımlama grubu değişmez değeridir; yöntem bir nesnenin yaş PersonInfo değeriyle birlikte ilk, orta ve aile adını 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 tanımlama grubu kullanabilir:
var person = GetPersonalInfo("111111111");
Console.WriteLine($"{person.Item1} {person.Item3}: age = {person.Item4}");
Adlar, tanımlama grubu türü tanımındaki tanımlama grubu öğelerine de atanabilir. 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 sonra yöntemine yapılan GetPersonalInfo önceki çağrı 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 geçirir ve dizi başvurusunun değeri dizinin işaretçisidir. Aşağıdaki örnekte, yönteminde yapılan dizinin içeriğinde values DoubleValues yapılan 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ğın değiştirilmesi hataya neden olan bir değişiklik oluşturur.
- 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ı yöntemleri, türün kendisini değiştirmeden veya devralınan bir türdeki yeni yöntemi uygulamadan mevcut bir türe bir yöntemi "eklemenize" olanak sağlar. Uzantı yönteminin genişletici türüyle aynı derlemede bulunması da gerekmez. Uzantı yöntemini, türün tanımlı bir üyesiymiş gibi çağırırsınız.
Daha fazla bilgi için bkz . Uzantı Yöntemleri.
Zaman Uyumsuz Yöntemler
Zaman uyumsuz özelliği kullanarak, açık geri çağırmalar kullanmadan veya kodunuzu birden çok yönteme veya lambda ifadesine el ile bölmeden zaman uyumsuz yöntemleri çağırabilirsiniz.
Bir yöntemi zaman uyumsuz değiştirici ile işaretlerseniz yönteminde await işlecini kullanabilirsiniz. Denetim zaman uyumsuz yöntemdeki bir await ifadeye ulaştığında, beklenen görev tamamlanmazsa denetim çağırana geri döner ve beklenen görev tamamlanana kadar anahtar sözcüğüyle await yöntemindeki ilerleme askıya alınır. Görev tamamlandığında, yürütme yönteminde devam edebilir.
Not
Zaman uyumsuz yöntem, henüz tamamlanmamış ilk beklenen nesneyle karşılaştığında veya zaman uyumsuz yöntemin sonuna ulaştığında (hangisi önce gerçekleşirse) çağırana geri döner.
Zaman uyumsuz yöntem genellikle , , TaskIAsyncEnumerable<T>veya voiddönüş türüne Task<TResult>sahiptir. Dönüş void türü öncelikli olarak bir dönüş türünün gerekli olduğu void olay işleyicilerini tanımlamak için kullanılır. Döndüren void zaman uyumsuz bir yöntem beklenemez ve void-dönüş yöntemini çağıran 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 tamsayı döndüren bir dönüş deyimine sahip zaman uyumsuz bir yöntemdir. Zaman uyumsuz bir yöntem olduğundan, yöntem bildiriminin Task<int>dönüş türü olmalıdır. Dönüş türü olduğundan Task<int>, içindeki ifadenin await DoSomethingAsync değerlendirilmesi, aşağıdaki int result = await delayTask deyimin gösterdiği gibi bir tamsayı oluşturur.
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 yöntem in, ref veya out parametrelerini bildiremez, ancak bu tür parametreleri olan yöntemleri çağırabilir.
Zaman uyumsuz yöntemler hakkında daha fazla bilgi için bkz . Async ve await ile zaman uyumsuz programlama ve Zaman uyumsuz 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ın olarak görülür. kullanarak bu tür yöntemleri =>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 döndürüyorsa void veya zaman uyumsuz bir yöntemse, yöntemin gövdesi bir deyim ifadesi olmalıdır (lambda'larla aynı şekilde). Özellikler ve dizin oluşturucular için salt okunur olmalıdır ve erişimci anahtar sözcüğünü get kullanmazsı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 sıradaki sonraki öğeyi isteyebilmesi için geçerli konum hatırlanır.
Yineleyicinin dönüş türü , , IEnumerable<T>, IAsyncEnumerable<T>IEnumeratorveya IEnumerator<T>olabilirIEnumerable.
Daha fazla bilgi için bkz . Yineleyiciler.
