Opanowanie zasady DRY: Zastosowanie wzorców projektowych w C# dla czystszego kodu

Kroki i przykład:

1. Kod początkowy: Logika generowania identyfikatora pracownika była bezpośrednio w obsłudze zdarzenia kliknięcia przycisku.

   

2. Kod refaktoryzowany: Tim poprawia metodę, czyniąc ją bardziej elastyczną. Zamiast polegać na konkretnych elementach UI, metoda teraz akceptuje firstName i lastName jako parametry i zwraca wygenerowany identyfikator. Ta zmiana pozwala na użycie metody w różnych kontekstach i elementach UI:

   private string GenerateEmployeeID(string firstName, string lastName)
   {
     string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
     return employeeID;
   }

   private string GenerateEmployeeID(string firstName, string lastName)
   {
     string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
     return employeeID;
   }

   Tim następnie demonstruje, jak ta metoda jest wywoływana z obsługi zdarzenia kliknięcia:

   employeeIdText.Text = GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

   employeeIdText.Text = GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

   Zauważa również, że ta metoda może teraz być używana w innych częściach aplikacji, takich jak przetwarzanie plików CSV z wieloma rekordami pracowników, bez powtarzania kodu.

Kroki i przykład:

1. Tworzenie biblioteki klas:

   • Tim o godzinie (9:47) tworzy nowy projekt biblioteki klas w .NET Framework, nazywając go DRYDemoLibrary.

   • W tej bibliotece definiuje klasę publiczną EmployeeProcessor i przenosi metodę GenerateEmployeeID do tej klasy:

     public class EmployeeProcessor
     {
      public string GenerateEmployeeID(string firstName, string lastName)
      {
         string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
         return employeeID;
      }
     }

     public class EmployeeProcessor
     {
      public string GenerateEmployeeID(string firstName, string lastName)
      {
         string employeeID = firstName.Substring(0, 4) + lastName.Substring(0, 4) + DateTime.Now.Millisecond.ToString();
         return employeeID;
      }
     }

2. Używanie biblioteki klas w projektach:

   • W swoich projektach WinForms (13:18) i WPF (14:00) Tim dodaje odnośnik do biblioteki klas DRYDemoLibrary.

   • Następnie zastępuje stary kod wywołaniami metody GenerateEmployeeID z biblioteki klas:

     EmployeeProcessor processor = new EmployeeProcessor();
     employeeIDText.Text = processor.GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

     EmployeeProcessor processor = new EmployeeProcessor();
     employeeIDText.Text = processor.GenerateEmployeeID(firstNameText.Text, lastNameText.Text);

   • To podejście eliminuje powtarzanie, ponieważ metoda jest teraz utrzymywana w jednym miejscu. Tim demonstruje, że ta sama biblioteka klas może być używana w różnych frameworkach UI (WinForms i WPF) bez powtarzania kodu.

3. Zalety:

   • Spójność: Centralizując logikę w bibliotece klas, Tim zapewnia, że zmiany w logice (np. poprawki błędów) są stosowane równomiernie we wszystkich projektach.

   • Zmniejszone utrzymanie: Zmiany w metodzie trzeba wprowadzać tylko w bibliotece klas, unikając niespójności i zmniejszając koszty utrzymania.

Kroki i przykład:

1. Tworzenie nowego rozwiązania i projektu:

   • Tim o godzinie (17:29) zaczyna od stworzenia nowego rozwiązania dla aplikacji konsolowej, symulując scenariusz, w którym możesz potrzebować użyć DRYDemoLibrary w innym typie projektu, jak usługa Windows lub aplikacja konsolowa.

   • Nazywa nowy projekt ConsoleUI i pokazuje, jak uruchomić podstawową aplikację konsolową.

     class Program
     {
      static void Main(string[] args)
      {
         Console.ReadLine();
      }
     }

     class Program
     {
      static void Main(string[] args)
      {
         Console.ReadLine();
      }
     }

