C# 9’da Yeni Özelliklere Giriş

 C# 9’da Yeni Özelliklere Giriş
Okunuyor C# 9’da Yeni Özelliklere Giriş

C# bir sonraki sürümü köşeyi dönünce, ve heyecan verici yeni özellikler ile yüklü!

.NET 5’in yakında piyasaya sürülmesiyle – .NET runtimes’ı birleyen sürüm – Microsoft yakın zamanda C# 9’a eklenecek özellikleri duyurdu. C# 9’un son Önizleme sürümü bugün duyurulduğu için, çok da uzak değil.

Bu makalede, C# 9’daki yeni özelliklere ve bunların kodunuzu geliştirmek için nasıl kullanılabileceğini inceeceğiz. Önce ana özelliklere odaklanacağız ve sonlara doğru daha küçük eşlik eden bazı özellikleri tartışacağız. Daha derine dalmak istiyorsanız, Roslyn deposundaki Dil Özelliği Durumu belgesine bir göz atın!

1. Kayıtlar

Kayıtlar, şu anda ve türleri arasında var olan boşluğu kapatır. Sınıflar etrafında geçmek için daha verimli, ancak eşitlik üyelerinin değerleri yerine, temel referans tarafından belirlenir. Structs eşitlik belirlerken değer semantik olsun, ancak etrafında geçti zaman kopyalanmalıdır.classstruct

Çoğu uygulamada nesneler intibak etme eğiliminde olduğundan, değer semantikisi istense bile, bu, çoğu zaman varsayılan eşitlik davranışını uygulamama ve geçersiz kılmama anlamına gelir.class

Kayıtlar değer semantiksahip olarak bu rahatsızlığı hafifletmek , hala referans geçirilirken.

Kayıt olarak görünen sınıflar, tür tanımındaki anahtar sözcük tarafından gösterilir:record

public record Order
{
    public int Id { get; init set; }
    public string Status { get; init set; }
    public bool IsPaid { get; init set; }
}

Normal sınıflar ve kayıtlar arasındaki temel farklardan biri, kayıtların değişmez olması amaçlanmıştır; durumları asla değişmez. Bu nedenle, her kayıt zaman içinde belirli bir noktadabir nesnenin durumunu temsil eder.

Nesnenin durumu değiştiğinde, özgün kaydı doğrudan değiştirmek yerine değişen üyeleri güncelleştirerek kaydın bir kopyasını oluştururuz. Kayıtların nasıl güncelleştirilebildiğini sonraki bölümde inceleyeceğiz.

Kayıtları Güncelleme

Kayıtların değişmez olması amaçlanmıştır. Verilerini mutasyona uğramak yerine, farklı değerlere sahip yeni bir örnek oluşturursunuz. İfade burada devreye giriyor.with

Örneğin, durumu “Teslim Edilen” olarak değişen bir kaydımız olduğunu düşünün, sipariş nesnemizin özelliğini güncelleştirmek yerine, türü yeni bir örnek oluşturur, özgün siparişimizden değerleri kopyalar, ancak durumu güncelleştireceğiz:OrderStatusOrder

var updatedOrder = order with { Status = "Delivered" };

Normal başvuru türlerinin aksine, nesnenin durumu değişmez, yalnızca yeni oluşturulanın durumu – nesne üzerinde çalışan herhangi bir kod önceki değerini gözlemlemez.orderupdatedOrderorder

Bu şekilde, her kayıt belirli bir zamanda bir nesnenin durumunu temsil eder. Bir değer değiştiğinde, yeni bir kayıt oluşturulur. Bu değişmezlik, bir kayıt üzerinde çalışan yöntemlerin, üzerinde çalıştığı verilerin yürütmenin ortasında asla değişmeyeceğine dair garantiye sahip olmasını sağlar.

Eşitlik

Varsayılan olarak, normal sınıflar aynı temel başvuruyupaylaştıklarında eşit olarak kabul edilir. Bu, aynı sınıfın aynı değerleri tutarak iki örnek oluştursanız bile, bunların eşit kabul edilmeyeceğini anlamına gelir.

Bu davranış, sınıfınızı kayıt olarak beyan ettiğinizde değişir. Nesnenin başvurukarşılaştırış yerine, kayıtlar değerle karşılaştırılır. Bu, aynı değerleri tutan iki farklı nesnenin eşit kabul edeceği veya Mads Torgersen’in dediği gibi:

