{"id":2501,"date":"2021-01-22T15:44:14","date_gmt":"2021-01-22T14:44:14","guid":{"rendered":"https:\/\/gdksoftware.com\/knowledgebase\/solid-principles-in-delphi-1-the-single-responsibility-principle"},"modified":"2021-03-24T14:31:46","modified_gmt":"2021-03-24T13:31:46","slug":"solid-principles-in-delphi-1-het-single-responsibility-principle","status":"publish","type":"knowledge","link":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle","title":{"rendered":"SOLID-principes in Delphi [1] – Het Single Responsibility principe"},"content":{"rendered":"

Het Single Responsibility principe.<\/p>\n

Vandaag duiken we in de S<\/strong> van de Solid principes: Het Single Responsibility Principe. Maar voor we beginnen, even een korte opfrisser over Solid.<\/p>\n

SOLID is een acroniem voor een reeks van vijf principes voor softwareontwikkeling, die, mits goed gevolgd, bedoeld zijn om ontwikkelaars te helpen flexibele en schone code te maken. De vijf principes zijn:<\/p>\n

The Single Responsibility Principle<\/strong> \u2014 Klassen moeten slechts \u00e9\u00e9n verantwoordelijkheid hebben en dus slechts \u00e9\u00e9n reden om te veranderen.<\/p>\n

The Open\/Closed Principle<\/strong> \u2014 Klassen en andere entiteiten moeten openstaan voor uitbreiding, maar gesloten zijn voor wijziging.<\/p>\n

The Liskov Substitution Principle<\/strong> \u2014 Objecten moeten kunnen worden vervangen door hun subtypes.<\/p>\n

The Interface Segregation Principle<\/strong> \u2014 Cli\u00ebnten mogen niet worden gedwongen af te hangen van interfaces die zij niet gebruiken.<\/p>\n

The Dependency Inversion Principle<\/strong> \u2014 Vertrouwen op abstracties in plaats van op concreties.<\/p>\n

\n

Dus, het Single Responsibility principe. Zoals de naam al suggereert, moet elke klasse in een programma \u00e9\u00e9n enkele verantwoordelijkheid hebben voor slechts \u00e9\u00e9n deel van de functionaliteit van het programma. Maar dat lijkt eenvoudiger dan het is. Wat is precies \u00e9\u00e9n deel van een programma, en hoe weet je wanneer je de functionaliteit moet scheiden? Het is te eenvoudig om te zeggen dat een klasse maar \u00e9\u00e9n ding moet doen.<\/p>\n

Robert C. Martin drukt het principe uit als \u2018Verzamel de dingen die om dezelfde redenen veranderen. Scheid de dingen die om verschillende redenen veranderen’<\/strong>, en meer recent \u2018This principle is about people\u2019<\/strong><\/a>. Dat zou ons in de juiste richting moeten wijzen.<\/p>\n

Wanneer je een softwaremodule schrijft, wil je er zeker van zijn dat wanneer wijzigingen worden gevraagd, die wijzigingen slechts afkomstig kunnen zijn van \u00e9\u00e9n enkele persoon, of \u00e9\u00e9n enkele gekoppelde groep mensen die \u00e9\u00e9n nauw omschreven bedrijfsfunctie vertegenwoordigen. Dit betekent dat een softwaremodule of klasse \u00e9\u00e9n verantwoordelijkheid moet hebben voor die bepaalde groep mensen.<\/strong><\/p>\n

Het is gemakkelijker dit uit te leggen aan de hand van een voorbeeld. Laten we eens kijken naar de volgende klasse:<\/p>\n

\n
type<\/span>\r\n  TShip =<\/span> class<\/span>\r\n  private<\/span>\r\n    FPosition:<\/span> TPoint;<\/span>\r\n    FHeading:<\/span> Integer<\/span>;<\/span>\r\n    FSpeed:<\/span> Integer<\/span>;<\/span>\r\n    FCargoLoad:<\/span> string<\/span>;<\/span>\r\n  public<\/span>\r\n    procedure<\/span> SetHeading<\/span>(NewHeading:<\/span> Integer<\/span>);<\/span>\r\n    procedure<\/span> SetSpeed<\/span>(NewSpeed:<\/span> Integer<\/span>);<\/span>\r\n    function<\/span> GetCoordinate<\/span>:<\/span> TPoint;<\/span>\r\n    procedure<\/span> PlotCourse<\/span>;<\/span>\r\n    procedure<\/span> LoadCargo<\/span>(NewCargo:<\/span> string<\/span>);<\/span>\r\n    procedure<\/span> PrintCargo<\/span>;<\/span>\r\n    procedure<\/span> ReportPosition<\/span>;<\/span>\r\n    procedure<\/span> CalculateProfit<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Dit is een klasse die een aantal dingen doet, allemaal over het beheren van de positie en koers van een schip, de lading en wat rapportages. Aangezien dit een kort voorbeeld is om te laten zien hoe je moet denken over het Single Responsibility Principle, moet je niet te veel aandacht besteden aan de details van de code zelf; het gaat om het grote overzicht van de structuur van deze specifieke klasse.<\/p>\n
Ik denk dat we allemaal dit soort ‘God’-klassen kennen. Meestal volgepropt met veel functionaliteit en code, en het beheren van \u00e9\u00e9n bepaald deel of module van je programma. De vraag is, als we enkele veranderingen moeten aanbrengen in deze klasse, hoe kunnen we deze klasse dan refactoren om er zeker van te zijn dat we de dingen die om dezelfde reden veranderen samenbrengen, en de dingen die om verschillende redenen veranderen scheiden.<\/p>\n
Laten we even stoppen en nadenken over verantwoordelijkheden van deze code met betrekking tot de (groep van) mensen. We kunnen een aantal specifieke mensen aanwijzen die enige verantwoordelijkheid zullen dragen met betrekking tot het beheer van het schip, de richting en koers, en de rapportage-instrumenten. Laten we zeggen dat we in dit geval een schipper, een navigator, een ladingmeester en een financieel manager defini\u00ebren. Als je aan deze verschillende rollen denkt, is het opeens heel gemakkelijk om deze klasse in verschillende modules te verdelen, met slechts \u00e9\u00e9n verantwoordelijkheid voor die bepaalde rol. We zouden een klasse moeten hebben voor het bepalen van de koers en het vermogen (schipper), een voor het beheren van de positie en het uitzetten van de koers van het schip (navigator), een voor het beheren van de lading van dit schip (ladingmeester), en een voor al onze (financi\u00eble) rapportage (financieel manager).<\/p>\n
Onze nieuwe klassen zouden er nu als volgt uit kunnen zien:<\/p>\n
\n
type<\/span>\r\n  TShipLocation =<\/span> class<\/span>\r\n  private<\/span>\r\n    FPosition:<\/span> TPoint;<\/span>\r\n  public<\/span>\r\n    function<\/span> GetCoordinate<\/span>:<\/span> TPoint;<\/span>\r\n    procedure<\/span> PlotCourse<\/span>;<\/span>\r\n    procedure<\/span> ReportPosition<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TShipMovement =<\/span> class<\/span>\r\n  private<\/span>\r\n    FHeading:<\/span> Integer<\/span>;<\/span>\r\n    FSpeed:<\/span> Integer<\/span>;<\/span>\r\n  public<\/span>\r\n    procedure<\/span> SetHeading<\/span>(NewHeading:<\/span> Integer<\/span>);<\/span>\r\n    procedure<\/span> SetSpeed<\/span>(NewSpeed:<\/span> Integer<\/span>);<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TCargo =<\/span> class<\/span>\r\n  private<\/span>\r\n    FCargoLoad:<\/span> string<\/span>;<\/span>\r\n  public<\/span>\r\n    procedure<\/span> LoadCargo<\/span>(NewCargo:<\/span> string<\/span>);<\/span>\r\n    procedure<\/span> PrintCargo<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TShipReport =<\/span> class<\/span>\r\n  public<\/span>\r\n    procedure<\/span> CalculateProfit<\/span>;<\/span>\r\n  end<\/span>;<\/span>\r\n\r\n  TShip =<\/span> class<\/span>\r\n  private<\/span>\r\n  public<\/span>\r\n    \/\/ reference to subclasses<\/span>\r\n  end<\/span>;<\/span>\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Zou je dat ook gedaan hebben als je niet dacht aan de mensen achter de verantwoordelijkheden van de klasse? Misschien, maar ik kan me voorstellen dat de ShipLocation en ShipMovement klasse in dezelfde klasse terecht hadden kunnen komen.<\/p>\n
Dus, wat gebeurt er nu als we een feature request krijgen van de schipper om een boegschroef toe te voegen om het schip makkelijker te kunnen sturen in kleine kanaaltjes? Breng deze wijziging gewoon aan in de ShipMovement klasse, zonder de andere klassen te be\u00efnvloeden. En als we een nieuw ladingsysteem willen implementeren? Verander gewoon de Cargo klasse, wederom zonder de andere klassen aan te tasten.<\/p>\n
Ik hoop dat je nu ziet waarom het single responsibility principe eigenlijk over mensen gaat, of actors, en de verantwoordelijkheid van de functionaliteit van modules of klassen van je programma in relatie tot deze mensen. En natuurlijk kun je dit toepassen op verschillende niveaus van je programma, van modules tot klassen tot specifieke functies.<\/p>\n
Als je dit principe altijd in je achterhoofd houdt bij het refactoren of ontwerpen van een module of klasse, dan weet ik zeker dat je code beter onderhoudbaar is en makkelijk te veranderen is.<\/p>\n
 <\/p>\n","protected":false},"featured_media":0,"parent":0,"template":"","class_list":["post-2501","knowledge","type-knowledge","status-publish","hentry","knowledge-category-delphi","knowledge-category-software-ontwikkeling"],"acf":{"author":1398,"type_hero":"compact","hero_image":2492,"hero_image_position":"\"30% 70%\"","hero_title":"SOLID-principes in Delphi [1] - Het principe van \u00e9\u00e9n enkele verantwoordelijkheid","hero_content":"","hero_link":null,"hero_show_h1":false},"yoast_head":"\nSOLID-principes in Delphi [1] - Het Single Responsibility principe - GDK Software<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle\" \/>\n<meta property=\"og:locale\" content=\"nl_NL\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SOLID-principes in Delphi [1] - Het Single Responsibility principe\" \/>\n<meta property=\"og:description\" content=\"Het Single Responsibility principe. Vandaag duiken we in de S van de Solid principes: Het Single Responsibility Principe. Maar voor we beginnen, even een korte opfrisser over Solid. SOLID is een acroniem voor een reeks van vijf principes voor softwareontwikkeling, die, mits goed gevolgd, bedoeld zijn om ontwikkelaars te helpen flexibele en schone code te […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle\" \/>\n<meta property=\"og:site_name\" content=\"GDK Software\" \/>\n<meta property=\"article:modified_time\" content=\"2021-03-24T13:31:46+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Geschatte leestijd\" \/>\n\t<meta name=\"twitter:data1\" content=\"5 minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank\\\/solid-principles-in-delphi-1-het-single-responsibility-principle\",\"url\":\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank\\\/solid-principles-in-delphi-1-het-single-responsibility-principle\",\"name\":\"SOLID-principes in Delphi [1] - Het Single Responsibility principe - GDK Software\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/nl#website\"},\"datePublished\":\"2021-01-22T14:44:14+00:00\",\"dateModified\":\"2021-03-24T13:31:46+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank\\\/solid-principles-in-delphi-1-het-single-responsibility-principle#breadcrumb\"},\"inLanguage\":\"nl-NL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank\\\/solid-principles-in-delphi-1-het-single-responsibility-principle\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank\\\/solid-principles-in-delphi-1-het-single-responsibility-principle#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/gdksoftware.com\\\/nl\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Knowledgebase\",\"item\":\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Software ontwikkeling\",\"item\":\"https:\\\/\\\/gdksoftware.com\\\/nl\\\/kennisbank-categorie\\\/software-ontwikkeling\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"SOLID-principes in Delphi [1] – Het Single Responsibility principe\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/gdksoftware.com\\\/nl#website\",\"url\":\"https:\\\/\\\/gdksoftware.com\\\/nl\",\"name\":\"GDK Software\",\"description\":\"Zet de stip op je horizon\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/gdksoftware.com\\\/nl?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"nl-NL\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"SOLID-principes in Delphi [1] - Het Single Responsibility principe - GDK Software","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle","og_locale":"nl_NL","og_type":"article","og_title":"SOLID-principes in Delphi [1] - Het Single Responsibility principe","og_description":"Het Single Responsibility principe. Vandaag duiken we in de S van de Solid principes: Het Single Responsibility Principe. Maar voor we beginnen, even een korte opfrisser over Solid. SOLID is een acroniem voor een reeks van vijf principes voor softwareontwikkeling, die, mits goed gevolgd, bedoeld zijn om ontwikkelaars te helpen flexibele en schone code te […]","og_url":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle","og_site_name":"GDK Software","article_modified_time":"2021-03-24T13:31:46+00:00","twitter_card":"summary_large_image","twitter_misc":{"Geschatte leestijd":"5 minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle","url":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle","name":"SOLID-principes in Delphi [1] - Het Single Responsibility principe - GDK Software","isPartOf":{"@id":"https:\/\/gdksoftware.com\/nl#website"},"datePublished":"2021-01-22T14:44:14+00:00","dateModified":"2021-03-24T13:31:46+00:00","breadcrumb":{"@id":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle#breadcrumb"},"inLanguage":"nl-NL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/gdksoftware.com\/nl\/kennisbank\/solid-principles-in-delphi-1-het-single-responsibility-principle#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/gdksoftware.com\/nl"},{"@type":"ListItem","position":2,"name":"Knowledgebase","item":"https:\/\/gdksoftware.com\/nl\/kennisbank"},{"@type":"ListItem","position":3,"name":"Software ontwikkeling","item":"https:\/\/gdksoftware.com\/nl\/kennisbank-categorie\/software-ontwikkeling"},{"@type":"ListItem","position":4,"name":"SOLID-principes in Delphi [1] – Het Single Responsibility principe"}]},{"@type":"WebSite","@id":"https:\/\/gdksoftware.com\/nl#website","url":"https:\/\/gdksoftware.com\/nl","name":"GDK Software","description":"Zet de stip op je horizon","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/gdksoftware.com\/nl?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"nl-NL"}]}},"_links":{"self":[{"href":"https:\/\/gdksoftware.com\/nl\/wp-json\/wp\/v2\/knowledge\/2501","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/gdksoftware.com\/nl\/wp-json\/wp\/v2\/knowledge"}],"about":[{"href":"https:\/\/gdksoftware.com\/nl\/wp-json\/wp\/v2\/types\/knowledge"}],"acf:post":[{"embeddable":true,"href":"https:\/\/gdksoftware.com\/nl\/wp-json\/wp\/v2\/team\/1398"}],"wp:attachment":[{"href":"https:\/\/gdksoftware.com\/nl\/wp-json\/wp\/v2\/media?parent=2501"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}