Eğitim
Modül
Değer döndüren C# yöntemleri oluşturma - Training
Bu modülde return anahtar sözcüğü ve yöntemlerden döndürülen değerler yer alır.
Bu tarayıcı artık desteklenmiyor.
En son özelliklerden, güvenlik güncelleştirmelerinden ve teknik destekten faydalanmak için Microsoft Edge’e yükseltin.
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öntemler , class
veya record
belirterek bildirilirstruct
:
public
gibi private
isteğe bağlı bir erişim düzeyi. Varsayılan değer: private
.abstract
gibi sealed
isteğe bağlı değiştiriciler.void
yöntemin değeri yok.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ö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ı int
tek bir parametre içerir. İlk yöntem çağrısı yöntemine Square
numint
türünde 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);
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 , Equals(Object)ve GetType()gibi ToString()ü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
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.
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 int
bir 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ı SampleRefType
bir 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 value
bağımsız değişkeninin rt
alanını da 33 olarak değiştirirMain
.
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;
}
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 ref
anahtar sözcüğünü out
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.
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:
null
.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.
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; burada SomeType
bir değer türü veya başvuru türü olabilir. Bu bir başvuru türüyse, etkili bir şekilde belirtilmesiyle null
aynıdır. Derleyici, parametrenin default
bildiriminden türü çıkaraabildiği için değişmez değeri kullanabilirsiniz.
formunun new ValType()
ifadesi, burada ValType
bir 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
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.
default(ValType)
Varsayılan parametre değerini sağlamak için 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, ExampleMethod
bir 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 description
parametreye bir değer sağlamak için optionalInt
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ö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
Normalde, mevcut bir türe yöntem eklemenin iki yolu vardır:
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 ö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 , , Task<TResult>Taskveya IAsyncEnumerable<T>dönüş türüne void
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.
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.
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, IEnumerable<T>IAsyncEnumerable<T>veya IEnumeratorolabilirIEnumerator<T>.
Daha fazla bilgi için bkz . Yineleyiciler.
.NET geri bildirimi
.NET, açık kaynak bir projedir. Geri bildirim sağlamak için bir bağlantı seçin:
Eğitim
Modül
Değer döndüren C# yöntemleri oluşturma - Training
Bu modülde return anahtar sözcüğü ve yöntemlerden döndürülen değerler yer alır.