Introduktion till .NET (.NET Core)

Introduktion

Detta är den första modulen i en serie av moduler som jag har skapat för min kurs Programmera .NET(Core) och C#. I denna första modul ska vi gå igenom vad .NET ramverket är för något och vi ska förstå varför vi ska använda det samt så ska vi gå igenom hur vi kommer igång och hur vi använder ramverket.

Så låt oss komma igång!

Vad är .NET?

.NET eller .NET Core som det hette före version 5, är ett öppet Cross Platform ramverk för att skapa applikationer och system som går att köra på Windows, MacOs samt Linux. Med vilket vi kan skapa olika typer av applikationer för olika typer av plattformar. Vi kan t ex använda .NET för att skapa webb applikationer som går att köra på Linux- eller Windows-baserade servrar. Vi kan till och med skapa applikationer som kompileras till en specifik plattform som t ex Android eller iOS.

Det som gör detta möjligt är ett standardiserat bas API som fungerar på alla plattformar och via de olika programmeringsspråken som används för att skapa .NET applikationer. Beroende på vilken typ av applikation som vi väljer att skapa. Finns det extra API'er för den specifika applikationstypen, t ex ASP.NET som innehåller extra API'er för att kunna köras på både Linux och Windows baserade servrar.

Programmeringsspråk som stöds av ramverket

• C# ett modernt objekt orienterat, kraftfullt och typ säkert språk
• Visual Basic är ett tillgängligt och mycket enkelt språk med enkel syntax struktur för att bygga typ säkra och objekt orienterade applikationer.
• F# ett funktionellt programmeringsspråk som gör det lätt att skriva robusta applikationer med hög prestanda.

Applikationer som vi kan skapa med .NET

Med hjälp av ramverket .NET kan vi skapa ett stort antal olika applikationer:

• Webb applikationer
• Desktop applikationer
• Mobil applikationer
• iOT applikationer
• Azure applikationer
• MicrosServices applikationer
• Spel applikationer
• osv...

Den aktuella versionen är version 6 av .NET, version 7 är på gång. Version 7 ligger för lansering under november i år 2022. Version 6 är vad som kallas för Long Term Support(LTS). Övriga versioner utan LTS är vad som kallas för Current versions.

Vad är skillnaden mellan LTS och Current?

Skillnaden är att LTS tillhandahåller support under 3 år medan Current tillhandahåller support under endast 18 månader.

Vad bör vi använda, LTS eller Current?

Mitt råd är att om vi ska bygga eller skapa en applikation eller ett system som ska vara i produktion under en längre tid så bör vi ALLTID eftersträva att använda LTS versioner av ramverket. Om vi behöver skapa mindre eller små applikationer som har en kort livslängd så kan vi använda Current versioner.

När lanserades .NET (Core) ramverket?

Den första versionen (1.0) lanserades 2016 den 27:e juni och efter det så varje ny version adderat ny funktionalitet och stabilitet.

Varför ska vi använda .NET?

Produktivitet

Ramverket ger oss stöd att skapa applikationer snabbt med hög kvalitet. Modernt språkstöd som t ex LINQ(Language Integrated Query) samt en asynkron programmeringsmodell gör oss väldigt produktiva och effektiva.

Bli inte oroliga om Ni inte känner igen begreppen ovan. Vi kommer att gå igenom detta i en senare modul.

Med tillgång till omfattande klass bibliotek, stöd för flera programmeringsspråk samt gemensamma API'er. Tillsammans med kraftfullt stöd ifrån flera utvecklingsverktyg som t ex Visual Code, Visual Studio och JetBrains Rider. Kan vi snabbt komma igång och skapa applikationer med hög prestanda och kvalitet.

Skapa en applikation kör överallt

Med hjälp av .NET kan vi skapa vilken applikationstyp som helst och köra den på vilken som helst av plattformarna som stöds av .NET. Vilket i sin tur innebär att vi som utvecklare kan använda våra kunskaper och återanvända dem oavsett vilken typ av applikation som vi behöver. I och med att vi kan återanvända våra kunskaper blir vi effektivare och snabbare dessutom så tack vare att vi snabbare kan skapa applikationer så blir kostnaden lägre för varje applikation som vi skapar.