Kayıtlar] kimliklerine göre değil, içerikleriyle tanımlanır.

Neden kayıtlara ihtiyacımız var?

Kayıt şeklinde değişmez türleri inanılmaz derecede yararlıdır nedenleri vardır. Muhtemelen değişmez nesnelerin genel yazılım tasarımı için neden harika olduğu hakkında bir makale yazabilir, ama bu makale için, biz sadece bir kayıt olmanın en çok yarar sınıfların türüne bir göz atacağız.

Veri Aktarımı ve Etkinlikler

İster veri göndererek veya alarak harici bir hizmetle etkileşimde bulunsak, ister yalnızca kendi uygulamamızdaki katmanlar arasında veri aktarımı yapsak, Veri Aktarımı Nesneleri kayıtların parladığı yerin mükemmel bir örneğidir.

Bir veri aktarım nesnesinin amacı, kodun bir bölümünden diğerine veri taşımaktır, bu da onları doğal olarak değişmez yapar. Harici bir sistemden bir siparişin ödendiğini bildiren bir olay aldığımızı varsayalım. Bu olayda herhangi bir değişiklik yapmayacağız – eğer yapsaydık, bu olay meydana gelen olayı artık tam olarak temsil etmez.

Bunun yerine, olayı bir olarak ilan edip amirlerimize iletebiliriz. İşleyicilerimizin her biri daha sonra olayın meydana geldiği gibi temsil edildiğini garanti ederek hiçbir yan etkisi olmadığını garanti eder.record

2. Yalnızca Init Özellikleri

Daha önce, zaman içinde güncelleştirilen yerine kopyalanan değişmez verileri temsil eden kayıtları araştırdık. Yerleşik değişmez veri türlerine sahip olmak dile harika bir ektir, ancak bu nesneleri nasıl anında ani bir şekilde alıyoruz? Tüm verilerini yapıcı argümanlar olarak aktarmak zorunda mıyız? Tam olarak değil. İşte burada sadece init-init özellikleri devreye girsin.

Adından da anlaşılacağı gibi, yalnızca init-özellikleri yalnızca nesne baş harfe döndüğünde ayarlanabilir. Sözdizimi kısadır; özellik ayarlayıcılar için bir değiştirici olarak eklenir:init

public record Order
{
    public int Id { get; init set; }
    public string Status { get; init set; }
    public bool IsPaid { get; init set; }
}

Aramızdakeskin gözlü için, bu önceki bölümde kayıtları örneklemek için kullanılan tam olarak aynı türüdür.

Ayarlayıcı olarak işaretlenmiş bir özellik yalnızca nesne anında atandığında atanabilir:init

var order = new Order
{
    Id = 100,
    Status = "Created",
    IsPaid = false
};

Bu özelliklerden birinin değerini daha sonra değiştirmeye yönelik herhangi bir girişim, örn. derleyici hatasına neden olur.order.Status = "Shipped"

Neden bunlara ihtiyacımız var?

Bir önceki bölümde de belirttiğim gibi, değişmez nesnelerin anlık olarak şu anda c# ile ters bir şekilde ifade edilemez. Daha önce, nesne başharf sözdizimi (örneğin, bir nesneyi anında ayarlarken özellikleri ayarlamanızı sağlar. ) olarak bildirerek, özelliğin ayarlayıcılarının arayanın erişebileceği bir şekilde gerekli dir.new Order { <property assignments> };publicinternal

Doğal olarak, değişmez tipler oluşturduğumuzda ve sınıfımızı dış modifikasyonlara karşı korumak istediğimizde, ayarlayıcılarımızı açıkta bırakmak istemeyiz.

Değişmez türleri bildirmek geleneksel olarak biraz güçlük olmuştur. Yalnızca init özellikleri, değişmez nesneleri daha anlamlı bir şekilde anında anında oluşturmanıza izin vererek, aynı zamanda nesnenizin üyelerini aşırı teşhir etmemenizi sağlayarak bu acının bir kısmını hafifletir.

3. Geliştirilmiş Desen Eşleştirme

C# 7’den beri Microsoft, C#’daki desen eşleştirme desteğini kademeli olarak geliştiriyor. Uygulama larımızın işlediği veriler, CLR türü gibi rasgele uygulama ayrıntıları yerine şekillerine (yani verilerine) göre daha fazla tanımlandığı için, davranışı belirlemek için mantıksal kalıpları beyan etme yeteneğinin artması, dile hoş bir ek olmaktan çok daha fazladır.

