Zie Scherp Scherper
OefeningenThe Corona filesHandboek backup
  • H0: Introductie
    • Introductie
    • Dit boek in papier?
    • Nuttige extras
  • H1: De eerste stappen
    • Introductie tot C#
    • Werken met Visual Studio
    • Je eerste programma
    • Input verwerken met ReadLine
    • Fouten in je code
    • Kleuren in Console
    • Meer weten
  • H2: De basisconcepten van C#
    • De essentie van C#
    • Datatypes
    • Variabelen
    • Expressies en operators
    • Const(ant)
    • Solutions en projecten
    • Meer weten
  • H3: Tekst gebruiken in code
    • Strings en chars
    • Escape characters
    • Strings samenvoegen
    • Unicode tonen
    • Environment bibliotheek
    • Meer weten
  • H4: Werken met data
    • Casting, conversie en parsing
    • Input verwerken en omzetten
    • Math-library en berekeningen
    • Over afronden
    • Random
    • Debuggen
    • Meer weten
  • H5: Beslissingen
    • Beslissingen intro
    • Booleanse logica en operators
    • If
    • Scope van variabelen
    • Switch
    • enum
    • Meer weten
  • H6: Herhalingen Herhalingen Herhalingen
    • Loops intro
    • While en Do While
    • For
    • Nesting
    • Meer weten
  • H7: Methoden
    • Methoden intro
    • Bibliotheken
    • Geavanceerde methodetechnieken
    • Meer weten
  • H8: Arrays
    • Array principes
    • Arrays en geheugen
    • System.Array
    • Algoritmes met arrays
    • Strings en arrays
    • Arrays en methoden
    • N-dimensionale arrays
    • Jagged arrays
    • Meer weten
  • H9: Object Oriented Programming
    • OOP Intro
    • Klassen en objecten in C#
    • Methoden en access modifiers
    • Full properties
    • Auto-properties
    • DateTime: leren werken met objecten
    • Meer weten
  • H10: Geheugenmanagement, uitzonderingen en namespaces
    • Stack en Heap
    • Objecten en methoden
    • Null en NullReferenceException
    • Namespaces en using
    • Exception handling
    • Waar exceptions plaatsen?
    • Meer weten
  • H11: Gevorderde klasseconcepten
    • Constructors en de default Constructors
    • Overloaded Constructors
    • Object Initializer Syntax
    • Static
    • Meer weten
  • H12: Arrays en klassen
    • Arrays van objecten
    • List
    • Foreach en var
    • Nuttige collection klassen
    • Meer weten
  • H13: Overerving
    • Overerving intro
    • Constructors bij overerving
    • Virtual en override
    • Base keyword
    • Meer weten
  • H14: Gevorderde overervingsconcepten
    • System.Object
    • Abstract
    • Eigen exceptions maken
    • Kennisclips
  • H15: Compositie en aggregatie
    • Compositie
    • this keyword
    • Meer weten
  • H16: Polymorfisme
    • Polymorfisme
    • Polymorfisme in de praktijk
    • Is en As keywords
    • Objecten vergelijken: alles komt samen
    • Meer weten
  • H17: Interfaces
    • Interface intro
    • Interfaces voorbeeld met president
    • Interfaces in de praktijk
    • Interfaces en polymorfisme
    • Meer weten
  • H18: Bestandsverwerking
    • Werken met bestanden
    • Schrijven en lezen
    • FileInfo klasse
    • Klassen serialiseren met json
    • Meer weten
  • Conclusie
    • Je hebt het gehaald
    • En nu?
  • Kennicslips
    • H1 - H8
    • H9 - H17
  • Appendix
    • Visual Studio snippets
    • VS Code for Mac installeren
    • Regions
    • String.Format
    • Out en Ref parameters
    • Operator overloading
    • Expression bodied members
    • Generics
    • struct en record
    • Een installer maken
  • Coding guidelines
    • Afspraken
    • Minpunten voor: Compileert niet
    • Minpunten voor: Klassen in 1 bestand
    • Minpunten voor: Redundante code
    • Minpunten voor: Bladspiegel
    • Minpunten voor: Naamgeving
    • Minpunten voor: goto, break en continue
    • Minpunten voor: Linq gebruiken
    • Minpunten voor: Methoden in methoden
    • Minpunten voor: Toplevel statements
Powered by GitBook
On this page
  • Folderstructuur van een solution
  • Folderstructuur van een project
  • De bin-folder
  • Meerdere projecten
  • Delen met de oma

Was this helpful?

  1. H2: De basisconcepten van C#