Prestanda

.NET är otroligt snabbt vilket innebär att våra applikationer presterar på mycket hög nivå med mindre krav på datorkraft.

.NET's ecosystem

Genom att använda Nuget package manager eller Visual Studio Marketplace så har vi tillgång till ett extremt stort eko system av bibliotek

Open Source

Sist men inte minst är att inte förglömma att .NET är Open Source.

Då har vi gått igenom vad .NET är och varför vi ska använda .NET. Nu är det dags att ta en titt på hur vi kommer igång.

Hur kommer vi gång med .NET?

För att komma igång med .NET utveckling behöver vi tillgång till följande:

• .NET 6.0 SDK
• Ett utvecklingsverktyg(Editor)
  • Visual Studio (gratis)
  • VS Code (gratis)
  • Jetbrains Rider (kostar pengar)
• dotnet cli (valfritt)

Installera .NET 6.0 SDK

Det finns två olika sätt att installera .NET på.
1. Installera Visual Studio för Windows eller för macOS
2. Manuellt hämta installationspaketet och installera det.

Om ni använder Visual Studio 2022 för Windows är chansen väldigt stor att ni redan har .NET 6.0 installerat på era maskiner.

Jag kommer att gå igenom hur vi kan installera .NET 6.0 SDK manuellt. För att få tag i installationspaketet så går vi till https://dotnet.microsoft.com/

När ni gör detta kan det tänkas att startsidan ser annorlunda ut, Microsoft har en benägenhet att titt som tätt ändra utseende på sidan. Lokalisera Download länken och klicka på den. Nu kommer ni att komma till ytterligare en sida där vi ska välja vilket operativsystemet som vi använder och vilken typ av installationspaket som vi vill installera.

I mitt fall så sitter jag med en macOS baserad dator och har valt macOS som operativsystem och väljer .NET 6.0 LTS. Sedan är det bara att klicka på Download och vänta tills installationspaketet är nedladdat. När det är nedladdat så dubbelklickar vi på installationsfilen och följer instruktionerna på skärmen.

Det är allt! nu har vi installerat .NET 6.0 LTS på våra maskiner.

För att bekräfta vår installation kan vi köra följande kommando i ett konsol- eller terminal-fönster:

dotnet --list-sdks

Resultatet visar vilka versioner av .NET SDK'er som vi har installerat. I mitt fall så har jag flera versioner av .NET 6.0 och en Release Candidate av .NET 7.0.

Nästa steg nu är att välja en editor för att kunna skriva kod.

Välja verktyg för att utveckla applikationer

Val av utvecklingsverktyg är ofta baserat på ens egna preferenser(tycke & smak) samt vilket operativsystem som används.

Hursomhelst de tre största och vanligaste utvecklingsverktygen på marknaden är:

• Visual Studio Code
• Visual Studio
• Jetbrains Rider

Visual Studio Code

Är förmodligen den mest populära och omtyckta editorn för att utveckla applikationer med och framförallt webb baserade applikationer. Varför den är så populär beror på att den finns för macOS, Windows samt Linux. Dessutom så är det en editor som vi kan bygga på med extra tillägg när vi behöver mer funktionalitet i verktyget.

Dessutom är den GRATIS! Och det är den som jag använder i princip i 90% av all applikationsutveckling med .NET.

Ni kan hitta VS Code här.

Klicka på knappen Download Visual Studio Code och välj det operativsystem som ni vill installera VS Code för.

Visual Studio

Visual Studio är Microsofts stora flaggskepp för utveckling av applikationer. Med Visual Studio kan vi utveckla alla typer av applikationer alltifrån desktop, webb till mobila applikationer. Nackdelen med Visual Studio är att verktyget är extremt stort och behöver mycket diskutrymme för att installeras. Om man vill ha tillgång till alla applikationsmoduler.

Det finns även en version av Visual Studio för Mac.

Nackdelen är att Visual Studio kräver prenumeration och en årlig avgift om man inte väljer Visual Studio Community Edition.

