Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Beschrijf de architectuur van uw app op hoog niveau door afhankelijkheidsdiagrammen te maken in Visual Studio. Zorg ervoor dat uw code consistent blijft met dit ontwerp door uw code te valideren met een afhankelijkheidsdiagram. U kunt ook laagvalidatie opnemen in uw buildproces.
Als u wilt zien welke edities van Visual Studio deze functie ondersteunen, raadpleegt u Edition-ondersteuning voor architectuur- en modelleringshulpprogramma's.
Opmerking
Afhankelijkheidsdiagrammen voor .NET Core-projecten worden ondersteund vanaf Visual Studio 2019 versie 16.2.
Wat is een afhankelijkheidsdiagram?
Net als een traditioneel architectuurdiagram identificeert een afhankelijkheidsdiagram de belangrijkste onderdelen of functionele eenheden van het ontwerp en hun onderlinge afhankelijkheden. Elk knooppunt in het diagram, een laag genoemd, vertegenwoordigt een logische groep naamruimten, projecten of andere artefacten. U kunt de afhankelijkheden tekenen die in uw ontwerp moeten voorkomen. In tegenstelling tot een traditioneel architectuurdiagram kunt u controleren of de werkelijke afhankelijkheden in de broncode voldoen aan de beoogde afhankelijkheden die u hebt opgegeven. Door een validatieonderdeel van een regelmatige build op Team Foundation Server te maken, kunt u ervoor zorgen dat de programmacode zich blijft houden aan de architectuur van het systeem door toekomstige wijzigingen. Zie Afhankelijkheidsdiagrammen: Naslaginformatie.
Uw app ontwerpen of bijwerken met afhankelijkheidsdiagrammen
De volgende stappen bieden een overzicht van het gebruik van afhankelijkheidsdiagrammen binnen het ontwikkelingsproces. In latere secties in dit onderwerp wordt meer informatie over elke stap beschreven. Als u een nieuw ontwerp ontwikkelt, laat u de stappen weg die verwijzen naar bestaande code.
Opmerking
Deze stappen worden in geschatte volgorde weergegeven. U wilt de taken waarschijnlijk overlappen, de volgorde ervan aanpassen aan uw eigen situatie en ze opnieuw bekijken aan het begin van elke iteratie in uw project.
Maak een afhankelijkheidsdiagram voor de hele toepassing of voor een laag erin.
Definieer lagen die primaire functionele gebieden of onderdelen van uw toepassing vertegenwoordigen. Geef deze lagen een naam op basis van hun functie, bijvoorbeeld 'Presentatie' of 'Services'. Als u een Visual Studio-oplossing hebt, kunt u elke laag koppelen aan een verzameling artefacten, zoals projecten, naamruimten, bestanden enzovoort.
De bestaande afhankelijkheden tussen lagen detecteren.
Bewerk de lagen en afhankelijkheden om het bijgewerkte ontwerp weer te geven dat de code moet weergeven.
Ontwerp nieuwe gebieden van uw toepassing door lagen te maken die de belangrijkste architectuurblokken of onderdelen vertegenwoordigen en afhankelijkheden definiëren om te laten zien hoe elke laag de andere gebruikt.
Bewerk de indeling en het uiterlijk van het diagram om het met collega's te bespreken.
Valideer de code op basis van het afhankelijkheidsdiagram om de conflicten tussen de code en de architectuur die u nodig hebt te markeren.
Werk de code bij zodat deze voldoet aan uw nieuwe architectuur. Code iteratief ontwikkelen en herstructureren totdat tijdens de validatie geen conflicten worden weergegeven.
Voeg laagvalidatie toe aan het buildproces om ervoor te zorgen dat de code blijft voldoen aan uw ontwerp.
Een afhankelijkheidsdiagram maken
Er moet een afhankelijkheidsdiagram worden gemaakt in een modelleringsproject. U kunt een nieuw afhankelijkheidsdiagram toevoegen aan een bestaand modelleringsproject, een nieuw modelleringsproject maken voor het afhankelijkheidsdiagram of een bestaand afhankelijkheidsdiagram kopiëren binnen hetzelfde modelleringsproject.
Belangrijk
Voeg geen bestaand afhankelijkheidsdiagram toe, sleep of kopieer een bestaand afhankelijkheidsdiagram van een modelleringsproject naar een ander modelleringsproject of naar een andere locatie in de oplossing. Een afhankelijkheidsdiagram dat op deze manier wordt gekopieerd, heeft dezelfde verwijzingen als het oorspronkelijke diagram, zelfs als u het diagram wijzigt. Dit voorkomt dat laagvalidatie correct werkt en kan andere problemen veroorzaken, zoals ontbrekende elementen of andere fouten bij het openen van het diagram.
Zie Afhankelijkheidsdiagrammen maken op basis van uw code.
Lagen definiëren om functionele gebieden of onderdelen weer te geven
Lagen vertegenwoordigen logische groepen artefacten, zoals projecten, codebestanden, naamruimten, klassen en methoden. U kunt lagen maken op basis van artefacten uit Visual C# en Visual Basic-projecten, of u kunt specificaties of plannen aan een laag koppelen door documenten, zoals Word-bestanden of PowerPoint-presentaties, te koppelen. Elke laag wordt weergegeven als een rechthoek in het diagram en toont het aantal artefacten dat eraan is gekoppeld. Een laag kan geneste lagen bevatten die specifiekere taken beschrijven.
Als algemene richtlijn noemen lagen volgens hun functie, bijvoorbeeld 'Presentatie' of 'Services'. Als de artefacten nauw van elkaar afhankelijk zijn, plaatst u deze in dezelfde laag. Als de artefacten afzonderlijk kunnen worden bijgewerkt of in afzonderlijke toepassingen kunnen worden gebruikt, plaatst u deze in verschillende lagen.
Aanbeveling
Er zijn bepaalde typen artefacten die u kunt koppelen aan lagen, maar die geen ondersteuning bieden voor validatie voor het afhankelijkheidsdiagram. Als u wilt zien of het artefact validatie ondersteunt, opent u Layer Explorer om de eigenschap Validatie van de artefactkoppeling te onderzoeken. Zie Bestaande afhankelijkheden tussen lagen detecteren.
Wanneer u een onbekende toepassing bijwerkt, kunt u ook codetoewijzingen maken. Met deze diagrammen kunt u patronen en afhankelijkheden detecteren terwijl u de code verkent. Gebruik Solution Explorer om naamruimten en klassen te verkennen, die vaak goed overeenkomen met bestaande lagen. Wijs deze codeartefacten toe aan lagen door ze vanuit Solution Explorer naar afhankelijkheidsdiagrammen te slepen. Vervolgens kunt u afhankelijkheidsdiagrammen gebruiken om de code bij te werken en consistent te houden met uw ontwerp.
See:
Bestaande afhankelijkheden tussen lagen detecteren
Er bestaat een afhankelijkheid waar een artefact dat is gekoppeld aan één laag een verwijzing heeft naar een artefact dat is gekoppeld aan een andere laag. Een klasse in de ene laag declareert bijvoorbeeld een variabele die een klasse in een andere laag heeft. U kunt bestaande afhankelijkheden detecteren door ze reverse-engineering uit te voeren.
Opmerking
Afhankelijkheden kunnen niet omgekeerd ontworpen worden voor bepaalde soorten objecten. Er worden bijvoorbeeld geen afhankelijkheden omgekeerd ontworpen van of naar een laag die is gekoppeld aan een tekstbestand. Als u wilt zien welke artefacten afhankelijkheden hebben die u kunt reverse-engineeren, klikt u met de rechtermuisknop op een of meer lagen en klikt u vervolgens op Koppelingen weergeven. Bekijk in Layer Explorer de kolom Ondersteuningsvalidatie . Afhankelijkheden worden niet gereverse-engineerd voor artefacten waarvoor in deze kolom Onwaar wordt weergegeven.
Bestaande afhankelijkheden tussen lagen reverse-engineeren
Selecteer één laag of meerdere lagen, klik met de rechtermuisknop op een geselecteerde laag en klik vervolgens op Afhankelijkheden genereren.
Normaal gesproken ziet u enkele afhankelijkheden die niet mogen bestaan. U kunt deze afhankelijkheden bewerken om deze uit te lijnen met het beoogde ontwerp.
Lagen en afhankelijkheden bewerken om het beoogde ontwerp weer te geven
Als u de wijzigingen wilt beschrijven die u wilt aanbrengen in uw systeem of de beoogde architectuur, gebruikt u de volgende stappen om het afhankelijkheidsdiagram te bewerken. U kunt ook enkele herstructureringswijzigingen aanbrengen om de structuur van de code te verbeteren voordat u deze uitbreidt. Zie De structuur van de code verbeteren.
| Van tot | Voer deze stappen uit |
|---|---|
| Een afhankelijkheid verwijderen die niet mag bestaan | Klik op de afhankelijkheid en druk vervolgens op Delete. |
| De richting van een afhankelijkheid wijzigen of beperken | Stel de eigenschap Direction in. |
| Nieuwe afhankelijkheden maken | Gebruik de hulpprogramma's voor afhankelijkheden en bidirectionele afhankelijkheden . Als u meerdere afhankelijkheden wilt tekenen, dubbelklikt u op het hulpprogramma. Wanneer u klaar bent, klikt u op het hulpmiddel Aanwijzer of drukt u op Esc . |
| Opgeven dat artefacten die aan een laag zijn gekoppeld, niet afhankelijk kunnen zijn van de opgegeven naamruimten | Typ de naamruimten in de eigenschap Verboden naamruimte-afhankelijkheden van de laag. Gebruik een puntkomma (;) om de naamruimten te scheiden. |
| Opgeven dat artefacten die zijn gekoppeld aan een laag niet tot de opgegeven naamruimten mogen behoren | Typ de naamruimten in de eigenschap Verboden naamruimten van de laag. Gebruik een puntkomma (;) om de naamruimten te scheiden. |
| Opgeven dat artefacten die zijn gekoppeld aan een laag, moeten behoren tot een van de opgegeven naamruimten | Typ de naamruimte in de eigenschap Vereiste naamruimten van de laag. Gebruik een puntkomma (;) om de naamruimten te scheiden. |
De structuur van de code verbeteren
Wijzigingen herstructureren zijn verbeteringen die geen invloed hebben op het gedrag van de toepassing, maar helpen de code in de toekomst gemakkelijker te wijzigen en uit te breiden. Goed gestructureerde code heeft een ontwerp dat eenvoudig te abstraheren is naar een afhankelijkheidsdiagram.
Als u bijvoorbeeld een laag maakt voor elke naamruimte in de code en vervolgens de afhankelijkheden reverse-engineert, moet er een minimale set afhankelijkheden in één richting tussen de lagen zijn. Als u een gedetailleerder diagram maakt met klassen of methoden als lagen, moet het resultaat ook dezelfde kenmerken hebben.
Als dit niet het geval is, is de code gedurende de hele levensduur moeilijker te wijzigen en is deze minder geschikt voor validatie met behulp van afhankelijkheidsdiagrammen.
Nieuwe gebieden van uw toepassing ontwerpen
Wanneer u begint met het ontwikkelen van een nieuw project of een nieuw gebied in een nieuw project, kunt u lagen en afhankelijkheden tekenen om de belangrijkste onderdelen te identificeren voordat u begint met het ontwikkelen van de code.
Identificeerbare architectuurpatronen weergeven in uw afhankelijkheidsdiagrammen, indien mogelijk. Een afhankelijkheidsdiagram waarin een bureaubladtoepassing wordt beschreven, kan bijvoorbeeld lagen bevatten, zoals Presentatie, Domeinlogica en Gegevensarchief. Een afhankelijkheidsdiagram dat betrekking heeft op één functie binnen een toepassing, kan lagen bevatten, zoals Model, Weergave en Controller.
Maak een code-artefact voor elke laag , zoals een naamruimte, klasse of onderdeel. Hierdoor kunt u de code gemakkelijker volgen en de codeartefacten koppelen aan lagen. Zodra u elk artefact maakt, koppelt u het aan de juiste laag.
U hoeft de meeste klassen en andere artefacten niet te koppelen aan lagen , omdat ze binnen grotere artefacten vallen, zoals naamruimten die u al aan lagen hebt gekoppeld.
Maak een nieuw diagram voor een nieuwe functie. Normaal gesproken zijn er een of meer afhankelijkheidsdiagrammen waarin de hele toepassing wordt beschreven. Als u een nieuwe functie in de toepassing ontwerpt, voegt u de bestaande diagrammen niet toe of wijzigt u deze niet. Maak in plaats daarvan uw eigen diagram dat de nieuwe onderdelen van de code weerspiegelt. De lagen in het nieuwe diagram bevatten mogelijk presentatie-, domeinlogica- en databaselagen voor de nieuwe functie.
Wanneer u de toepassing bouwt, wordt uw code gevalideerd op basis van het algemene diagram en het gedetailleerdere functiediagram.
De indeling voor presentatie en discussie bewerken
Als u lagen en afhankelijkheden wilt identificeren of deze met teamleden wilt bespreken, bewerkt u het uiterlijk en de indeling van het diagram op de volgende manieren:
Wijzig de grootten, vormen en posities van lagen.
De kleuren van lagen en afhankelijkheden wijzigen.
- Selecteer een of meer lagen of afhankelijkheden, klik met de rechtermuisknop en klik vervolgens op Eigenschappen. Bewerk de eigenschap Kleur in het venster Eigenschappen.
De code valideren op basis van het diagram
Wanneer u het diagram hebt bewerkt, kunt u het op elk gewenst moment handmatig valideren of automatisch elke keer dat u bouwt.
See:
Werk de code bij zodat deze voldoet aan de nieuwe architectuur
Normaal gesproken worden fouten weergegeven wanneer u code voor het eerst valideert op basis van een bijgewerkt afhankelijkheidsdiagram. Deze fouten kunnen verschillende oorzaken hebben:
Er wordt een artefact toegewezen aan de verkeerde laag. In dit geval verplaatst u het artefact.
Een artefact, zoals een klasse, gebruikt een andere klasse op een manier die conflicteert met uw architectuur. In dit geval herstructureer u de code om de afhankelijkheid te verwijderen.
Als u deze fouten wilt oplossen, werkt u de code bij totdat er geen fouten meer worden weergegeven tijdens de validatie. Dit is meestal een iteratief proces. Zie Code valideren met afhankelijkheidsdiagrammen voor meer informatie over deze fouten.
Opmerking
Wanneer u de code ontwikkelt of herstructureert, hebt u mogelijk nieuwe artefacten om een koppeling naar het afhankelijkheidsdiagram te maken. Dit is echter mogelijk niet nodig, bijvoorbeeld wanneer u lagen hebt die bestaande naamruimten vertegenwoordigen en de nieuwe code alleen meer materiaal toevoegt aan deze naamruimten.
Tijdens het ontwikkelingsproces wilt u mogelijk enkele gerapporteerde conflicten tijdens de validatie onderdrukken. U kunt bijvoorbeeld fouten onderdrukken die u al hebt aangepakt of die niet relevant zijn voor uw specifieke scenario. Wanneer u een fout onderdrukt, is het een goed idee om een werkitem in Team Foundation te registreren. Zie Code valideren met afhankelijkheidsdiagrammen om deze taak uit te voeren.
Laagvalidatie opnemen in het buildproces
Als u ervoor wilt zorgen dat toekomstige wijzigingen in de code voldoen aan de afhankelijkheidsdiagrammen, moet u laagvalidatie opnemen in het standaardbouwproces van uw oplossing. Wanneer andere teamleden de oplossing bouwen, worden eventuele verschillen tussen de afhankelijkheden in de code en het afhankelijkheidsdiagram gerapporteerd als buildfouten. Zie Code valideren met afhankelijkheidsdiagrammen voor meer informatie over het opnemen van laagvalidatie in het buildproces.