C# Değişkenlerini ve Veri Türlerini Anlama

Dinamik ve Var Farkı

C#'da, var, tür güvenliğini ve IntelliSense desteğini sağlamak için derleme zamanında türün belirlendiği, örtük olarak tiplenmiş yerel değişkenler için kullanılır. Buna karşılık, dynamic değişkenlerin derleme zamanı tür kontrolünü atlayarak çalıştırma zamanında türün çözüldüğü daha fazla esneklik sunar ancak çalıştırma zamanı hataları ve performans kaybı riski taşır.

Tim Corey, var statik değişkenler olmaları nedeniyle derleme zamanı tür belirlemesi ile tür güvenliğini sağladığını, dynamic ise çalıştırma zamanı tür çözümü ile esneklik sunduğunu ve bunun çalıştırma zamanı hatalarına ve performans sorunlarına yol açabileceğini açıklar.

// Declaration of a dynamic variable that can change types at runtime
dynamic testDynamic;

// Declaration of a dynamic variable that can change types at runtime
dynamic testDynamic;

// This will result in a compile-time error due to lack of type inference
// var testVar;

// This will result in a compile-time error due to lack of type inference
// var testVar;

// var assignment with type inference from the initial value
var testVar = 2; // testVar is inferred to be of type int

// var assignment with type inference from the initial value
var testVar = 2; // testVar is inferred to be of type int

// Attempting to change the type from int to double causes an error
// testVar = 1.1; // Error: Cannot implicitly convert type 'double' to 'int'

// Attempting to change the type from int to double causes an error
// testVar = 1.1; // Error: Cannot implicitly convert type 'double' to 'int'

// Another example with dynamic typing
var testVar = 2.1; // Now testVar is a double

// Another example with dynamic typing
var testVar = 2.1; // Now testVar is a double

// Declaring a constant variable
const int MaxValue = 100;

// Declaring a constant variable
const int MaxValue = 100;

Dinamik Otomatik Tür Dönüşümü

Tim, dynamic anahtar kelimesinin object gibi davrandığını ancak ekstra yetenekler ekleyerek esnek tür işlemesine olanak sağladığını vurgular. 3:53'te Tim dynamic'in, tamsayılar ve double'lar arasındaki hesaplamaları kapsama yeteneğiyle, çalışma zamanında farklı türler arasında sorunsuz bir şekilde dönüştürebileceğini gösterir. Kod örneği ile şu şekilde açıklanmıştır:

// Demonstrating dynamic type conversion at runtime
dynamic testDynamic = 1;
testDynamic = testDynamic + 2.1;
Console.WriteLine(testDynamic); // Outputs 3.1 as it converts the integer to a double

// Demonstrating dynamic type conversion at runtime
dynamic testDynamic = 1;
testDynamic = testDynamic + 2.1;
Console.WriteLine(testDynamic); // Outputs 3.1 as it converts the integer to a double

Burada, Tim (4:39) testDynamic'in başlangıçta bir tam sayı değeri tuttuğunu, ancak üzerine 2.1 eklendiğinde, bir hata olmadan double'a kolayca dönüştüğünü ve bu yüzden çıktının 3.1 olduğunu göstermektedir.

Esnekliğine rağmen, Tim dynamic'in sık tür dönüştürmelerinin yol açacağı performans maliyetleri nedeniyle aşırı kullanılmaması gerektiği konusunda uyarır. 5:55'te dynamic'in C# geliştiriminde gereksiz işlemci yükünü ve derleme zamanı tür kontrolü ile IntelliSense desteğinin kaybını önlemek için dikkatli kullanılmasını vurgular, kritik kod tabanlarının sağlam olması ve hatasız olmasına yardımcı olur.

Geliştirme Sürecinde Dinamiğin Eksiklikleri

Tim Corey, dynamic'in uygulamalarınızda çalışma zamanı hatalarına ve beklenmedik davranışlara nasıl yol açabileceğini gösterir. Bir dinamik değişken nasıl bildirilir ve başlangıçtaki boş bir dizeye nasıl atanır, böylece anında hata oluşmaz, göstererek başlar. Daha sonra dinamik değişkende var olmayan sayHi metodunu çağırmayı dener, bu derleme zamanında hata oluşturmaz ancak bir çalışma zamanı istisnası ile sonuçlanır, dynamic önemli bir dezavantajını, derleme zamanı kontrolünün olmadığı durumu gösterir.

// Demonstrating lack of compile-time checks with dynamic
dynamic testDynamic = "";
// testDynamic.sayHi(); // Runtime error: method does not exist

// Demonstrating lack of compile-time checks with dynamic
dynamic testDynamic = "";
// testDynamic.sayHi(); // Runtime error: method does not exist