Ni kan hitta Visual Studio här.

För att installera Visual Studio klicka på Download Visual Studio och välj den version som ni vill ladda ner. Community versionen är gratis.

Jetbrains Rider

Rider ifrån Jetbrains är ett verktyg i samma kategori som Microsoft Visual Studio. Vilket betyder att vi kan utveckla desktop, webb, azure samt mobila applikationer för Android och iOS med Rider. Rider är ett väldigt kraftigt och fantastiskt utvecklingsverktyg. Nackdelen är att det kostar via en årlig prenumeration där första året kostar strax under 2000 kr, sedan sjunker årsavgiften år 2 och år 3.

Jag använder Rider när jag behöver utveckla applikationer som vi ännu inte fått stöd för i VS Code. Som t ex mobila applikationer.

Som sagt vilket verktyg vi använder är baserat på tycke och smak. Jag kommer att använda VS Code för alla kod exempel i denna artikel och i kommande artiklar. Så vill ni följa med och göra samma exempel som jag så rekommenderar jag varmt VS Code.

Nu när vi har gått igenom vilka populära verktyg som finns och valt att installera VS Code så är vi nästan klara att börja skapa applikationer. Det finns en sak till som jag vill gå igenom med er innan vi börjar och det är dotnet cli.

Dotnet CLI

Dotnet CLI eller Dotnet Command Line Interface är ett konsol verktyg som låter oss skapa, kompilera, bygga och köra applikationer ifrån ett konsol fönster eller ett terminal fönster. Dotnet CLI är automatiskt installerat när vi installerade .NET SDK.

Varför använda konsol kommandon när vi har tillgång till grafiska användargränssnitt?

Genom att använda kommandon blir vi mycket mer effektiva och produktiva som utvecklare. Dessutom om vi ska använda VS Code så behöver vi kunna kommandon för att skapa .NET applikationer. VS Code har inga färdiga mallar att använda. I motsats till Visual Studio och Rider.

Så kortfattat, så måste vi kunna hantera de olika kommandona som finns tillgängliga i dotnet CLI!

För att lista vad som finns tillgängligt som kommandon i dotnet cli kan vi skriva följande kommando
dotnet --help

