C # neden önceki bir ifade olmadan {} kod bloklarına izin veriyor?

Neden C # izin vermez bir önceki açıklamada olmadan kod blokları (örn if, else, for, while)?

void Main()
{
    {   // any sense in this?
        Console.Write("foo");
    }
}

Verdiğiniz bağlamda hiçbir önemi yok. Konsola sabit bir dize yazmak, program akışının herhangi bir yerinde aynı şekilde çalışacaktır. ¹

Bunun yerine, genellikle bunları bazı yerel değişkenlerin kapsamını kısıtlamak için kullanırsınız. Bu, burada ve burada daha da detaylandırılmıştır . Bak João Angelo'nun cevap ve Chris Wallis 'cevabı kısa örnekler için. Aynısının C tarzı sözdizimine sahip diğer bazı diller için de geçerli olduğuna inanıyorum, ancak bu soruyla ilgili olmayacaklarından değil.

¹ _{Tabii ki komik olmaya ve tamamen beklenmedik bir şey Consoleyapan bir Write()yöntemle kendi sınıfınızı yaratmaya karar vermedikçe.}

En { ... }azından yerel değişkenler için yeni bir kapsam getirme yan etkisine sahiptir.

Bunları, switchher durum için farklı bir kapsam sağlamak için ifadelerde kullanma eğilimindeyim ve bu şekilde, yerel değişkeni, kullanımlarının mümkün olan en yakın yerinde aynı isimle tanımlamama ve ayrıca bunların yalnızca vaka düzeyinde geçerli olduklarını belirtmeme izin verme eğilimindeyim .

Bu, kapsamı tanımlamak için parantez kullanan birçok C sözdizimi dilinin mantıksal bir yan etkisi olduğundan, C # 'ın bir özelliği değildir .

Örneğinizde parantezlerin hiçbir etkisi yoktur, ancak aşağıdaki kodda bir değişkenin kapsamını ve dolayısıyla görünürlüğünü tanımlarlar:

Bu , ilk blokta kapsam dışına çıktığım için izin verilir ve bir sonraki blokta tekrar tanımlanır:

{
    {
        int i = 0;
    }

    {
        int i = 0;
    }
}

Bu izin verilmez i kapsam dışında düşmüş ve artık dış kapsamında görünür olduğu gibi:

{
    {
        int i = 0;
    }

    i = 1;
}

Ve benzeri vb.

{}Birkaç ifade içerebilen bir ifade olarak görüyorum .

Bir boole ifadesinin ardından gelen bir if ifadesini ve ardından gelen bir ifadeyi düşünün . Bu işe yarar:

if (true) Console.Write("FooBar");

Bu da işe yarar:

if (true)
{
  Console.Write("Foo");
  Console.Write("Bar");
}

Yanılmıyorsam buna blok ifade denir.

Yana {}diğer ifadeler içerebilir ayrıca diğer içerebilir {}. Bir değişkenin kapsamı ebeveyni tarafından tanımlanır {}(blok ifadesi).

Bahsetmeye çalıştığım nokta, bu {}sadece bir ifade, yani bir eğer ya da herneyse gerektirmiyor ...

C-sözdizimi dillerinde genel kural "aradaki { }her şey tek bir ifade olarak ele alınmalıdır ve tek bir ifadenin yapabileceği her yere gidebilir" dir:

• Bir if.
• A for, whileveya do.
• Kodun herhangi bir yerinde .

Tüm niyet ve amaçlar için, dil dilbilgisi şunları içeriyordu:

     <statement> :== <definition of valid statement> | "{" <statement-list> "}"
<statement-list> :== <statement> | <statement-list> <statement>

Yani, "bir ifade (çeşitli şeyler) veya bir açılış parantezinden, ardından bir ifade listesi (bir veya daha fazla ifade içerebilir) ve ardından kapalı bir parantezden oluşabilir". IE "bir { }blok herhangi bir yerde herhangi bir ifadenin yerini alabilir". Kodun ortasına dahil.

{ }Tek bir ifadenin gidebileceği herhangi bir yere bir bloğa izin vermemek , aslında dil tanımını daha karmaşık hale getirirdi .

Çünkü C ++ (ve java), önceki bir ifade olmadan kod bloklarına izin verdi.

C ++ onlara izin verdi çünkü C bunu yaptı.

Tüm bunların Avrupa program dili ( Modula-2 tabanlı) tasarımından ziyade ABD program dili (C tabanlı) tasarımının kazandığı gerçeğine bağlı olduğunu söyleyebilirsiniz .

(Kontrol ifadeleri tek bir ifadeye göre hareket eder, ifadeler yeni ifadeler oluşturmak için gruplar olabilir)

// if (a == b)
// if (a != b)
{
    // do something
}

1 Çünkü ... İfadenin Kapsam Alanını Korur .. veya İşlev, Bu, büyük kod için gerçekten yararlıdır ..

{
    {
        // Here this 'i' is we can use for this scope only and out side of this scope we can't get this 'i' variable.

        int i = 0;
    }

    {
        int i = 0;
    }
}

C # 'nın ifadelerden önce gelen kod bloklarına neden izin verdiğini sordunuz. "Neden" sorusu, "bu yapının olası faydaları neler olabilir?" Şeklinde de yorumlanabilir.

Şahsen, kod bloğunun yerel değişkenlerin kapsamını sınırladığını unutmadan, okunabilirliğin diğer geliştiriciler için büyük ölçüde geliştirildiği C # 'da ifadesiz kod blokları kullanıyorum. Örneğin, ek kod blokları sayesinde okunması çok daha kolay olan aşağıdaki kod parçacığını düşünün:

OrgUnit world = new OrgUnit() { Name = "World" };
{
    OrgUnit europe = new OrgUnit() { Name = "Europe" };
    world.SubUnits.Add(europe);
    {
        OrgUnit germany = new OrgUnit() { Name = "Germany" };
        europe.SubUnits.Add(germany);

        //...etc.
    }
}
//...commit structure to DB here

Bunun her yapı seviyesi için yöntemler kullanılarak daha zarif bir şekilde çözülebileceğinin farkındayım. Ancak yine de, örnek veri tohumlayıcıları gibi şeylerin genellikle hızlı olması gerektiğini unutmayın.

Dolayısıyla, yukarıdaki kod doğrusal olarak çalıştırılsa bile, kod yapısı nesnelerin "gerçek dünya" yapısını temsil eder, böylece diğer geliştiricilerin anlamasını, sürdürmesini ve genişletmesini kolaylaştırır.