Solutions en projecten

PreviousConst(ant)NextMeer weten

Last updated 11 months ago

Was this helpful?

Het wordt tijd om eens te kijken hoe Visual Studio jouw code juist organiseert wanneer je een nieuw project start. Zoals je al hebt gemerkt in de solution Explorer wordt er meer aangemaakt dan enkel een Program.cs codebestand. Visual Studio werkt volgens volgende hiërarchie:

  1. Een solution is een folder waarbinnen één of meerdere projecten bestaan.

  2. Een project is een verzameling (code)bestanden die samen een specifieke functionaliteit vormen en kunnen worden gecompileerd tot een uitvoerbaar bestand, bibliotheek, of andere vorm van output (we vereenvoudigen bewust het concept project in dit handboek).

Wanneer je dus aan de start van een nieuwe opdracht staat en in VS kiest voor "Create a new project" dan zal je eigenlijk aan een nieuwe solution beginnen met daarin één project.

Je bent echter niet beperkt om binnen een solution maar één project te bewaren. Integendeel, vaak kan het handig zijn om meerdere projecten samen te houden. Ieder project bestaat op zichzelf, maar wordt wel logisch bij elkaar gehouden in de solution. Dat is ook de reden waarom we vanaf de start hebben aangeraden om nooit het vinkje "Place solution and project in the same directory" aan te duiden.

Folderstructuur van een solution

Wanneer je in VS een nieuw project start ben je niet verplicht om de "Project name" en "Solution name" dezelfde waarde te geven. Je zal wel merken dat bij het invoeren van de "Project name" de "Solution name" dezelfde invoer krijgt. Je mag echter vervolgens perfect de "Solution name" aanpassen.

Stel dat we een nieuw VS project aanmaken met volgende informatie:

  1. Naam van het project = Opdracht1

  2. Naam van de solution = Huiswerk

En plaatsen deze in de folder C:\Temp.

Wanneer we het project hebben aangemaakt en de Solution Explorer bekijken zien we volgende beeld :

Rechterklik nu op de solution en kies "Open folder in file explorer". Je kan deze optie kiezen bij eender welk item in de solution explorer. Het zal er voor zorgen dat de verkenner wordt geopend op de plek waar het item staat waar je op rechterklikte. Op die manier kan je altijd ontdekken waar een bestand of of folder zich fysiek bevindt op je harde schijf.

We zien nu een tweede belangrijke aspect dat we in deze sectie willen uitleggen: Een solution wordt in een folder geplaatst met dezelfde naam én bevat één .sln bestand. Binnenin deze folder wordt een folder aangemaakt met de naam van het project. Je folderstructuur volgt dus flink de structuur van je solution in VS.

Je kan dus je volledige solution, inclusief het project, openen door in deze folder het .sln bestand te selecteren. Dit .sln bestand zelf bevat echter geen code.

Die laatste zin heeft als gevolg dat je de hele folderstructuur moet verplaatsen indien je aan je solution op een andere plek wilt werken. Open gerust eens een .sln-bestand in notepad en je zal zien dat het bestand onder andere oplijst waar het onderliggende project zich bevindt. Wil je dus je solution doorgeven of mailen naar iemand, zorg er dan voor je de hele foldestructuur doorgeeft, inclusief het .sln bestand en alles folders die er bij horen.

Folderstructuur van een project

Laten we nu eens kijken hoe de folderstructuur van het project zelf is. Rechterklik deze keer op het project in de solution explorer (Opdracht1) en kies weer "Open folder in file explorer".

Hier staat een herkenbaar bestand! Inderdaad, het Program.cs codebestand. In dit bestand staat de actuele code van Opdracht1.

Voorts zien we ook een .csproj bestand genaamd Opdracht1. Net zoals het .sln bestand zal dit bestand beschrijven welke bestanden én folder(s) deel uitmaken van het huidige project. Je kan dit bestand dus ook openen vanuit de verkenner en je zal dan je volledige project zien worden ingeladen in Visual Studio.

Een .cs-bestand rechtstreeks vanuit de verkenner openen werkt niet zoals je zou verwachten. VS zal weliswaar de inhoud van het bestand tonen, maar je kan verder niets doen. Je kan niet compileren, debuggen, enz. De reden is eenvoudig: een .cs bestand op zichzelf is nutteloos. Het heeft pas een bestaansreden wanneer het wordt geopend in een project. Het project zal namelijk beschrijven hoe dit specifieke bestand juist moet gebruikt worden in het huidige project.

De bin-folder