C#’ın önceki sürümünde, bir türün özellikleri üzerinde desen eşleştirmeyapmamıza olanak sağlayan yeni bir sözdizimi tanıtıldı:switch

static string Display(object o) => o switch
{
    Point { X: 0, Y: 0 }         => "origin",
    Point { X: var x, Y: var y } => $"({x}, {y})",
    _                            => "unknown"
};

Hayvanat bahçesini ziyaret eden bir bireyin bilet fiyatını belirlemek için desen eşleştirmesini kullanmak istediğimizi söyleyebiliriz. Yaşlarına bağlı olarak, ya tam fiyat öderler ya da indirim denerler. C# 8’de bunu şu şekilde ifade edebilirsiniz:

static int CalculateTicketPrice(Person person)
{
    return person switch
    {
        var p when p.Age <= 12 => 5,
        var p when p.Age > 12 && p.Age <= 60 => 15,
        var p when p.Age > 60 => 10
    };
}

Dikkat, bizim anahtarı sadece gerçekten bizim sınıfın özelliği dokunur olsa bile, bizim kod gürültü biraz var.p.Age

C# 9 ile anahtar ifadeleri artık ilişkisel de olabilir. Bu da ilişkisel işleçler (vb. gibi) üzerinde çalışabilecekleri anlamına gelir, bu da anahtar silahlarımızı <>>=p.Age

static int CalculateTicketPrice(Person person)
{
    return person when person.Age switch
    {
        <= 12 => 5,
        > 12 and <= 60 => 15,
        > 60 => 10
    };
}

Yukarıdaki parçacık da mantıksal işleci içerir unutmayın. İlişkisel işleçleri kullanmanın yanı sıra, , ve — bu aralıkları kısa bir şekilde bildirmenize olanak sağlar gibi mantıksal ifadeleri kullanarak anahtar kolları oluşturabilirsiniz.andandnotor

Buna ek olarak, artık bir nesnenin belirli bir “şekli” karşılayıp tatmin etmeyişeyolmadığını belirlemek için ifadelerdeki desen eşleştirmesini de kullanabilirsiniz. Örneğin, nesnelerin bir listesi olduğunu varsayalım ve koordinatları 1’e eşit olan tüm vektörleri yazdırmak istiyoruz. Desen eşleştirme kullanarak, bu olarak ifade edilebilir:ifVector3X

 foreach (var v in vectors)
    {
        if (v is { X: 1 })
            Console.WriteLine(v);
    }

Bunun da anahtar kelime aracılığıyla örtülü olarak bir denetim gerçekleştirdiğini unutmayın. Özellikle yararlı değil gibi değer türleri ile uğraşırken , ama nokta olsun.nullisVector3

Neden buna ihtiyacımız var?

Modern yazılım mühendisliği, nadiren hiç artık kendi duvarlı bahçe üzerinde çalışmak için olsun. Sisteminizin farklı kurallara uyarak dış sistemlerle etkileşimde olma olasılığı yüksektir. Bu, clr türü gibi rasgele bir uygulama ayrıntısı yerine, şekline göre verileri işleme yeteneği giderek daha önemli hale gelir anlamına gelir.

Tüm bunlar tamamen sözdizimsel şeker; yukarıdaki anahtar ifadesi if ifadeleri bir demet halinde derlenir alır:

private static int CalculateTicketPrice(Person person)
{
    int result;
    if (person.Age > 12)
    {
        if (person.Age <= 12 || person.Age > 60)
        {
            if (person.Age <= 60)
            {
                throw new SwitchExpressionException(person);
            }
            result = 10;
        }
        else
        {
            result = 15;
        }
    }
    else
    {
        result = 5;
    }
    return result;
}

Ama bu durumda, şeker kesinlikle kodumuzu daha tatlı yapar. Eğer seçmek zorunda olsaydı, yerine kod ifade, ya da yukarıdaki karmaşık yapı dört satır yazmak istiyorsunuz?switchif else

https://webodasi.com/sirketlerin-kiralamak-istedigi-kucuk-gelistirici-olun/

4. Hedef Yazma Geliştirmeleri

Hedef yazma, derleyicinin örneğin atama yaparken türü çıkarmasını sağlayan kavramdır:null

string s = null;

Açık konuşmak gerekirse, bu bir atamadır, ancak atamanın sol tarafı değişkenin türünü el ile dökmeniz gerekmez.(string) nullstring

