Wyjaśnij zasadę otwartej / zamkniętej

Jak już wyjaśniłem, zasada otwarta / zamknięta stwierdza, że ​​raz napisanego kodu nie należy modyfikować (oprócz poprawek błędów). Ale jeśli moje reguły biznesowe ulegną zmianie, czy nie powinienem modyfikować kodu wdrażającego te zmiany? Podejrzewam, że nie rozumiem czegoś na temat zasady, ponieważ nie ma to dla mnie sensu.

Jest to prawdopodobnie najtrudniejsza z solidnych zasad do wyjaśnienia. Pozwól mi spróbować. Wyobraź sobie, że napisałeś klasę faktury, która działa idealnie i nie zawiera błędów. Robi PDF faktury.

Następnie ktoś mówi, że chce faktury HTML z linkami. Nie zmieniasz żadnego kodu na fakturze, aby spełnić to żądanie. Zamiast tego tworzysz inną klasę, fakturę HTML, która robi to, czego teraz chce. Korzystasz z dziedziczenia, abyś nie musiał pisać dużo zduplikowanego kodu w fakturze HTML.

Stary kod, który korzystał ze starej faktury, nie jest uszkodzony ani nie jest w żaden sposób naruszony. Nowy kod może korzystać z faktury HTML. (Jeśli wykonasz także Liskov substitutability , L bryły, możesz nadać instancjom HTMLInvoice istniejący kod, który oczekuje instancji Faktury.) Wszyscy żyją długo i szczęśliwie.

Faktura jest zamknięta dla modyfikacji, otwarta na rozszerzenie. Aby to zadziałało, musisz poprawnie napisać Fakturę, btw.

Czy czytałeś artykuł The Open-Closed Principle autorstwa kumpli wujka Boba z ObjectMentor? Myślę, że to jedno z lepszych wyjaśnień.

Istnieje wiele heurystyk związanych z projektowaniem obiektowym. Na przykład „wszystkie zmienne składowe powinny być prywatne” lub „należy unikać zmiennych globalnych”, lub „niebezpieczne jest używanie identyfikacji typu w czasie wykonywania (RTTI)”. Jakie jest źródło tych heurystyk? Co sprawia, że ​​są prawdziwe? Czy zawsze są prawdziwe? Ta kolumna bada zasadę projektowania leżącą u podstaw tej heurystyki - zasadę otwartego zamkniętego.

Jak powiedział Ivar Jacobson: „Wszystkie systemy zmieniają się podczas swoich cykli życia. Należy o tym pamiętać, opracowując systemy, które mają trwać dłużej niż pierwsza wersja. ”Jak możemy tworzyć projekty, które są stabilne w obliczu zmian i będą trwać dłużej niż pierwsza wersja? Bertrand Meyer udzielił nam wskazówek już w 1988 r., Kiedy ukształtował słynną już zasadę otwartego zamknięcia. Parafrazując go:

PODMIOTY OPROGRAMOWANIA (KLASY, MODUŁY, FUNKCJE, ITP.) POWINNY BYĆ OTWARTE NA ROZSZERZENIE, ALE ZAMKNIĘTE NA MODYFIKACJĘ.

Gdy pojedyncza zmiana w programie powoduje kaskadę zmian w zależnych modułach, program ten wykazuje niepożądane atrybuty, które kojarzymy z „złym” projektem. Program staje się kruchy, sztywny, nieprzewidywalny i niemożliwy do ponownego użycia. Zasada otwartego zamknięcia atakuje to w bardzo prosty sposób. Mówi, że powinieneś projektować moduły, które nigdy się nie zmieniają . Gdy wymagania się zmieniają, rozszerzasz zachowanie takich modułów, dodając nowy kod, a nie zmieniając stary, który już działa.

Opis

Moduły zgodne z zasadą otwartego i zamkniętego mają dwa podstawowe atrybuty.

1. Są „otwarte na rozszerzenie”.
   Oznacza to, że zachowanie modułu można rozszerzyć. Możemy sprawić, że moduł będzie zachowywał się w nowy i różny sposób, gdy zmieniają się wymagania aplikacji lub w celu zaspokojenia potrzeb nowych aplikacji.
2. Są „zamknięte na modyfikacje”.
   Kod źródłowy takiego modułu jest nienaruszony. Nikomu nie wolno dokonywać w nim zmian w kodzie źródłowym.

Wydaje się, że te dwa atrybuty są ze sobą sprzeczne. Normalnym sposobem na rozszerzenie zachowania modułu jest dokonywanie zmian w tym module. Uważa się, że moduł, którego nie można zmienić, ma ustalone zachowanie. Jak rozwiązać te dwa przeciwstawne atrybuty?

Abstrakcja jest kluczem ...

Odpowiedź Kate Gregory jest bardzo dobra, ale pod inną sytuację, w której nowy wymóg może być spełniony przez stosunkowo niewielką zmianę w istniejącej Invoiceklasie. Załóżmy na przykład, że do faktury PDF należy dodać nowe pole. Według OCP powinniśmy nadal tworzyć nową podklasę, nawet jeśli nowe pole można dodać do istniejącej implementacji, zmieniając kilka wierszy kodu.

W moim rozumieniu OCP odzwierciedla rzeczywistość lat 80. i wczesnych 90., w których projekty często nawet nie korzystały z kontroli wersji, a tym bardziej miały zautomatyzowane testy regresji lub zalety zaawansowanych narzędzi refaktoryzacyjnych. OCP był próbą uniknięcia ryzyka złamania kodu, który został ręcznie przetestowany i wprowadzony do produkcji. Obecnie mamy lepsze sposoby zarządzania ryzykiem uszkodzenia działającego oprogramowania (a mianowicie systemów kontroli wersji, TDD i testów automatycznych oraz narzędzi do refaktoryzacji).

Osobiście uważam, że tę zasadę należy wziąć ze szczyptą soli. Kod jest organiczny, firmy zmieniają się, a kod zmienia się zgodnie z potrzebami firmy w miarę upływu czasu.

Bardzo trudno mi się skupić na tym, że abstrakcja jest kluczowa. Co jeśli abstrakcja była pierwotnie nieprawidłowa? Co się stanie, jeśli funkcja biznesowa ulegnie znaczącej zmianie?

Ta zasada zasadniczo zapewnia, że ​​ORYGINALNE intencje i zachowanie projektu nigdy się nie zmieniają. To prawdopodobnie działa dla tych, którzy mają publiczne interfejsy API, a ich klienci mają problemy z nadążaniem za nowymi wersjami i niektórymi innymi przypadkowymi przypadkami. Jeśli jednak firma jest właścicielem CAŁEGO kodu, podważam tę zasadę.

Dobre testowanie kodu powinno sprawić, że refaktoryzacja bazy kodu będzie dziecinnie prosta. Oznacza to, że nie ma problemu z pomyłkami - twoje testy pomogą ci lepiej zaprojektować.

Mówiąc, że jeśli nie ma żadnych testów, to zasada jest zdrowa.