Bagaimana untuk menulis kod yang boleh diuji dalam pembangunan C#

Cara menulis kod yang boleh diuji dalam pembangunan C#

Pengenalan:
Dengan pembangunan berterusan pembangunan perisian, pembangunan dipacu ujian (TDD) dan ujian unit telah menjadi kemahiran penting bagi setiap pembangun. Menulis kod yang boleh diuji adalah kunci untuk memastikan kualiti dan kebolehselenggaraan kod. Artikel ini akan memperkenalkan beberapa petua dan amalan terbaik untuk menulis kod yang boleh diuji dalam pembangunan C#, bersama-sama dengan contoh kod khusus.

1. Ikut prinsip SOLID
Prinsip SOLID ialah lima prinsip asas reka bentuk berorientasikan objek. Ia membantu meningkatkan kebolehujian dan kebolehselenggaraan kod. Berikut ialah gambaran ringkas tentang prinsip ini:

1. Prinsip Tanggungjawab Tunggal (SRP): Kelas sepatutnya mempunyai satu sebab sahaja untuknya berubah.
2. Prinsip Tertutup-Terbuka (OCP): Entiti perisian harus boleh dikembangkan dan bukannya mengubah suai kod sedia ada.
3. Prinsip Penggantian Liskov (LSP): Subkelas seharusnya dapat menggantikan kelas induk tanpa tingkah laku yang tidak dijangka.
4. Prinsip Pengasingan Antara Muka (ISP): Pelanggan tidak boleh dipaksa untuk bergantung pada antara muka yang tidak digunakannya.
5. Prinsip Penyongsangan Ketergantungan (DIP): Modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah. Kedua-duanya harus bergantung pada abstraksi.

Mengikut prinsip ini boleh membantu kami menulis kod gandingan rendah yang boleh diuji. . Ini bermakna kita boleh menggunakan objek olok-olok atau ujian gandaan sebagai ganti kebergantungan sebenar untuk ujian unit.

Kod contoh:

public interface IEmailService
{
    void SendEmail(string to, string subject, string body);
}

public class EmailService : IEmailService
{
    public void SendEmail(string to, string subject, string body)
    {
        // 发送电子邮件的实现逻辑
    }
}

public class MyClass
{
    private readonly IEmailService _emailService;

    public MyClass(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void DoSomething()
    {
        // 使用_emailService进行操作
    }
}

// 在单元测试中使用测试替身
[TestClass]
public class MyClassTests
{
    [TestMethod]
    public void DoSomething_ShouldSendEmail()
    {
        var emailServiceMock = new Mock<IEmailService>();
        var myClass = new MyClass(emailServiceMock.Object);

        myClass.DoSomething();

        emailServiceMock.Verify(e => e.SendEmail(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()), Times.Once);
    }
}

3 Tulis kaedah yang boleh diuji

Menulis kaedah yang boleh diuji adalah kunci untuk menulis kod yang boleh diuji. Berikut ialah beberapa petua biasa:

Pisah kaedah kepada unit berfungsi yang kecil dan khusus, yang setiap satunya melakukan satu perkara sahaja.

Elakkan menggunakan kaedah statik dan keadaan global dalam kaedah kerana ia meningkatkan kerumitan kod dan gandingan yang ketat.
Cuba elakkan daripada menggunakan sumber luaran yang sangat digabungkan (seperti pangkalan data, permintaan rangkaian, dsb.) dan alihkan operasi ini untuk memisahkan kelas atau antara muka sebanyak mungkin.
Gunakan pembina berparameter untuk menghantar kebergantungan dan bukannya menciptanya di dalam kaedah.
4. Contoh kod:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public int Divide(int a, int b)
    {
        if (b == 0)
        {
            throw new DivideByZeroException();
        }

        return a / b;
    }
}

// 单元测试
[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void Add_ShouldReturnSum()
    {
        var calculator = new Calculator();

        var result = calculator.Add(2, 3);

        Assert.AreEqual(5, result);
    }

    [TestMethod]
    public void Divide_ShouldThrowDivideByZeroException()
    {
        var calculator = new Calculator();

        Assert.ThrowsException<DivideByZeroException>(() => calculator.Divide(5, 0));
    }
}

Ringkasan:

Menulis kod yang boleh diuji adalah sangat penting untuk memastikan kualiti perisian dan kebolehselenggaraan. Mengikuti prinsip SOLID, menggunakan suntikan kebergantungan dan menulis kaedah yang boleh diuji adalah langkah utama. Dengan petua dan amalan terbaik ini, kami boleh menulis kod C# yang lebih mantap dan boleh diuji.

Rujukan:


Martin, Robert C. "Kod Bersih: Buku Panduan Ketukangan Perisian Tangkas, 2008.

Freeman, Steve, dan Nat Pryce "Perisian Berorientasikan Objek Berkembang,. " Addison-Wesley, 2009.

Atas ialah kandungan terperinci Bagaimana untuk menulis kod yang boleh diuji dalam pembangunan C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!