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

Dinamik ve Var Arasındaki Fark

C#'ta, var, derleme zamanında tür güvenliği ve IntelliSense desteği sağlayarak, türün derleme zamanında belirlendiği örtük türde yerel değişkenler için kullanılır. Buna karşılık, dynamic, değişkenlerin derleme zamanı tür denetimini atlamasına izin verir, tür çalıştırma zamanında çözülür, daha fazla esneklik sunar ama çalışma zamanı hataları ve performans sorunları riski taşır.

Tim Corey, var'nin statik değişkenler olduğu için derleme zamanında tür belirlemesi ile tür güvenliğini sağladığını, dynamic'nın ise çalışma zamanı tür çözümü ile esneklik sunduğunu ancak çalışma 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, biraz object gibi davranarak, ancak ek yeteneklerle esnek tür işleme sağladığını vurgular. 3:53'te Tim, dynamic'nın, farklı türler arasında çalışma zamanı sırasında sorunsuz bir şekilde dönüştürebildiğini, örnek kodunda gösterildiği gibi, tam sayılar ve çiftlerle ilgili hesaplamaları açık cast etmeden gerçekleştirebildiğini gösterir.

// 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'nın başlangıçta bir tam sayı değeri tuttuğunu ancak 2.1 ekleyince çift bir değere dönüştüğünü ve sonuçta 3.1 çıktığını belirtir.

Esnekliğine rağmen, Tim, sık tür dönüşümleri nedeniyle dynamic'nın aşırı kullanılmasına karşı uyarır. 5:55'te dynamic'nın C# geliştirmesinde gereksiz işlemci yükünü ve sağlam, hatasız kod tabanlarını sürdürmek için kritik olan derleme zamanı tür denetimi ve IntelliSense desteğinin kaybını önlemek için dikkatli kullanılmasına vurgu yapar.

Geliştirmedeki Dinamiklerin Dezavantajları

Tim Corey, dynamic'nın, uygulamalarınızda çalışma zamanı hatalarına ve beklenmeyen davranışlara yol açabileceğini gösterir. Başlangıçta bir dinamik değişken tanımlayıp atayarak ve anında bir hata oluşmamasını sağlamak için boş bir dize atayarak başlar. Ardından, dinamik değişken üzerinde var olmayan metod sayHi'ı çağırmaya çalışır, bu derleme zamanında bir hataya neden olmaz ancak çalışma zamanı istisnası ile sonuçlanır, bu da dynamic'nın önemli bir dezavantajını gösterir: derleme zamanı denetiminin eksikliği.

// 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

8:38'de Tim, dinamik değişkenlerin çalışma zamanında tür değiştirebileceğini, bu da beklenmeyen davranışlara neden olabileceğini gösterir. O, dinamik bir değişkene bir Person nesnesi atar, ardından onu bir metin dizesine yeniden atar ve bu esnekliğin mantıksal hatalara yol açabileceğini ve hata ayıklamayı zorlaştırabileceğ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 adları nedeniyle çalışma zamanı hatalarına yol açabilecek IntelliSense desteğinden yoksun olduğunu açıklar. Örneğin, 14:05'te, var olmayan bir özellik Email adını çağırır, bu hatanın çalışma zamanına kadar fark edilmediğini vurgular. Kod hatasız bir şekilde derlenir, ancak çalışma zamanında Person nesnesinde beklenen yöntemler veya özellikler dizede bulunamadığında başarısız olur.

// 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";
}

Dinamiğin Neden ve Ne Zaman Kullanılacağı

Tim, dynamic'nın vazgeçilmez olduğu belirli senaryoları detaylı olarak açıklar. C#'ın temelinde, her değişkenin yaşam döngüsü boyunca tutarlı kalan kesin bir tür atanmış olan, güçlü tipli bir dil olduğunu açıklar. Bu, değişkenlerin dinamik olarak tür değiştirebileceği JavaScript gibi dillere karşıttır.

Tim, 18:14'de, C#'ın güçlü tipli değişkenler için tasarlanmış olmasına rağmen, özellikle Python, Ruby veya COM objeleri gibi dil ve dış sistemlerle etkileşimlerde dinamik türlemenin faydalı olabileceğini belirtir. O, dynamic'nın pratik ihtiyacını vurgulamak için bir Python API entegrasyonu örneği kullanır. Bu durumlarda, dış kaynaklardan gelen çeşitli veri türlerine adapte olabilen esnek bir tür sistemi, etkileşimi basitleştirir.