De "obj" folder ga ik in dit handboek negeren. Maar kijk eens wat er in de "bin" folder staat?! Een folder genaamd "debug". In deze folder zal je de gecompileerde (debug-)versie van je huidige project terecht komen. Je zal wat moeten doorklikken tot de binnenste folder (die de naam van de huidige .net versie bevat waarin je compileert).

Je kan in principe vanuit deze folder ook je gecompileerde project uitvoeren door te dubbelklikken op Opdracht1.exe. Je zal echter merken dat het programma ogenblikkelijk terug afsluit omdat het programma aan het einde van de code altijd afsluit. Voeg daarom volgende lijn code toe onderaan in je Main: Console.ReadLine(). Het programma zal nu pas afsluiten wanneer je op Enter hebt gedrukt en de gecompileerde versie kan dus nu vanuit de verkenner gestart worden, hoera!

Merk op dat je de volledige inhoud van deze folder moet meegeven indien je je gecompileerde resultaat aan iemand wilt geven om uit te voeren.

Meerdere projecten

Ik zei net dat een solution meerdere projecten kan bevatten. Maar hoe voeg je een extra project toe? Terwijl je huidige solution open is (waar je een project wenst aan toe te voegen) kies je in het menu voor File->Add->New project...

Je moet nu weer het klassieke proces doorlopen om een console-project aan te maken. Alleen ontbreekt deze keer het "Solution name" tekstveld, daar dit reeds gekend is.

Wanneer je klaar bent zal je zien dat in de solution Explorer een tweede project is verschenen. Als we de folderstructuur van onze solution opnieuw bekijken, zien we dat er een nieuwe folder (Opdracht2) is verschenen met een eigen Program.cs en .csproj-bestand.

Nu rest ons nog één belangrijke stap: selecteren welk project moet gecompileerd en uitgevoerd worden. In de solution explorer kan je zien welk het actieve project is, namelijk het project dat vet gedrukt staat.

Je kan nu op 2 manieren kiezen welk project moet uitgevoerd worden:

Manier 1: Rechterklik in de Solution Explorer op het actief te zetten project en kies voor "Set as startup project."

Manier 2: Bovenaan, links van de groene "compiler/run" knop, staat een selectieveld met het actieve project. Je kan hier een andere project selecteren.

Controleer altijd goed dat je in het juiste Program.cs bestand bent aan het werken. Je zou niet de eerste zijn die maar niet begrijpt waarom de code die je invoert z'n weg niet vindt naar je debugvenster. Inderdaad, vermoedelijk heb je het verkeerde Program.cs bestand open of heb je het verkeerde actieve project gekozen.

Ook nu reeds heb je mogelijk interesse in meerdere projecten in 1 solution. Je kan nu perfect je opdrachten groeperen onder 1 solution, maar toch iedere opdracht mooi gescheiden houden. In de echte wereld gebruikt men meerdere projecten in 1 solution om het overzicht te bewaren en alles zo modulair mogelijk aan te pakken. Denk maar aan een solution met een projecten dat de (unit)testen bevat, een project voor de frontend, en nog een project voor de backend.

Delen met de oma

Om een gecompileerde .NET applicatie te kunnen uitvoeren op een computer heb je nog een .NET runtime nodig. Gebruikers die geen Visual Studio hebben geïnstalleerd hebben deze runtime meestal niet op hun systeem.

Wil je dus dat je oma kan genieten van jouw laatste creatie, zorg er dan voor dat ze de juiste .NET runtime heeft draaien. Je zal haar hier wat mee moeten helpen want je moet de runtime voor die versie waar tegen jouw applicatie is gecompileerd.

Je ziet duidelijk een hiërarchie: bovenaan de solution Huiswerk, met daarin een project Opdracht1, gevuld met informatie zoals het Program.cs bestand. Deze hiërarchie zal je ook terugzien als je via de verkenner vervolgens naar de aangemaakte folder zou gaan.
De hiërarchie anders voorgesteld.
Tip: rechterklikken in veel programma's geeft je vaak toegang tot meer geavanceerde commando's, zo ook in VS.
Merk op dat je mogelijk ook nog verborgen bestanden zal zien, afhankelijk van de instellingen van je verkenner.
Inhoud van bin/debug/net8.0 nadat project werd gecompileerd
Er is geen limiet op het aantal projecten in 1 solution. De enige beperking is de kracht van je computer.
Ook "Existing project..." is een handige actie om te kennen!
Gelukkig kan je zaken dichtklappen m.b.v. driehoekjes naast iedere item.
Tijd om naar Opdracht2 over te schakelen.