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

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# dilinin birleşik 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 nulldeğeri kullanı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ünde object bir değişken bir değer türüne dönüştürüldüğünde , kutusunun kaldırılmış olduğu söylenir. Daha fazla bilgi için bkz . Kutulama ve Kutu açma.

Dize türü

Tür sıfır string 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. Örnek:

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

Önceki örnekte " True" ve sonra "False" görüntülenir çünkü dizelerin içeriği eşdeğerdir, b ancak a aynı dize örneğine başvurmaz.

+ 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; nesne oluşturulduktan sonra bir dize nesnesinin içeriği 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 b ayrılan bellek ("h" dizesini içerdiğinde) çöp 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 metin 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 karakterinden oluşan bir dizi de ekleyebilirsiniz. Metniniz eklenmiş bir tırnak dizisi gerektiriyorsa, ham dize sabitini 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 tırnak içine alınan 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ırnakları 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 belirler. 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 tırnak karakteriyle başlayıp bitmiyor olabilir:

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ınmış 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ğerini içerebilir. Kaçış dizileri dahil edilir. Aşağıdaki örnekte ters eğik çizgi, \u0066 f harfi ve \n yeni satır için kaçış dizisi \\ kullanılır.

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

Not

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

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

@"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 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 dize değişmez değerine son eki ekleyebilirsiniz. UTF-8 değişmez değerleri nesne olarak ReadOnlySpan<byte> depolanır. UTF-8 dize değişmez ReadOnlySpan<byte>değeri doğal türüdür. 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 sabit değerini bir dizi olarak depolamak için, sabit değeri içeren baytların değiştirilebilir diziye kopyalanması için öğesinin kullanılması ReadOnlySpan<T>.ToArray() gerekir:

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

UTF-8 dize değişmez değerleri derleme zamanı sabitleri değildir; bunlar ç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şkilendirmesiyle 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ürlerinde birçok System.Action ortak temsilci için genel tanımlar sağlanır. 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. Temsilcilerin uygulamaları için bkz. Temsilciler ve Genel Temsilciler. Temsilciler Olaylar için temeldir. Bir temsilci, adlandırılmış veya anonim bir yöntemle ilişkilendirilerek örneklenebilir.

Temsilcinin, uyumlu bir dönüş türüne ve giriş parametrelerine sahip bir yöntem veya lambda ifadesiyle örneği oluşturulmalıdır. Yöntem imzasında izin verilen varyans derecesi hakkında daha fazla bilgi için bkz. Temsilcilerde Varyans. Anonim yöntemlerle kullanım 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 örnekte 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;

C# 9 ile başlayarak, benzer söz dizimi kullanan işlev işaretçilerini bildirebilirsiniz. İşlev işaretçisi, bir temsilci türü örneği oluşturmak ve sanal Invoke yöntemi çağırmak yerine yönergesini 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ürdynamic, tür ifadeleri içeren işlemlerin dynamic çözümlenmediği veya türün derleyici tarafından denetlendiği işlemlerden object farklıdır. Derleyici, işlem hakkındaki bilgileri bir araya 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 deyimlerinin üzerine dyn veya obj üzerine WriteLine getirin. Aşağıdaki kodu IntelliSense'in kullanılabildiği bir düzenleyiciye kopyalayın. IntelliSense için dyndinamik ve nesnesiniobjgö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());
    }
}

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

System.Int32
System.Int32

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

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

ifadesinde bir tamsayı ve bir nesne obj + 3ekleme girişimi için derleyici hatası bildirildi. 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şıttır.

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:

Ayrıca bkz.