2. Dodawanie odnośnika do biblioteki klas:

   • Tim wyjaśnia, jak dodać odnośnik do DLL DRYDemoLibrary w nowym projekcie. To wymaga przeglądania do pliku DLL w folderze bin projektu biblioteki klas i dodania go do aplikacji konsolowej.

     using DRYDemoLibrary;

     using DRYDemoLibrary;

   • Po dodaniu odnośnika Tim (19:24) używa klasy EmployeeProcessor z biblioteki do generowania identyfikatora pracownika na podstawie danych wejściowych użytkownika.

     Console.WriteLine("What is your first name?");
     string firstName = Console.ReadLine();
     
     Console.WriteLine("What is your last name?");
     string lastName = Console.ReadLine();
     
     EmployeeProcessor processor = new EmployeeProcessor();
     string employeeID = processor.GenerateEmployeeID(firstName, lastName);
     
     Console.WriteLine($"Your employee ID is {employeeID}");

     Console.WriteLine("What is your first name?");
     string firstName = Console.ReadLine();
     
     Console.WriteLine("What is your last name?");
     string lastName = Console.ReadLine();
     
     EmployeeProcessor processor = new EmployeeProcessor();
     string employeeID = processor.GenerateEmployeeID(firstName, lastName);
     
     Console.WriteLine($"Your employee ID is {employeeID}");

3. Uruchamianie aplikacji konsolowej:

   • Tim demonstruje uruchamianie aplikacji konsolowej, aby pokazać, że pomyślnie generuje identyfikator pracownika używając biblioteki. To potwierdza, że ten sam kod z biblioteki klas można ponownie wykorzystywać w różnych projektach.

     

4. Aktualizacja DLL:

   • Tim krótko wspomina, że jeśli DLL się zmieni, można je zaktualizować w projektach, które jej używają. Zauważa, że chociaż to wideo tego nie omawia w szczegółach, używanie paczek NuGet jest zalecanym podejściem do zarządzania i aktualizowania DLL w wielu projektach.

Kluczowe punkty:

1. Tworzenie paczki NuGet:

   • Zamiast ręcznego zarządzania plikami DLL Tim sugeruje stworzenie paczki NuGet dla biblioteki klas. To obejmuje zapakowanie DLL do paczki NuGet i przesłanie jej na serwer NuGet (prywatny lub publiczny).

2. Aktualizacja paczek:

   • Używając paczki NuGet, można zaktualizować bibliotekę we wszystkich projektach, które jej używają, po prostu aktualizując wersję paczki. To zapewnia spójność i zmniejsza ryzyko niezgodności wersji lub brakujących aktualizacji.

3. Zalety:

   • Zarządzanie centralne: Paczki NuGet zapewniają centralizowany sposób zarządzania wersjami bibliotek i zależnościami.

   • Łatwość aktualizacji: Aktualizacja biblioteki w wielu projektach staje się łatwiejsza i bardziej niezawodna.

   • Integracja: NuGet integruje się z różnymi narzędziami i środowiskami deweloperskimi, upraszczając proces zarządzania zależnościami bibliotek.

Początkowe ustawienie testu

Tim zaczyna od uruchamiania testu jednostkowego, który obecnie nie przechodzi z powodu błędu w DLL. Podkreśla znaczenie testów jednostkowych w identyfikacji problemów, nawet gdy kod jest poza głównym rozwiązaniem. Kod oczekiwał wprowadzenia 4-literowego, ale zamiast tego Tim wprowadził 3-literowe imię, które powoduje awarię w pliku DLL, nawet jeśli nie jest bezpośrednio włączony do rozwiązania.

Refaktoryzacja kodu w celu rozwiązania błędów

Aby rozwiązać problem z obsługą imion, Tim refaktoruje kod. Wyjaśnia, jak DRY można zastosować w rozwoju, tworząc nowy projekt biblioteki klas (23:50). To podejście zapewnia, że zmiany wielu obiektów można dokonać raz i efektywnie testować bez powtarzania poprawek.

Dodawanie testów jednostkowych

Tim wprowadza nową klasę testową jako EmployeeProcessorTest w projekcie biblioteki klas i tworzy testy jednostkowe przy użyciu XUnit. Pokazuje, jak stworzyć metodę testową do generowania identyfikatorów pracowników i omawia znaczenie zakładania zależności zamiast polegania na rzeczywistych wartościach.

Pisanie metody testowej

Tim pisze metodę testu jednostkowego pod nazwą GenerateEmployeeID_ShouldCalculate. Ustawia teorię z danymi inline do testowania różnych scenariuszy, zapewniając, że metoda zwraca oczekiwane wyniki. Wyjaśnia również, jak używać Assert.Equal, aby zweryfikować wynik.

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      // Arrange
      var processor = new EmployeeProcessor();

      // Act
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, 8);

      // Assert
      Assert.Equal(expectedStart, actualStart);
   }
}

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      // Arrange
      var processor = new EmployeeProcessor();

      // Act
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, 8);

      // Assert
      Assert.Equal(expectedStart, actualStart);
   }
}

Uruchamianie testu jednostkowego