Şu anda C#’da tür bildirimini ortaya çıkarabileceğiniz bir avuç durum vardır: atamalar, lambda ifadeleri ve daha az bir ölçüde dizi başharfleri.null

Hedef yazma C # 9, bir programcı olarak hayatınızı hiç çok biraz daha iyi hale getirmelidir genişletiliyor:

Hedef Yazılı ifadeler new

Örtük dizi başharflerini engelleme, yeni bir nesne oluşturmak için sözdizimi her zaman başharfle başharfe bindirdiğiniz tür nerededir.new T()T

C# 9 ile, atamanın sol tarafı türü belirlediği sürece ifadeden türü atlayabilirsiniz. Bu nedenle, aşağıdaki atama yasal olacaktır:new

Vector3 vec = (1, 2, 3);

Hedef Yazma ve Paylaşılan Türler

Şu anda, bir yöntemin geri dönüş değerleri eşleşmiyorsa, derleyici bir hata verir. Diyelim ki şu yönteme sahibiz:

public IEnumerable<int> GetNumbers(bool even)
{
    return even ? new List<int> {2, 4, 6} : new []{1, 3, 5};
}

Her ikisi de ve olsa da, derleyici hala bir uyarı sorunları. Ya dizi ya da döküm tarafından bu etrafında alabilirsiniz:List<int>int[]IEnumerable<int>List<int>IEnumerable<int>

public IEnumerable<int> GetNumbers(bool even)
{
    return even ? (IEnumerable<int>) new List<int> {2, 4, 6} : new []{1, 3, 5};
}

Ama C# 9’da artık buna gerek kalmayacak. Sürece iki operands paylaşılan bir türü var (bu durumda, ), kodunuzu sadece iyi derlenecek.IEnumerable<int>

Neden buna ihtiyacımız var?

Bu dil özellikleri daha çok yaşam kalitesinin iyileştirilmesidir. Yeni bir nesne oluştururken türünden vazgeçebilmek düzgündür, ancak bir şeyleri büyük ölçüde değiştirmeyecek.

Ben şahsen C# dil ekibi de bu küçük yaşam kalitesi değişiklikleri itmek için zaman ve çaba koyarak harika olduğunu düşünüyorum. C # yavaş yavaş program için daha keyifli bir dil haline gelmiştir, ve bu küçük özellikleri pasta üzerine krema gibidir.

5. Üst Düzey Programlar

Kurulmuş codebases için mutlaka önemli bir özellik olmasa da, üst düzey programlar programcı bile basit C # programları ile ilişkili “tören” atlayın sağlar.

Önce, konsola sadece “Hello World!” yazmak için yeni bir Konsol Uygulaması oluştururken, bir sürü kodla karşılanırsınız:

using System;

namespace ConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Ve bu örnek zaten ücretsiz olarak var gereksiz yönergeleri kaldırmak için aşağı kesilmiş. Deneyimli programcılar tüm bu yapıları bilir: direktifler, bildirimler ve sonuçta “Hello World!” yazdıran kodu içeren yöntem.usingusingnamespaceclass

Ancak yeni programcılar için, bu kavramak için çok şey var. Onlar merak ediyor olabilir “Neden basit bir Merhaba Dünya programı yazmak için tüm bu kod gerekir?”. Ve bu iyi bir soru, çünkü gerçekten, sadece Hello World yazmak için tüm bu kod gerekmez. C# ve nominal tip sistemi ile birlikte gelen törenin bir parçası.

Tören büyük uygulamalar ve sistemler tasarlarken inanılmaz derecede yararlıdır, ama bir Merhaba Dünya gibi önemsiz bir şey yazarken, sadece gereksiz şişkinlik’ s.

C# 9 ile başlayarak töreni atlayabilirsiniz ve Hello World’ünüzü şu şekilde ifade edebilirsiniz:

using System;

Console.WriteLine("Hello World!");

Yani bu, ad boşluklarının ve sınıfların artık gerekli olmadığı anlamına mı geliyor? Tam olarak değil. Bir ad alanı ve sınıf tanımlamak zorunda değilsiniz, ancak derleyici hala sizin için bunları oluşturur. Esasen, üst düzey programlar “sadece” sözdizimsel şeker vardır.

Yukarıdaki parçacık için derlenmiş kaynak koduna bakarsanız, derleyicinin sizin için tüm törenlerle ilgilendiğini görürsünüz:

