Yerleşik başvuru türleri (C# başvurusu)

Makale
11/14/2023

C# birçok yerleşik başvuru türüne sahiptir. .NET kitaplığındaki bir tür için eş anlamlı olan anahtar sözcükleri veya işleçleri vardır.

Nesne türü

Türü object , .NET'te için System.Object bir diğer addır. C# birleştirilmiş tür sisteminde, önceden tanımlanmış ve kullanıcı tanımlı tüm türler, başvuru türleri ve değer türleri, doğrudan veya dolaylı olarak öğesinden System.Objectdevralır. türünde değişkenlere herhangi bir türde objectdeğer atayabilirsiniz. Herhangi bir object değişken, değişmez değeri nullkullanılarak varsayılan değerine atanabilir. Değer türünde bir değişken nesneye dönüştürüldüğünde kutulandığı söylenir. Tür object değişkeni bir değer türüne dönüştürüldüğünde, bu değişkenin kutulanmamış olduğu söylenir. Daha fazla bilgi için bkz . Kutulama ve Kutu açma.

Dize türü

türü string sıfır veya daha fazla Unicode karakterden oluşan bir diziyi temsil eder. string , .NET'te için System.String bir diğer addır.

Bir başvuru türü olsa da string , eşitlik işleçleri == ve != başvuruların değil nesnelerin değerlerini string karşılaştırmak için tanımlanır. Değer tabanlı eşitlik, dize eşitliği testini daha sezgisel hale getirir. Örneğin:

string a = "hello";
string b = "h";
// Append to contents of 'b'
b += "ello";
Console.WriteLine(a == b);
Console.WriteLine(object.ReferenceEquals(a, b));

Dizelerin içeriği eşdeğer olduğundan ve a aynı dize örneğine başvurmadığından, önceki örnekte "True" ve b "False" görüntülenir.

+ işleci dizeleri birleştirir:

string a = "good " + "morning";

Yukarıdaki kod, "günaydın" ifadesini içeren bir dize nesnesi oluşturur.

Dizeler sabittir; bir dize nesnesinin içeriği nesne oluşturulduktan sonra değiştirilemez. Örneğin, bu kodu yazdığınızda, derleyici aslında yeni karakter dizisini tutmak için yeni bir dize nesnesi oluşturur ve bu yeni nesne öğesine batanır. Için ayrılan b bellek ("h" dizesini içerdiğinde), atık toplama için uygundur.

string b = "h";
b += "ello";

işleci, []bir dizenin tek tek karakterlerine salt okunur erişim için kullanılabilir. Geçerli dizin değerleri şu konumdan 0 başlar ve dizenin uzunluğundan küçük olmalıdır:

string str = "test";
char x = str[2];  // x = 's';

Benzer şekilde, işleç bir dizedeki [] her karakteri yinelemek için de kullanılabilir:

string str = "test";

for (int i = 0; i < str.Length; i++)
{
  Console.Write(str[i] + " ");
}
// Output: t e s t

Dize değişmez değerleri

Dize değişmez değerleri türündedir string ve ham, tırnak içine alınmış ve ayrıntılı olmak üzere üç biçimde yazılabilir.

Ham dize değişmez değerleri C# 11'de başlayarak kullanılabilir. Ham dize değişmez değerleri, kaçış dizileri gerektirmeden rastgele metinler içerebilir. Ham dize değişmez değerleri boşluk ve yeni satırlar, eklenmiş tırnak işaretleri ve diğer özel karakterleri içerebilir. Ham dize değişmez değerleri en az üç çift tırnak işareti (""") içine alınır:

"""
This is a multi-line
    string literal with the second line indented.
"""

Hatta üç (veya daha fazla) çift tırnak karakteri içeren bir dizi de ekleyebilirsiniz. Metniniz ekli bir tırnak dizisi gerektiriyorsa, ham dize değişmez değerlerini gerektiği gibi daha fazla tırnak işaretiyle başlatıp sonlandırabilirsiniz:

"""""
This raw string literal has four """", count them: """" four!
embedded quote characters in a sequence. That's why it starts and ends
with five double quotes.

You could extend this example with as many embedded quotes as needed for your text.
"""""

Ham dize değişmez değerleri genellikle eklenen metinden ayrı satırlarda başlangıç ve bitiş tırnak dizilerine sahiptir. Çok satırlı ham dize değişmez değerleri, kendilerine alıntı yapılan dizeleri destekler:

var message = """
"This is a very important message."
""";
Console.WriteLine(message);
// output: "This is a very important message."

Başlangıç ve bitiş tırnak işaretleri ayrı satırlarda olduğunda, açılış teklifini izleyen ve bitiş tırnak işaretinden önceki yeni satırlar son içeriğe dahil değildir. Kapanış tırnak dizisi, dize değişmez değeri için en soldaki sütunu dikte eder. Ham dize değişmez değerlerini genel kod biçimiyle eşleşecek şekilde girintili yapabilirsiniz:

var message = """
    "This is a very important message."
    """;
Console.WriteLine(message);
// output: "This is a very important message."
// The leftmost whitespace is not part of the raw string literal

Bitiş tırnak dizisinin sağındaki sütunlar korunur. Bu davranış, aşağıdaki örnekte gösterildiği gibi JSON, YAML veya XML gibi veri biçimleri için ham dizeleri etkinleştirir:

var json= """
    {
        "prop": 0
    }
    """;

Metin satırlarından herhangi biri kapanış tırnak dizisinin soluna uzanırsa derleyici bir hata verir. Açma ve kapatma tırnak dizileri aynı satırda olabilir ve dize değişmez değeri bir tırnak karakteriyle başlamaz veya bitmez:

var shortText = """He said "hello!" this morning.""";

Çıkış dizesine tırnak karakterleri ve ayraçlar eklemek için ham dize değişmez değerlerini dize ilişkilendirmesiyle birleştirebilirsiniz.

Tırnak içine alınan dize değişmez değerleri çift tırnak içine alınır ("):

"good morning"  // a string literal

Dize değişmez değerleri herhangi bir karakter değişmez değeri içerebilir. Kaçış dizileri dahil edilir. Aşağıdaki örnek, ters eğik çizgi, \u0066 f harfi ve \n yeni satır için kaçış sırasını \\ kullanır.

string a = "\\\u0066\n F";
Console.WriteLine(a);
// Output:
// \f
//  F

Not

Kaçış kodu \udddd (burada dddd dört basamaklı bir sayıdır), U+dddd Unicode karakterini temsil eder. Sekiz basamaklı Unicode kaçış kodları da tanınır: \Udddddddd.

Düz metin dize değişmez değerleri ile @ başlar ve çift tırnak içine alınır. Örneğin:

@"good morning"  // a string literal

Ayrıntılı dizelerin avantajı, kaçış dizilerinin işlenmemiş olmasıdır ve bu da yazmayı kolaylaştırır. Örneğin, aşağıdaki metin tam bir Windows dosya adıyla eşleşir:

@"c:\Docs\Source\a.txt"  // rather than "c:\\Docs\\Source\\a.txt"

@tırnak içine alınmış bir dizeye çift tırnak işareti eklemek için iki kez ekleyin:

@"""Ahoy!"" cried the captain." // "Ahoy!" cried the captain.

UTF-8 dize değişmez değerleri

.NET'teki dizeler UTF-16 kodlaması kullanılarak depolanır. UTF-8, Web protokolleri ve diğer önemli kitaplıklar için standarttır. C# 11'den başlayarak, UTF-8 kodlamasını u8 belirtmek için son eki bir dize değişmez değerine ekleyebilirsiniz. UTF-8 değişmez değerleri nesne olarak ReadOnlySpan<byte> depolanır. UTF-8 dize değişmez değeri doğal türüdür ReadOnlySpan<byte>. UTF-8 dize değişmez değeri kullanmak, aşağıdaki kodda gösterildiği gibi eşdeğerini System.ReadOnlySpan<T>bildirmekten daha net bir bildirim oluşturur:

ReadOnlySpan<byte> AuthWithTrailingSpace = new byte[] { 0x41, 0x55, 0x54, 0x48, 0x20 };
ReadOnlySpan<byte> AuthStringLiteral = "AUTH "u8;

UtF-8 dize değişmez değerini bir dizi olarak depolamak için, sabit değeri içeren baytları değiştirilebilir diziye kopyalamak için komutunun kullanılması ReadOnlySpan<T>.ToArray() gerekir:

byte[] AuthStringLiteral = "AUTH "u8.ToArray();

UTF-8 dize değişmez değerleri derleme zamanı sabitleri değildir; çalışma zamanı sabitleridir. Bu nedenle, isteğe bağlı bir parametre için varsayılan değer olarak kullanılamazlar. UTF-8 dize değişmez değerleri, dize ilişkilendirmesi ile birleştirilemiyor. Belirteci $ ve u8 son eki aynı dize ifadesinde kullanamazsınız.

Temsilci türü

Temsilci türünün bildirimi yöntem imzasına benzer. Bir dönüş değeri ve herhangi bir türde herhangi bir sayıda parametreye sahiptir:

public delegate void MessageDelegate(string message);
public delegate int AnotherDelegate(MyType m, long num);

.NET'te ve System.Func türleri birçok System.Action ortak temsilci için genel tanımlar sağlar. Büyük olasılıkla yeni özel temsilci türleri tanımlamanız gerekmez. Bunun yerine, sağlanan genel türlerin örneklemelerini oluşturabilirsiniz.

A delegate , adlandırılmış veya anonim bir yöntemi kapsüllemek için kullanılabilecek bir başvuru türüdür. Temsilciler C++'taki işlev işaretçilerine benzer; ancak, temsilciler tür açısından güvenli ve güvenlidir. Temsilci uygulamaları için bkz . Temsilciler ve Genel Temsilciler. Temsilciler Olaylar için temel oluşturur. Bir temsilci, adlandırılmış veya anonim bir yöntemle ilişkilendirilerek örneklenebilir.

Temsilci, uyumlu bir dönüş türüne ve giriş parametrelerine sahip bir yöntem veya lambda ifadesiyle örneklenmelidir. Yöntem imzasında izin verilen varyans derecesi hakkında daha fazla bilgi için bkz . Temsilcilerde Varyans. Anonim yöntemlerle kullanmak için temsilci ve onunla ilişkilendirilecek kod birlikte bildirilir.

Çalışma zamanında dahil olan temsilci türleri değişken dönüştürme nedeniyle farklı olduğunda temsilci birleşimi veya kaldırma işlemi çalışma zamanı özel durumuyla başarısız olur. Aşağıdaki örnekte başarısız olan bir durum gösterilmektedir:

Action<string> stringAction = str => {};
Action<object> objectAction = obj => {};
  
// Valid due to implicit reference conversion of
// objectAction to Action<string>, but may fail
// at run time.
Action<string> combination = stringAction + objectAction;

Yeni bir temsilci nesnesi oluşturarak doğru çalışma zamanı türüne sahip bir temsilci oluşturabilirsiniz. Aşağıdaki örnekte, bu geçici çözümün önceki örne nasıl uygulanabileceği gösterilmektedir.

Action<string> stringAction = str => {};
Action<object> objectAction = obj => {};
  
// Creates a new delegate instance with a runtime type of Action<string>.
Action<string> wrappedObjectAction = new Action<string>(objectAction);

// The two Action<string> delegate instances can now be combined.
Action<string> combination = stringAction + wrappedObjectAction;

Benzer söz dizimi kullanan işlev işaretçileri bildirebilirsiniz. İşlev işaretçisi, bir temsilci türü örneği oluşturmak ve sanal Invoke yöntemi çağırmak yerine yönergeyi kullanırcalli.

Dinamik tür

türü, dynamic değişkenin kullanımını ve üyelerine yapılan başvuruların derleme zamanı türü denetimini atladığını gösterir. Bunun yerine, bu işlemler çalışma zamanında çözümlenir. Türü, dynamic Office Otomasyonu API'leri gibi COM API'lerine, IronPython kitaplıkları gibi dinamik API'lere ve HTML Belge Nesne Modeli'ne (DOM) erişimi basitleştirir.

Tür dynamic çoğu durumda tür object gibi davranır. Özellikle, null olmayan tüm ifadeler türüne dynamic dönüştürülebilir. Türü, dynamic tür dynamic ifadeleri object içeren işlemlerin çözümlenmediği veya türün derleyici tarafından denetlendiği durumlardan farklıdır. Derleyici, işlem hakkındaki bilgileri birlikte paketler ve bu bilgiler daha sonra çalışma zamanında işlemi değerlendirmek için kullanılır. İşlemin bir parçası olarak, türündeki dynamic değişkenler türünde objectdeğişkenler halinde derlenir. Bu nedenle, tür dynamic çalışma zamanında değil, yalnızca derleme zamanında var olur.

Aşağıdaki örnek, türünde bir değişken ile türündeki dynamicobjectbir değişkenin karşıtlığını oluşturur. Derleme zamanında her değişkenin türünü doğrulamak için, fare işaretçisini deyimlerin üzerine dyn veya obj üzerine WriteLine getirin. Aşağıdaki kodu IntelliSense'in kullanılabildiği bir düzenleyiciye kopyalayın. IntelliSense için dyn dinamik ve nesnesi obj gösterir.

class Program
{
    static void Main(string[] args)
    {
        dynamic dyn = 1;
        object obj = 1;

        // Rest the mouse pointer over dyn and obj to see their
        // types at compile time.
        System.Console.WriteLine(dyn.GetType());
        System.Console.WriteLine(obj.GetType());
    }
}

WriteLine deyimleri ve objçalışma zamanı türlerini dyn görüntüler. Bu noktada her ikisi de tamsayı türündedir. Aşağıdaki çıktı üretilir:

System.Int32
System.Int32

derleme zamanında ve obj arasındaki dyn farkı görmek için, önceki örnekteki bildirimlerle WriteLine deyimler arasına aşağıdaki iki satırı ekleyin.

dyn = dyn + 3;
obj = obj + 3;

İfadesinde bir tamsayı ve nesne obj + 3ekleme girişimi için bir derleyici hatası bildirilir. Ancak için hata bildirilmemiştir dyn + 3. içeren dyn ifade, türü dyndynamicolduğundan derleme zamanında denetlenmiyor.

Aşağıdaki örnek çeşitli bildirimlerde kullanır dynamic . yöntemi, Main derleme zamanı türü denetimini çalışma zamanı türü denetimiyle de karşıtlık eder.

using System;

namespace DynamicExamples
{
    class Program
    {
        static void Main(string[] args)
        {
            ExampleClass ec = new ExampleClass();
            Console.WriteLine(ec.ExampleMethod(10));
            Console.WriteLine(ec.ExampleMethod("value"));

            // The following line causes a compiler error because ExampleMethod
            // takes only one argument.
            //Console.WriteLine(ec.ExampleMethod(10, 4));

            dynamic dynamic_ec = new ExampleClass();
            Console.WriteLine(dynamic_ec.ExampleMethod(10));

            // Because dynamic_ec is dynamic, the following call to ExampleMethod
            // with two arguments does not produce an error at compile time.
            // However, it does cause a run-time error.
            //Console.WriteLine(dynamic_ec.ExampleMethod(10, 4));
        }
    }

    class ExampleClass
    {
        static dynamic _field;
        dynamic Prop { get; set; }

        public dynamic ExampleMethod(dynamic d)
        {
            dynamic local = "Local variable";
            int two = 2;

            if (d is int)
            {
                return local;
            }
            else
            {
                return two;
            }
        }
    }
}
// Results:
// Local variable
// 2
// Local variable

C# dili belirtimi

Daha fazla bilgi için C# dil belirtiminin aşağıdaki bölümlerine bakın: