Pola Perintah

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan C# di Coddy. Pelajaran 56 dari 70.

Command pattern adalah pola perilaku yang mengubah permintaan menjadi object mandiri yang berisi semua informasi tentang permintaan tersebut. Transformasi ini memungkinkan kamu meneruskan permintaan sebagai argumen method, mengantrekannya, mencatatnya, atau mendukung operasi yang bisa dibatalkan.

Pola ini memisahkan object yang memanggil suatu operasi dari object yang tahu cara menjalankannya. Pola ini terdiri dari empat komponen utama: interface perintah, perintah konkret, receiver (object yang melakukan pekerjaan sebenarnya), dan invoker (object yang memicu perintah).

public interface ICommand
{
    void Execute();
}

public class Light  // Penerima
{
    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();
}

Invoker menyimpan dan menjalankan perintah tanpa mengetahui apa yang dilakukan perintah tersebut:

public class RemoteControl  // Pemanggil
{
    private ICommand _command;
    
    public void SetCommand(ICommand command) => _command = command;
    
    public void PressButton() => _command.Execute();
}

// Penggunaan
var light = new Light();
var remote = new RemoteControl();

remote.SetCommand(new TurnOnCommand(light));
remote.PressButton();  // Light menyala

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

Pola Command sangat berguna untuk menerapkan fungsi pembatalan, merekam makro, atau mengantrekan operasi untuk dijalankan nanti. Setiap perintah merangkum semua hal yang diperlukan untuk melakukan suatu tindakan, sehingga sistemmu menjadi lebih fleksibel dan mudah dikembangkan.

Tantangan

Mudah

Mari buat sistem perintah editor teks menggunakan pola Command. Kamu akan membuat sistem yang mengemas operasi penyuntingan seperti menyisipkan dan menghapus teks sebagai object perintah, sehingga editor dapat menjalankannya melalui antarmuka terpadu.

Kamu akan mengatur kodemu di tiga file:

Command.cs: Definisikan antarmuka ICommand di namespace TextEditor dengan satu method Execute(). Lalu buat dua class perintah konkret:
- InsertCommand - menerima Document dan string text di konstruktornya. Saat dijalankan, perintah ini menambahkan teks ke dokumen dan mencetak Inserted: {text}
- DeleteCommand - menerima Document dan int count di konstruktornya. Saat dijalankan, perintah ini menghapus count karakter terakhir dari dokumen dan mencetak Deleted: {count} characters
Document.cs: Buat class Document di namespace yang sama. Ini adalah penerima, yaitu object yang benar-benar menjalankan operasi teks. Class ini harus memiliki:
- Field string privat untuk menyimpan konten, dengan nilai awal berupa string kosong
- Method Append(string text) yang menambahkan teks ke konten
- Method RemoveLast(int count) yang menghapus count karakter terakhir. Jika count melebihi panjang konten, hapus seluruh konten
- Method GetContent() yang mengembalikan konten saat ini
Program.cs: Buat class Editor yang bertindak sebagai pemanggil. Class ini harus memiliki method SetCommand(ICommand command) dan method ExecuteCommand() yang menjalankan perintah saat ini. Dalam kode utama, tunjukkan pola Command dengan memproses serangkaian operasi penyuntingan.

Kamu akan menerima input berikut:

Jumlah perintah yang akan dijalankan
Untuk setiap perintah: tipe perintah (insert atau delete), diikuti teks yang akan disisipkan atau jumlah karakter yang akan dihapus

Setelah menjalankan semua perintah, cetak konten akhir dokumen pada baris baru dengan format Content: {content}.

Contohnya, jika inputnya adalah:

4
insert
Hello
insert
 World
delete
3
insert
!

Outputnya akan seperti berikut:

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

Perhatikan bahwa Editor (pemanggil) tidak mengetahui apa pun tentang manipulasi teks. Class ini hanya menjalankan perintah yang diberikan kepadanya. Perintah-perintah tersebut mengemas tindakan sekaligus penerimanya, sehingga kamu dapat menambahkan operasi baru seperti ReplaceCommand dengan mudah tanpa mengubah editor!

Coba sendiri

using System;
using TextEditor;

// TODO: Buat class Editor (pemanggil)
public class Editor
{
    // TODO: Tambahkan field privat untuk menyimpan perintah saat ini
    private ICommand _command;

    // TODO: Implementasikan method SetCommand
    public void SetCommand(ICommand command)
    {
        // TODO: Simpan perintah
    }

    // TODO: Implementasikan method ExecuteCommand
    public void ExecuteCommand()
    {
        // TODO: Jalankan perintah saat ini
    }
}

class Program
{
    public static void Main(string[] args)
    {
        // Baca jumlah perintah
        int n = Convert.ToInt32(Console.ReadLine());

        // Buat dokumen (penerima)
        Document document = new Document();

        // Buat editor (pemanggil)
        Editor editor = new Editor();

        // TODO: Proses setiap perintah
        for (int i = 0; i < n; i++)
        {
            string commandType = Console.ReadLine();

            // TODO: Berdasarkan commandType, buat perintah yang sesuai
            // - Jika "insert": baca teks dan buat InsertCommand
            // - Jika "delete": baca jumlahnya dan buat DeleteCommand
            // Lalu tetapkan perintah pada editor dan jalankan
        }

        // TODO: Cetak konten akhir dengan format "Content: {content}"
    }
}