Tim Corey, 18:44'te, dynamic'nın dil arası etkileşimler için kullanışlı olduğunu, ancak derleme zamanı hata denetimi ve IntelliSense desteğinin kaybı nedeniyle yalnızca C# kodu için genellikle önerilmediğini vurgular. O, dynamic'nın esnekliğinin performans ve tür güvenliği maliyetine geldiğini, güçlü türlendirilmiş değişkenlerin tercih edilmesi gereken düzenli C# programlaması için daha az istenen bir seçenek yaptığını uyarır.

Var Anahtar Kelimesinin Neden ve Ne Zaman Kullanılacağı

Tim ardından C#'ta var anahtar kelimesinin kullanımı ve felsefesini tartışır. O, var'yı kullanma konusunda iki ana kamp olduğunu belirtir: bunu yalnızca kullanmayı tercih edenler ve açık tür ilanlarını tercih edenler.

Tim, 19:43'te, var savunucularının daha iyi adlandırma kuralları teşvik ettiğini ve kodu kendiliğinden belgeler hale getirdiğini savunduğunu açıklar. Değişken adlarının, türü, uygun bir beyan olmadan aktarmak için yeterince açıklayıcı olması gerektiğine inanırlar.

Diğer tarafta (20:46), açık tür beyanlarını tercih edenler, gerçek türün doğrudan kodda görülmesinin, değişkenin türünü görmek için üzerine gelmeden, yerel değişkenin ne türde olduğunu anında açık hale getirdiğini savunuyor. Örneğin:

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

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

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

Tim, 21:15'te, genellikle string, int, double ve decimal gibi yaygın veri türleri için açık türleri kullandığını çünkü bu şekilde kodun daha net olduğu ve double ile decimal karıştırılması gibi potansiyel sorunlardan kaçınıldığını belirterek dengeli yaklaşımını paylaşır. Ö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

Tim, benzer türler arasında karışıklık olduğunda, doğru türün kullanıldığını garanti etmek için türü açıkça bildirmenin önemli olduğunu vurgular.

Ancak, Tim var'nın uzun veya karmaşık türlerle uğraşırken özellikle yararlı olabileceğini de kabul eder. 23:37'de bir List<List<Person>> bilgisini açıklar.

// 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 23:55'te foreach döngülerinde 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'nın belirginliği azaltabileceğini, ancak okunabilirliği korumak ve kafa karışıklığını önlemek için değişken adının net ve açıklayıcı olmasının önemli olduğunu belirterek sonuç çıkarır.

Açık türlerle @--CODE-370--@@ kullanarak, geliştiriciler açık, sürdürülebilir ve verimli kod yazabilir, her iki yaklaşımın güçlü yönlerini uygun bağlama göre kullanabilirler.

Anonim Nesne Olarak Var

Tim, türün açıkça bilinmediği veya anonim türlerle çalışıldığında var kullanımını tartışır. Tanımlanmış bir türü olmayan bir anonim nesne oluşturarak bunu gösterir. İşte kullandığı kod:

// 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 nesne anonim olduğu ve belirli bir tür adı olmadığı için, bunun için değişkenlerin yalnızca var kullanılarak ilan edilebileceğini açıklar. Bu yaklaşım, formel bir sınıf tanımlamaya gerek kalmadan nesnelerin oluşturulmasına ve kullanılmasına izin verir.

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

// 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}");

Kod yürütüldüğünde 26:25'te çıktı şudur:

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

Tim, 26:54'te, basit ve yaygın türler için string, tam sayılar ve sınıf örnekleri gibi açık türleri kullanmayı tercih ettiğini çünkü kodu daha net hale getirdiğini açıklar. Ancak, var'yı türün uzun, karmaşık veya açıkça bilinmediği durumlarda, anonim türler veya karmaşık tür ilanları gibi, kullanır.

Sonuç

İşte bu—C# değişkenleri ve veri türleri hakkında net bir anlayış, var ve dynamic anahtar kelimelerinin stratejik kullanımıyla birlikte. Tim Corey'nin dengeli yaklaşımını izleyerek, var anahtar kelimesi ile kodunuzda tür güvenliğini ve netliği sağlayabilir, dynamic anahtar kelimesinin esnekliğinden dış sistemlerle etkileşim gibi belirli senaryolar için faydalanabilirsiniz.

Daha detaylı içgörüler için, Tim Corey'nin 'C#'ta Dinamik ve Var' videosunu izlediğinizden emin olun ve daha fazla C# öğrenme konuları için YouTube Kanalını mutlaka ziyaret edin.