Daha sonra, 8:38'de, Tim dinamik değişkenlerin çalışma zamanında tür değiştirebileceğini ve bu durumun beklenmeyen davranışlara sebep olabileceğini gösterir. Dinamik bir değişkene Person nesnesi atar, ardından bunu bir metine yeniden atar ve bu esnekliğin mantıksal hatalara ve hata ayıklamanın zorlaşmasına nasıl yol açabileceğini gösterir.

// Demonstrating the potential errors with dynamic type reassignment
dynamic testDynamic = new Person();
testDynamic = "Hi";
Console.WriteLine(testDynamic); // Works fine, but not ideal for type safety

// Demonstrating the potential errors with dynamic type reassignment
dynamic testDynamic = new Person();
testDynamic = "Hi";
Console.WriteLine(testDynamic); // Works fine, but not ideal for type safety

Tim, ayrıca dinamik değişkenlerin, yazım hataları veya yanlış metod isimlerinden kaynaklanan çalışma zamanı hatalarına yol açabilecek IntelliSense desteğinden yoksun olduğunu açıklar. Örneğin, 14:05'te mevcut olmayan Email adlı bir özelliği çağırır, bu hata çalıştırma zamanına kadar fark edilmeyeceğini ve derlenmeye başladığında hata olmadığını ancak çalışma zamanında Person nesnesinin üzerinde beklenen metodlar veya özellikler metinde bulunmadığında başarısız olduğunu gösterir.

// Demonstrating a runtime error due to missing property
// testDynamic.Email = "Test@test.com"; // property not found until runtime

// Demonstrating a runtime error due to missing property
// testDynamic.Email = "Test@test.com"; // property not found until runtime

// Using var for strongly-typed assignments
var testVar = new Person();
testVar.FirstName = "Sue";
testVar.LastName = "Storm";

// The use of IntelliSense assists in reducing runtime errors
Console.WriteLine(testVar.SayHello()); // Ideally a method in Person class

// Using var for strongly-typed assignments
var testVar = new Person();
testVar.FirstName = "Sue";
testVar.LastName = "Storm";

// The use of IntelliSense assists in reducing runtime errors
Console.WriteLine(testVar.SayHello()); // Ideally a method in Person class

// Attempting to change type results in compile-time errors with var
// testVar = "Hi"; // Compile-time error

// Attempting to change type results in compile-time errors with var
// testVar = "Hi"; // Compile-time error

// Method returning a dynamic type
public dynamic GetMessage() {
    return "This is a test";
}

// Method returning a dynamic type
public dynamic GetMessage() {
    return "This is a test";
}

Dinamik Kullanımının Nedenleri ve Zamanı

Tim, dynamic önemli hale geldiği belirli senaryoları ayrıntılı olarak açıklar. C#'ın temelde güçlü yazılmış bir dil olduğunu, yani her değişkene belirli bir tür atandığını ve yaşamı boyunca tutarlı kaldığını açıklar. Bu, değişkenlerin türlerini dinamik olarak değiştirebildiği JavaScript gibi dillere karşıdır.

Tim, 18:14'te, C#'ın güçlü yazılmış değişkenleri hedef almasına rağmen, Python, Ruby veya COM nesneleri gibi dış sistemlerle veya dillerle etkileşim kurarken dinamik yazmanın faydalı olabileceği durumlar olduğuna vurgu yapıyor. Python API entegrasyon örneğini kullanarak dynamic pratiğe dayalı ihtiyaçı vurgular. Bu durumlarda, dış kaynaklardan çeşitli veri türlerine adapte olabilen esnek bir tür sistemi, etkileşimi basitleştirir.

Tim Corey, 18:44'te dynamic, dil dışı etkileşimler için kullanışlı olmasına rağmen, saf C# kodu için derleme zamanı hata kontrolü ve IntelliSense desteğinin kaybolması nedeniyle genellikle önerilmediğini vurgular. Esnekliğinin, performanstan ve tür güvenliğinden ödün verdiğini ve böylece düzenli C# programcılığı için, sıkı tiplenmiş değişkenlerin tercih edilmesi gereken daha az istenilen bir seçenek olduğunu uyarır.

Var Anahtar Kelimesinin Kullanım Nedenleri ve Zamanı

Tim daha sonra C#'daki var anahtar kelimesinin kullanımı ve felsefesini tartışır. var kullanımı konusunda iki ana kamp olduğuna dikkat çeker: bunu yalnızca kullanmayı tercih edenler ve açık tür beyanlarını destekleyenler.

Tim, 19:43'te var savunucularının bunun daha iyi adlandırma kurallarını teşvik ettiğini, kodu kendi kendine belgelesi haline getirdiğini savunduklarını açıklar. Değişken adlarının türünü ifade etmek için yeterince açıklayıcı olması gerektiğine inanırlar, açık bir bildirim gerektirmeden.

Öte yandan (20:46), açık tür bildirimlerini tercih edenler, gerçek türün doğrudan kodda görülmesinin, türün ne olduğunun hemen anlaşılmasını sağladığını, değişkenin üzerine gelinerek türünü görmeye gerek kalmadan açıklar. Örneğin:

// Explicit type declaration provides clarity
string firstName = "Tim";

// Explicit type declaration provides clarity
string firstName = "Tim";

Bu, bazıları tarafından değişken türü hakkında herhangi bir belirsizliği ortadan kaldırdığı için tercih edilir.

Tim, 21:15'te dengeli yaklaşımını paylaşarak yaygın veri türleri için genellikle açık türleri kullandığını ifade eder, çünkü bu kodu daha net hale getirir ve double ile decimal'nı karıştırma gibi potansiyel sorunları önler. Örneğin:

// Explicit type ensures there's no ambiguity between float types
double myMoney = 1.1; // This is a double
decimal myMoney = 1.1M; // This is a decimal

// Explicit type ensures there's no ambiguity between float types
double myMoney = 1.1; // This is a double
decimal myMoney = 1.1M; // This is a decimal

Açıkça türü belirtmenin, benzer türler arasında karışıklık olabileceği hissedildiğinde doğru türün kullanıldığından emin olmaya yardımcı olduğunu vurgular.

Ancak Tim, var özellikle uzun veya karmaşık türlerle uğraşırken faydalı olabileceğini kabul eder. 23:37'de bir List<List<Person>> beyan etmenin yer kaplayıcı olabileceği bir örnek sunar:

// Declaring a complex type using var
var rounds = new List<List<Person>>();

// Declaring a complex type using var
var rounds = new List<List<Person>>();

Ayrıca foreach döngülerinde (23:55) faydasını gösterir:

// Utilizing var in loop for cleaner code
foreach (var round in rounds) {
    // Do something with each round
}

// Utilizing var in loop for cleaner code
foreach (var round in rounds) {
    // Do something with each round
}

Tim, var'in kelime fazlalığını azaltabileceğini belirtir, ancak okunabilirliği korumak ve kafa karışıklığını önlemek için değişken adlarının net ve açıklayıcı olmasını sağlamak önemlidir.

var kullanımı ile açık türlerin dengesini sağlamak, geliştiricilerin duruma uygun olarak kodunuzu açık, sürdürülebilir ve verimli yazmasını sağlar.

Var Anonim Nesne Olarak

Tim, türün açıkça bilinmediği veya anonim türlerle çalışılırken var kullanımını tartışır. Anında bağlantısız bir nesne oluşturarak gösterir, bu önceden tanımlı bir türe sahip değildir. Kullandığı kod burada var:

// Creating an anonymous object with var
var myItem = new { FirstName = "Tim", Email = "test@test.com" };

// Creating an anonymous object with var
var myItem = new { FirstName = "Tim", Email = "test@test.com" };

Tim, 25:30'da, bu nesnenin anonim olduğunu ve belirli bir tür adı olmadığını, bunun için değişkenlerin sadece var kullanılarak bildirilmesi gerektiğini açıklar. Bu yaklaşım, resmi bir sınıf tanımlamaya gerek kalmadan nesnelerin oluşturulmasına ve kullanılmasına olanak tanır.

Bunun nasıl pratikte çalıştığını göstermek için Tim, (25:52) yazar:

// Outputting properties of an anonymous object
Console.WriteLine($"Hello {myItem.FirstName}: your email is {myItem.Email}");

// Outputting properties of an anonymous object
Console.WriteLine($"Hello {myItem.FirstName}: your email is {myItem.Email}");

26:25'te kodu calistirdiginda, şu çıktıyı verir:

Bu, var'in anonim bir nesnenin özelliklerini ele alabileceğini ve bu nesne anonim olmasına rağmen Visual Studio'nun bu özellikler için IntelliSense desteği sunduğunu gösterir.

Tim, 26:54'te, basit ve yaygın türler gibi string'ler, tamsayılar ve sınıf örnekleri için açık türleri kullanmayı tercih ettiğini çünkü bu kodu daha net hale getirdiğini netleştirir. Ancak, türün uzun, karmaşık veya açıkça bilinmediği anonim türler veya karmaşık tür beyanları durumlarında var kullanır.

Sonuç

Ve işte orada, var ve dynamic anahtar kelimelerinin stratejik kullanımıyla birlikte C# değişkenleri ve veri türleri hakkında net bir anlayış. Tim Corey'nin dengeli yaklaşımını takip ederek, var anahtar kelimesiyle kodunuzda tür güvenliği ve berraklığı sağlayabilirken, dış sistemlerle etkileşim gibi belirli senaryolar için dynamic anahtar kelimesinin esnekliğinden yararlanabilirsiniz.

Daha ayrıntılı bilgiler için Tim Corey'nin "C#'ta Dynamic ve Var" videosunu izlediğinizden ve daha fazla C# öğrenme konuları için YouTube Kanalı'na göz attığınızdan emin olun.