Tim podkreśla znaczenie zakładania dynamicznych danych, takich jak wartości daty-czasu, aby kontrolować warunki i wyniki testów. Omówił wyzwanie pracy z dynamicznymi ciągami i testowanie różnych scenariuszy, używając kontrolowanych wartości. Następnie uruchomia test jednostkowy, ale zanim to, dodaje dwie paczki NuGet, które są niezbędne do przeprowadzenia testów: xunit.runner.console i xunit.runner.visualstudio.

Po pomyślnym uruchomieniu wszystkich testów dla jednego inline data wynik jest pokazywany w następujący sposób:

Teraz o godzinie (31:30) Tim dodał inne dane inline i zmienił drugi parametr funkcji podłożeń na expectedStart.Length:

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   [InlineData("Tim", "Corey", "TimCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      var processor = new EmployeeProcessor();
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, expectedStart.Length);
      Assert.Equal(expectedStart, actualStart);
   }
}

public class EmployeeProcessorTest
{
   [Theory]
   [InlineData("Timothy", "Corey", "TimoCore")]
   [InlineData("Tim", "Corey", "TimCore")]
   public void GenerateEmployeeID_ShouldCalculate(string firstName, string lastName, string expectedStart)
   {
      var processor = new EmployeeProcessor();
      var actualStart = processor.GenerateEmployeeID(firstName, lastName).Substring(0, expectedStart.Length);
      Assert.Equal(expectedStart, actualStart);
   }
}

Po ponownym uruchomieniu testu jednostkowego o godzinie (32:05) z drugą teorią, test się załamał:

Polepszanie kodu za pomocą metod prywatnych

Aby przestrzegać zasady DRY, Tim dalej refaktoruje kod, tworząc prywatną metodę GetPartOfName w rzeczywistej klasie EmployeeProcessor w ramach DRYDemoLibrary. Ta metoda obsługuje wyodrębnianie części imion, poprawiając ponowne użycie i czytelność kodu. Tim dokonał następujących zmian:

public string GenerateEmployeeID(string firstName, string lastName)
{
   string employeeID = $@"{GetPartOfName(firstName, 4)}{GetPartOfName(lastName, 4)}{DateTime.Now.Millisecond.ToString()}";
   return employeeID;
}

private string GetPartOfName(string name, int numberOfCharacters)
{
   string output = name;

   if (name.Length > numberOfCharacters)
   {
      output = name.Substring(0, numberOfCharacters);
   }

   return output;
}

public string GenerateEmployeeID(string firstName, string lastName)
{
   string employeeID = $@"{GetPartOfName(firstName, 4)}{GetPartOfName(lastName, 4)}{DateTime.Now.Millisecond.ToString()}";
   return employeeID;
}

private string GetPartOfName(string name, int numberOfCharacters)
{
   string output = name;

   if (name.Length > numberOfCharacters)
   {
      output = name.Substring(0, numberOfCharacters);
   }

   return output;
}

Aktualizacja testów jednostkowych

Tim aktualizuje testy jednostkowe, aby odzwierciedlały zmiany w kodzie, takie jak modyfikacja oczekiwanej długości podciągów. Wyjaśnia, jak uruchomienie tych testów pomoże szybko zidentyfikować problemy i potwierdzić, że kod spełnia nowe wymagania. Tim dodaje nowe teorie, a następnie uruchamia testy jednostkowe, aby zweryfikować, czy wyniki są zgodne z oczekiwaniami:

Tworzenie biblioteki .NET Standard

Redukowanie powtórzeń w rozwoju

Tim Corey podkreśla, że poprzez przyjęcie biblioteki .NET Standard, minimalizujesz powtarzalność kodu nie tylko w bazie kodu, ale także w procesie rozwoju. Zamiast dublować kod w ramach różnych projektów specyficznych dla platformy, centralizujesz go w jednej bibliotece, która działa w wielu środowiskach.

Zalety:

• Ujednolicona baza kodu: Jedna baza kodu dla różnych platform zmniejsza wysiłek wymagańy do utrzymania i aktualizacji kodu.
• Uproszczone testowanie: Z biblioteką .NET Standard możesz pisać testy jednostkowe raz i zapewnić ich zastosowanie do wszystkich obsługiwanych platform.

Testowanie i debugowanie: Tim wprowadza testy jednostkowe jako sposób na dalsze zmniejszenie wysiłku i powtarzalności. Testy zautomatyzowane weryfikują poprawność kodu bez potrzeby ręcznego testowania każdej iteracji aplikacji.