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. Main yöntemi her C# uygulamasının giriş noktasıdır ve program başlatıldığında ortak dil çalışma zamanı (CLR) tarafından çağrılır.
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 edilmelidir.
Yöntem çağırma
Yöntemler örnek veya statik olabilir. Örnek yöntemini çağırmak için bir nesne örneği oluşturmanız ve bu nesne üzerinde yöntemini çağırmanı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, ikincisi parametrenin 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öntemin imzası ile 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ğere göre 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 ModifyObjectobj.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 öncekiyle aynıdır, ancak değer yöntemine ModifyValue başvuru ile geçirilir. 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 dizileri
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 dizisi 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 dizi türü olmalı ve yöntemin parametre listesindeki son parametre olmalıdır.
Çağıran dört yoldan biriyle yöntemini çağırabilir:
- İstenen öğe sayısını içeren uygun türde bir dizi geçirerek.
- Uygun türde bağımsız değişkenlerin virgülle ayrılmış listesini yönteme geçirerek.
- geçirerek
null. - Parametre dizisine bağımsız değişken sağlamayarak.
Aşağıdaki örnek, bir parametre dizisinden 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 dizidir.
static class ParamsExample
{
static void Main()
{
string fromArray = GetVowels(["apple", "banana", "pear"]);
Console.WriteLine($"Vowels from array: '{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 string[]? input)
{
if (input == null || input.Length == 0)
{
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: ''
İ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ğeri aşağıdaki ifade türlerinden biri tarafından atanmalıdır:
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, değer türünün türün gerçek bir üyesi olmayan örtük parametresiz oluşturucusunu ç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);
}
}
Birden çok isteğe bağlı bağımsız değişken içeren bir yöntem konumsal bağımsız değişkenler kullanılarak çağrılırsa, çağıranın ilk parametreden bağımsız değişkenin sağlandığı son parametreye kadar tüm isteğe bağlı parametreler için bir bağımsız değişken sağlaması gerekir. Örneğin yöntemi söz konusu ExampleMethod olduğunda, ç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ğlamalıdır. 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ı tarafından çağrılacak belirli bir aşırı yüklemeyi belirleme biçimini aşağıdaki gibi etkiler:
- Yöntem, dizin oluşturucu veya oluşturucu, parametrelerinin her biri isteğe bağlıysa veya ada veya konuma göre çağıran deyimdeki tek bir bağımsız değişkene karşılık geliyorsa yürütme adayıdır ve bu bağımsız değişken parametre türüne dönüştürülebilir.
- 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. Bu, daha az parametreye sahip adaylar için aşırı yükleme çözümlemesinde genel tercihin bir sonucudur.
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üğü 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 geçersiz olmayan 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;
}
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 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);
Bu örnekte result, bir değeri depolamak için yerel değişken kullanmak isteğe bağlıdır. Kodun okunabilirliğine yardımcı olabilir veya yöntemin tüm kapsamı için bağımsız değişkenin özgün değerini depolamanız gerekiyorsa gerekli olabilir.
Bazen yönteminizin tek bir değerden daha fazlasını döndürmesini istersiniz. Bunu, tanımlama grubu türlerini ve tanımlama grubu değişmez değerlerini kullanarak kolayca yapabilirsiniz. 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 PersonInfo nesnenin yaş değeriyle birlikte ilk, orta ve soyadı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 döndürülen tanımlama grubu aşağıdaki gibi bir kodla 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önteme bağımsız değişken olarak bir dizi geçirilirse ve tek tek öğelerin değerini değiştirirse, iyi stil veya işlevsel değer akışı için bunu yapmayı seçebilirsiniz, ancak yöntemin diziyi döndürmesi gerekli değildir. Bunun nedeni C# öğesinin tüm başvuru türlerini değere göre geçirmesi ve dizi başvurusunun değerinin dizinin işaretçisi olmasıdır. Aşağıdaki örnekte, yönteminde yapılan dizinin içeriğinde valuesDoubleValues 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. Türün kaynak koduna sahip değilseniz bunu yapamazsınız. Yöntemi desteklemek için özel veri alanları da eklerseniz bu, hataya neden olan bir değişiklik haline gelir.
- 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 awaitDoSomethingAsync 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ının olması yaygın bir durumdı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.
Ayrıca bkz.
Geri Bildirim
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz. https://aka.ms/ContentUserFeedback.
Gönderin ve geri bildirimi görüntüleyin