using System;
using System.Runtime.CompilerServices;

// Token: 0x02000002 RID: 2
[CompilerGenerated]
internal static class <Program>$
{
	// Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
	private static void <Main>$(string[] args)
	{
		Console.WriteLine("Hello World!!");
	}
}

Akılda tutulması gereken değer, açık olmasa bile, kodhala statik bir bağlamdaçalışır , yöntem sayesinde.static void Main()

Neden buna ihtiyacımız var?

Bu, C#’ı acemi programcılar için teorik olarak daha erişilebilir kılan nispeten küçük bir özelliktir. Visual Studio hala varsayılan olarak ad alanları ve sınıf tanımı da dahil olmak üzere her şeyi oluşturur, ancak teorik olarak uygun yönergeleri ile birlikte C # satır bir çift yazmak ve çalıştırın.using

Benim şüphem bu dolaylı olarak Try .NETgibi projelere yönelik olmasıdır. Sadece C # bir snippet çalıştırmak istediğiniz bu durumlarda, üst düzey programlar ait son derece yararlı olur.

Neden? Çünkü direktifler yöntem gövdelerinde bulunamaz (bunun yerine ifade olurlar). Bu, kullanım yönergelerinin kullanıcı kodu tarafından sağlanmalıdır, ancak bildirim başlamadan önce dosyanın en üstüne eklenmesi gerektiğinden, kodu “dinamik olarak” çalıştırmak için bir sorun teşkil eder. Ve hepimizin bildiği gibi, uygun direktifler olmadan, kod derlemeyecek.usingusingclassusing

C# rasgele parçacıkları çalışan arzu senaryoları için, üst düzey programlar ait çok yararlıdır. Sadece kullanıcının kodunu almak, tüm kullanımları ile birlikte, ve derleyici anlaşma uygun yerlerde yerleştirerek.

Mansiyon

C# son şeklini almaya başladığında, bu özel sürüm için kesme yapmayan özellikler vardır. Bunlardan biri oldukça geç bir aşamada C # 9 atlandı basitleştirilmiş argüman kontrolleri vardı. Ben bu özelliği aslında C # 9 için kabul edildi göz önüne alındığında, C # bir sonraki sürümü içine yapma sona erecek oldukça muhtemel olduğunu düşünüyorum. Bu nedenle, bir fahri söz alır.null

Basitleştirilmiş Null Bağımsız Değişken Denetimleri

Bu özelliğin alaka düzeyi tamamen kod tabanınıza ve kodunuzda ön koşul denetimlerini kapsamlı olarak uygulayıp uygulamadığınıza bağlıdır.

Bir başvuru türünü parametrelerinden biri olarak kabul eden bir yöntem tanımlarken, bir başvuru geçirildiğinde işlevin başarısız olacağı çoğu zaman anlayabilirsiniz. Eğer yöntem kendi iş hakkında gitmeden önce kontrol elide, büyük olasılıkla başa çıkmak için tartışmasız en istisna ile karşılanacak: nullnullNullReferenceException

Bu özel durumları önlemek için, bir başvurunun yöntemin gövdesine girmediğinden emin olmak istersiniz. Bunu yapmanın yaygın bir yolu, bir yönteme veya oluşturucuya geçirilen bağımsız değişkenleri doğrulamaktır:null

public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor, ILoggerFactory loggerFactory)
{
    if (optionsAccessor == null)
    {
        throw new ArgumentNullException(nameof(optionsAccessor));
    }

    if (loggerFactory == null)
    {
        throw new ArgumentNullException(nameof(loggerFactory));
    }

    // Actual constructor code goes here.
}

Standart .NET kitaplıkları bu denetimlerle yüklüdür ve büyük olasılıkla kodunuz da öyledir.

Gerekli iken, bu kontroller yöntemin önsözü şişirilmiş yapmak, hem de biraz monoton. Neyse ki, C# 9’da, geçirilen başvuruların geçersiz olduğundan emin olmak için gerekli parametrelerdeki ek açıklama kullanılarak dil desteği sunulacaktır:!

public MemoryCache(IOptions<MemoryCacheOptions> optionsAccessor!, ILoggerFactory loggerFactory!)
{
    // Actual constructor code goes here, having the guarantee that neither optionsAccessor nor loggerFactory are null.
    _options = optionsAccessor.Value;
    _logger = loggerFactory.CreateLogger<MemoryCache>();
}