Vad vi får är en lång, lång lista med saker som vi kan utföra med dotnet cli. Detta är enbart en del av kommandon som finns tillgängliga

  add               Add a package or reference to a .NET project.
  build             Build a .NET project.
  build-server      Interact with servers started by a build.
  clean             Clean build outputs of a .NET project.
  format            Apply style preferences to a project or solution.
  help              Show command line help.
  list              List project references of a .NET project.
  msbuild           Run Microsoft Build Engine (MSBuild) commands.
  new               Create a new .NET project or file.
  nuget             Provides additional NuGet commands.
  pack              Create a NuGet package.
  publish           Publish a .NET project for deployment.
  remove            Remove a package or reference from a .NET project.
  restore           Restore dependencies specified in a .NET project.
  run               Build and run a .NET project output.
  sdk               Manage .NET SDK installation.
  sln               Modify Visual Studio solution files.
  store             Store the specified assemblies in the runtime package store.
  test              Run unit tests using the test runner specified in a .NET project.
  tool              Install or manage tools that extend the .NET experience.
  vstest            Run Microsoft Test Engine (VSTest) commands.
  workload          Manage optional workloads.```

Jag kommer inte i denna artikel att gå igenom alla kommandon, utan vi kommer att titta på dessa i kommande artiklar och moduler. Vi kommer alldeles strax att se hur vi kan skapa en applikation med dotnet cli och använda kommandon för att köra applikationer.

Hur skapar vi en dotnet applikation?

Låt oss avsluta denna artikel/modul med att skapa två olika applikationer med dotnet cli. Först ska vi se vad för olika typer av applikationer som vi kan skapa med dotnet cli.

Skriv in följande kommando i ett konsol eller terminal fönster.

dotnet new list

Vad vi får tillbaka är en massiv lista av olika applikationstyper som vi kan skapa.

Template Name                                 Short Name          Language  
--------------------------------------------  ------------------  ---------- 
ASP.NET Core Empty                            web                 [C#],F#   
ASP.NET Core gRPC Service                     grpc                [C#]       
ASP.NET Core Web API                          webapi              [C#],F#   
ASP.NET Core Web App                          webapp,razor        [C#]      
ASP.NET Core Web App (Model-View-Controller)  mvc                 [C#],F#   
ASP.NET Core with Angular                     angular             [C#]       
ASP.NET Core with React.js                    react               [C#]       
Blazor Server App                             blazorserver        [C#]      
Blazor Server App Empty                       blazorserver-empty  [C#]      
Blazor WebAssembly App                        blazorwasm          [C#]      
Blazor WebAssembly App Empty                  blazorwasm-empty    [C#]      
Class Library                                 classlib            [C#],F#,VB
Console App                                   console             [C#],F#,VB
dotnet gitignore file                         gitignore                     
Dotnet local tool manifest file               tool-manifest                 
EditorConfig file                             editorconfig                  
global.json file                              globaljson                    
MSTest Test Project                           mstest              [C#],F#,VB
MVC ViewImports                               viewimports         [C#]      
MVC ViewStart                                 viewstart           [C#]      
NuGet Config                                  nugetconfig                   
NUnit 3 Test Item                             nunit-test          [C#],F#,VB
NUnit 3 Test Project                          nunit               [C#],F#,VB
Protocol Buffer File                          proto                         
Protocol Buffer File                          proto                         
Razor Class Library                           razorclasslib       [C#]      
Razor Component                               razorcomponent      [C#]      
Razor Page                                    page                [C#]      
Solution File                                 sln,solution                  
Web Config                                    webconfig                     
Worker Service                                worker              [C#],F#   
xUnit Test Project                            xunit               [C#],F#,VB

Så låt oss börja med att skapa en enkel konsol applikation. Skriv in följande kommando i konsolfönstret i en katalog där ni vill skapa applikationen.

dotnet new console -n myFirstApp

Flaggan -n betyder name(vilket namn vill vi ge får applikation, dessutom skapas en katalog med samma namn). I detta fallet skapar vi en applikation med namnet myFirstApp i en katalog med samma namn. Tryck sedan på Enter och vänta till kommando prompten visas igen. Navigera in i den nya katalogen.

Om vi nu skriver in följande kommando

dotnet run

Om ni får ett felmeddelande att ingen projektfil hittas så betyder det oftast att vi står i fel katalog.

När applikationen nu körs/exekveras så ser vi i vårt konsol fönster

myFirstApp dotnet run
Hello, World!

Applikationen fungerar🎉!

Låt oss nu skapa en mer avancerad applikation. Så tillbaka i vårt konsol fönster navigera till en katalog där vi ska skapa vår nya applikation. Skriv sedan in följande kommando och tryck sedan på Enter.

dotnet new mvc -n myFirstWebApp

Vad vi vill skapa här är en applikation baserad på ASP.NET MVC(Model View Controller) design mönstret. När applikationen är skapad så navigera in i katalogen som skapades och skriv in följande kommando i konsolfönstret.

dotnet run

När kommandot är klart så ser vi följande rader i vårt konsolfönster.

➜ myFirstWebApp dotnet run
Building...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5172
info: Microsoft.Hosting.Lifetime[0]
      Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
      Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
      Content root path: /Users/michaelgustavsson/Documents/Development/Repos/softtech-dev/blogg/C#/myFirstWebApp

Vad vi har fått nu är en webb applikation som är startad och lyssnar efter anrop på en specifik url. I mitt fall https://localhost:5172, ni kan ha fått en annan port. Kopiera url:en och klistra in den i en webbläsares adress fält och tryck Enter.

Kolla vad vi har skapat med en rad kod via dotnet cli.

Detta är helt fantastiskt, vi har fått en fungerande webb applikation utan att skriva en enda rad kod. Vi har fått en komplett mall för en applikation som kan justera och anpassa efter våra behov. När vi är klara med att beundra vår nya applikation går vi tillbaka till konsol fönstret och trycker på tangent kombinationen Ctrl+C för att stänga webb applikationen.