Komut Kalıbı

Coddy'nin C# Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 56 / 70.

Komut deseni, bir isteği, o istekle ilgili tüm bilgileri içeren bağımsız bir nesneye dönüştüren davranışsal bir desendir. Bu dönüşüm; istekleri metot argümanları olarak iletmenize, kuyruğa almanıza, günlüğe kaydetmenize veya geri alınabilir işlemleri desteklemenize olanak tanır.

Bu kalıp, bir işlemi çağıran nesneyi, işlemi nasıl gerçekleştireceğini bilen nesneden ayırır. Dört temel bileşenden oluşur: bir komut arayüzü, somut komutlar, bir alıcı (asıl işi yapan nesne) ve bir çağırıcı (komutları tetikleyen nesne).

public interface ICommand
{
    void Execute();
}

public class Light  // Alıcı
{
    public void TurnOn() => Console.WriteLine("Light is ON");
    public void TurnOff() => Console.WriteLine("Light is OFF");
}

public class TurnOnCommand : ICommand
{
    private Light _light;
    
    public TurnOnCommand(Light light) => _light = light;
    
    public void Execute() => _light.TurnOn();
}

public class TurnOffCommand : ICommand
{
    private Light _light;
    
    public TurnOffCommand(Light light) => _light = light;
    
    public void Execute() => _light.TurnOff();
}

Çağıran, ne yaptıklarını bilmeden komutları saklar ve yürütür:

public class RemoteControl  // Çağırıcı
{
    private ICommand _command;
    
    public void SetCommand(ICommand command) => _command = command;
    
    public void PressButton() => _command.Execute();
}

// Kullanım
var light = new Light();
var remote = new RemoteControl();

remote.SetCommand(new TurnOnCommand(light));
remote.PressButton();  // Light AÇIK

remote.SetCommand(new TurnOffCommand(light));
remote.PressButton();  // Light KAPALI

Command kalıbı, özellikle geri alma işlevselliğini, makro kaydını veya işlemleri daha sonra yürütülmek üzere sıraya almayı uygulamak için oldukça güçlüdür. Her komut, bir eylemi gerçekleştirmek için gereken her şeyi kapsüller ve bu da sisteminizi daha esnek ve genişletilebilir hâle getirir.

Görev

Kolay

Command kalıbını kullanarak bir metin düzenleyici komut sistemi oluşturalım. Ekleme ve metin silme gibi düzenleme işlemlerinin komut nesneleri olarak kapsüllendiği ve düzenleyicinin bunları birleşik bir arayüz üzerinden çalıştırabildiği bir sistem oluşturacaksın.

Kodunu üç dosyaya ayıracaksın:

Command.cs: ICommand ad alanında tek bir TextEditor metoduna sahip bir Execute() arayüzü tanımla. Ardından iki somut komut sınıfı oluştur:
- InsertCommand - yapıcısında bir Document ve bir string text alır. Çalıştırıldığında metni belgeye ekler ve Inserted: {text} yazdırır
- DeleteCommand - yapıcısında bir Document ve bir int count alır. Çalıştırıldığında belgedeki son count karakteri kaldırır ve Deleted: {count} characters yazdırır
Document.cs: Aynı ad alanında bir Document sınıfı oluştur. Bu sınıf, metin işlemlerini gerçekten gerçekleştiren alıcıdır. Şunlara sahip olmalıdır:
- İçeriği depolamak için özel bir string alan (boş dize olarak başlatılır)
- İçeriğe metin ekleyen bir Append(string text) metodu
- Son RemoveLast(int count) karakteri kaldıran bir count metodu (count içerik uzunluğunu aşarsa tüm içeriği temizle)
- Geçerli içeriği döndüren bir GetContent() metodu
Program.cs: çağıran olarak görev yapan bir Editor sınıfı oluştur. Bu sınıfın bir SetCommand(ICommand command) metodu ve geçerli komutu çalıştıran bir ExecuteCommand() metodu olmalıdır. Ana kodunda, bir dizi düzenleme işlemini işleyerek command kalıbını göster.

Aşağıdaki girdileri alacaksın:

Çalıştırılacak komutların sayısı
Her komut için: komut türü (insert veya delete), ardından eklenecek metin veya silinecek karakter sayısı

Tüm komutları çalıştırdıktan sonra, son belge içeriğini yeni bir satırda Content: {content} biçiminde yazdır.

Örneğin girdiler şöyleyse:

4
insert
Hello
insert
 World
delete
3
insert
!

Çıktı şöyle olmalıdır:

Inserted: Hello
Inserted:  World
Deleted: 3 characters
Inserted: !
Content: Hello Wo!

Editor (çağıran) metin işleme hakkında hiçbir şey bilmez; kendisine verilen komutu çalıştırması yeterlidir. Komutlar hem eylemi hem de alıcıyı kapsüller. Bu sayede düzenleyiciyi değiştirmeden ReplaceCommand gibi yeni işlemler eklemek kolaylaşır!

Kendin dene

using System;
using TextEditor;

// TODO: Editor sınıfını oluşturun (invoker)
public class Editor
{
    // TODO: Mevcut komutu saklamak için özel bir alan ekleyin
    private ICommand _command;

    // TODO: SetCommand metodunu uygulayın
    public void SetCommand(ICommand command)
    {
        // TODO: Komutu saklayın
    }

    // TODO: ExecuteCommand metodunu uygulayın
    public void ExecuteCommand()
    {
        // TODO: Mevcut komutu çalıştırın
    }
}

class Program
{
    public static void Main(string[] args)
    {
        // Komut sayısını oku
        int n = Convert.ToInt32(Console.ReadLine());

        // Belgeyi oluşturun (receiver)
        Document document = new Document();

        // Editörü oluşturun (invoker)
        Editor editor = new Editor();

        // TODO: Her komutu işleyin
        for (int i = 0; i < n; i++)
        {
            string commandType = Console.ReadLine();

            // TODO: commandType değerine göre uygun komutu oluşturun
            // - Eğer "insert" ise: metni oku ve InsertCommand oluştur
            // - Eğer "delete" ise: sayıyı oku ve DeleteCommand oluştur
            // Ardından komutu editöre atayın ve çalıştırın
        }

        // TODO: Nihai içeriği "Content: {content}" formatında yazdırın
    }
}