Yapıcı (veya başka bir yöntem) geçirilen bağımsız değişkenlerin geçersiz olduğunu bilerek yürütmeye devam edebilir ve bu nedenle tüm null-check-checking seremonisini iptal edebilir.

Statik vs çalışma zamanı denetimi

C#’ın önceki sürümünde, nullable olmayan başvuru türleri için opt-in desteği tanıtıldı. Etkinleştirildiğinde, derleyici her geçildiğinde veya açıkça nullable olarak işaretlenmemiş bir başvuru türüne atandığında bir uyarı yayımlar.null

Tabii ki, bazen beklenen oldu – örneğin ne zaman onun yüklemi eşleşen bir değer bulamaz. İade türünü örneğin bir . olarak ifade ederek uyarının etrafından dolaşabilirsiniz. Buna null-affgiving işlecidenir.nullFirstOrDefaultstring!

Null-affgiving işleci ve yeni stil null çek sözdizimi çok benzer olsa da, bazı büyük farklılıklar vardır. İlk olarak, null çek türü yerine parametre üzerinde bildirilir.!

Bunun nedeni, bu null denetimlerin tür sistemini hiç etkilememesidir. Nullable bir bağlam ayarlandığında, derleyici, kod yollarından herhangi birinin mantıksal olarak bir değerin geçirilmesine neden olup olmadığını derleme zamanında statik olarak denetler ve daha sonra durum buysa bir uyarı yayınlar.null

Bu yeni çekler yalnızca çalışma zamanıdır. Bunlar doğrudan eşdeğerdir:

if (o == null) 
    throw new ArgumentNullException(nameof(o));

Neden bunlara ihtiyacımız var?

Null referansları hata ayıklama zor olduğu için kötü üne sahiptir, bu nedenle bir meydana gelen daha az şansı, daha iyi. C#’nın önceki sürümünde tanıtılan nullable olmayan başvuru türleri soruna çok pastoral bir çözüm sağlarken, her zaman pratik bir çözüm değildir.null

Yeni projelerde nullable olmayan başvuru türlerini etkinleştirmek uygun olsa da, mevcut projeleri bu özellik ile yenilemek çok daha zordur. Yazılımınız doğrudan dış bileşenlere maruz kalırsa (örn. kitaplık kodu).

Bu nedenle, kontrol tekrarlayan, ancak gerekli angarya kalır. .NET çekirdek kitaplıklarında rastgele kod dosyaları seçimine bakarsanız, maruz kalan yöntemlerin çoğunun çok benzer prologlar içerdiğini göreceksiniz: denetimler. Bu özellik sadece bize tek bir karakter ile tüm bu çekleri yazmanızı sağlar. Seveilmeyecek ne var ki?nullpublicnull

Sonuç

Bu, C#’a yıllardır eklenen en büyük özellik kümesidir. Microsoft, verilerin CLR türü gibi rasgele bir uygulama ayrıntısı yerine şekline göre verilerle çalışabilme özelliğiyle C#’ı modern, çok amaçlı bir dil olarak sağlamlaştırmaya çalışır.

TypeScript programcılara daha az katı bir yazma sistemi arzu edildiğinde çok yönlü ve son derece geçerli bir seçenek sunduğunda, c# sertlik ve güvenilirlik söz konusu olduğunda tepenin kralıdır. Kayıt türleri ve yalnızca init özellikleri gibi özellikler yalnızca bu konumu daha da katılaştırma.

Eğer C # bir deneyin vermeyi düşünüyorsanız, şimdi zamanı!

C# Dil Deposu

C# evrimini zaman içinde benim kadar ilginç bulursanız, GitHub üzerinde CSharpLang deposunagöz atabilirsiniz. Bu depoda, C# ekibi ve topluluk gelecekteki dil özellikleri yle ilgili önerileri tartışır ve bundan sonra neler olacağını görebilirsiniz.

Örneğin, bu makalede açıklanan özelliklerin önerilerinin bir listesi aşağıda verilmiştir:

  1. Kayıt türleri
  2. Yalnızca özellik ayarlayıcıları
  3. Desen Eşleştirme
  4. Hedef Yazma
  5. Üst Düzey Programlar / Üst Düzey İfadeler

Dilerseniz Bir Sonra Ki Blog Sayfalarımıza Göz Atabilirsiniz..

Görüşmek Üzere Hoşçakalın WebOdasıyla Kalın..

Yapılan Yorumlar
Bir Yorum Yapın