C # Mülakat Soruları

SORU

(mülakat klasiği: field vs property + inheritance)

class A
{
    public int X = 1;
    public virtual int P => X;
}

class B : A
{
    public new int X = 2;
    public override int P => X;
}

A obj = new B();
Console.WriteLine($"{obj.X} {obj.P}");

Çıktı hangisi?

A) 1 1 B) 1 2 C) 2 1 D) 2 2

Cevap 👉 B

Açıklaması

=> = “şu expression’ı döndür” Getter / metot kısayolu

Bu soru field hiding + property override + referans tipi birleşimi olduğu için satır satır gidelim. Önce kodu etiketleyerek yazıyorum, sonra çıktıyı bağlayacağım.

Kod (satır satır açıklamalı)

class A
{
    public int X = 1;              // field (A sınıfına ait alan)

• X → field
• public → her yerden erişilebilir
• Değer: 1
• Virtual değil → polymorphism’e girmez

    public virtual int P => X;     // property (expression-bodied, virtual)
}

• P → property
• get var, set yok (read-only)
• => X → return X;
• virtual → override edilebilir
• Polymorphism burada başlıyor

class B : A
{

B, A’dan inheritance alıyor

    public new int X = 2;          // field (A.X'i gizler - hiding)

• new → method/field hiding
• A.X silinmez, gizlenir
• B içinden X denince → B.X = 2
• Polymorphism yok, compile-time kararı

    public override int P => X;    // property override (polymorphism)
}

• override → A.P’nin yerine geçer
• Runtime’da gerçek nesne (B) dikkate alınır
• Buradaki X → B.X

A obj = new B();   // base class referansı, derived nesne

• Referans tipi: A
• Gerçek nesne: B
• Bu satır polymorphism’in klasik başlangıcı

Console.WriteLine($"{obj.X} {obj.P}");

obj.X

• X field
• `virtual değil**
• Compile-time kararı
• Referans tipi A → A.X
• Değer: 1

obj.P

• P virtual property
• Runtime kararı
• Gerçek nesne B → B.P
• B.P → return X;
• B içindeki X → 2

Nihai çıktı

1 2

Doğru cevap

👉 B) 1 2

SORU

class A
{
    protected int x;

    public A()
    {
        x = 5;
    }

    public virtual int Value
    {
        get { return x; }
    }
}

class B : A
{
    public B()
    {
        x = 10;
    }

    public override int Value
    {
        get { return x * 2; }
    }
}

A obj = new B();
Console.WriteLine(obj.Value);

Bu kodun çıktısı nedir?

A) 5 B) 10 C) 20 D) Compile-time error

Açıklması

class A

protected int x;

• field
• protected → sadece A ve A’dan türeyen sınıflar erişebilir

public A()
{
    x = 5;
}

• constructor
• A nesnesi oluşturulunca x = 5 atanır

public virtual int Value
{
    get { return x; }
}

• Polymorphism sadece virtual/override ile olur
• property
• virtual → override edilebilir
• return x;

class B : A

public B()
{
    x = 10;
}

• B constructor
• 👉 Constructor sadece çalışır. Ezmez, gizlemez.
• Önce A constructor çalışır → x = 5
• Sonra B constructor çalışır → x = 10
• Yani son durumda x = 10

public override int Value
{
    get { return x * 2; }
}

• override property
• Runtime’da bu çalışır
• x * 2

Kritik satır (polymorphism)

A obj = new B();

• Referans tipi: A
• Gerçek nesne: B

Console.WriteLine(obj.Value);

• Value virtual
• Runtime’da B.Value çağrılır
• x = 10
• x * 2 = 20

Çıktı

20

✅ Doğru cevap: C

Aynı Soru İçin Different Explanation :)

class A
{
    protected int x;

    public A()
    {
        x = 5;
    }

    public virtual int Value
    {
        get { return x; }
    }
}

class B : A
{
    public B()
    {
        x = 10;
    }

    public override int Value
    {
        get { return x * 2; }
    }
}

A obj = new B();
Console.WriteLine(obj.Value);

Çıktı ne olurdu soru

1) Sınıflar ve scope (kapsam)

class A { ... } scope’u

protected int x;

• field (alan).

protected: A sınıfının içinde ve A’dan türeyen sınıfların içinde erişilebilir. Yani B sınıfı x’e direkt erişebilir.

public A() { x = 5; }

• constructor: A nesnesi oluşturulurken çalışır.

public virtual int Value { get { return x; } }

• property: dışarıya bir değer döndüren “kontrollü erişim”.
• virtual: “alt sınıf isterse bunu override edebilir” izni.

class B : A { ... } scope’u

B, A’dan inheritance alıyor.

public B() { x = 10; }

• B oluşturulurken çalışır.
• x protected olduğu için erişebilir ve değer atar.

public override int Value { get { return x * 2; } }

• A.Value’yi override eder: “A’daki davranışın yerine bu geçsin.”
• Burada Value artık x * 2 döndürür.

2) En kritik kısım: Nesne oluşturma sırası (constructor zinciri)

Şu satır çalışınca:

A obj = new B();

• Referans tipi: A
• Gerçek nesne: B

Ama nesne yaratılırken constructorlar zincir halinde çalışır:

1. Önce base class constructor (A()) çalışır

x = 5;

• Bu noktada x = 5

2. Sonra derived class constructor (B()) çalışır

x = 10;

Bu noktada x = 10 (aynı field’a yeni değer)

✅ Yani nesne tamamen kurulduğunda x artık 10.

Burada “hiding” yok. x yeniden tanımlanmadı (new int x gibi bir şey yok). Sadece aynı field’ın değeri constructor’da güncellendi.

3) Polymorphism: virtual + override ile runtime seçimi

Şu satır:

Console.WriteLine(obj.Value);

• Value bir property.
• A içinde Value virtual.
• B içinde Value override.

Bu yüzden çağrı yapılınca C# şunu yapar:

• “Referans tipi A olsa bile, gerçek nesne B ise, override edilmiş versiyonu çalıştır.”

Yani çalışacak olan:

B.Value

Ve B.Value şunu döndürür:

get { return x * 2; }

x şu an 10 olduğu için:

• x * 2 = 10 * 2 = 20

Dolayısıyla çıktı:

20

4) Neden “compile-time error” değil?

• A obj = new B(); geçerli (upcasting).
• Value property’si A’da var, public, erişilebilir.
• B, A’nın Value’sini doğru şekilde override etmiş (imza aynı).
• x erişimi protected olduğu için B içinde sorun yok.