.NET Core alapok

A bejegyzés egy rövid betekintést kíván nyújtani a .NET Core alapjaiba, bemutatva néhány újdonságát, illetve összehasonlítva a .NET Frameworkkel.

A .NET Core a .NET egy implementációja a .NET Foundationtől. Míg a .NET Framework kódja kezdetben nem volt elérhető, és csak évekkel később nyitották meg a Reference Source [1] keretein belül, addig a .NET Core fejlesztése során más megközelítést alkalmaztak, így a Core teljesen nyílt forráskódú, kódja a .NET Foundation GitHub repóiban érhető el. Egyelőre még a .NET keretrendszerrel párhuzamosan fejlesztik, azonban később – már csak egyszerűen .NET néven – teljesen fel fogja váltja azt.

A .NET Core egyik jelentős újítása a Frameworkhöz képest, hogy elhozza a platformfüggetlenséget a microsoftos világba. A .NET Framework, illetve a vele készült alkalmazások korábban főképp csak Windows alatt voltak elérhetők, ezzel szemben a .NET Core-os alkalmazások az eddig megszokott windowsos környezet mellett elérhetők lehetnek macOS-en, illetve több különböző Linux-disztribúción is.

A .NET Core felépítése

Felépítése moduláris, két fő részből áll, a CoreCLR-ből, illetve a CoreFX-ből [2]. A runtime és a CoreFX is NuGet csomagokon keresztül érhető el. A CoreFX – vagy .NET Core Base Class Library – a .NET Framework BCL-jének Core-os megfelelője. Funkciók alapján szétbontott csomagokból áll, amelyeken keresztül nagyrészt a System névtérben található osztályok érhetők el, így megtalálható benne például a különböző kollekciókat tartalmazó System.Collections vagy a reflexióhoz használható System.Reflection, de ezeken kívül még számos, a Frameworkből már jól ismert névtérrel találkozhatunk külön NuGet csomagok formájában.

Ennek a megközelítésnek több előnye is van a Framework monolitikus felépítésével szemben. Csak a szükséges csomagokat meghivatkozva növelhető a teljesítmény ahhoz az esethez képest, amikor a teljes keretrendszerrel együtt fölösleges komponensek is megtalálhatók lennének az alkalmazásokban, illetve – mivel a kisebb egységeket jelentő csomagok önmagukban, a teljes keretrendszertől külön is kezelhetők – ilyen módon egyszerűbbé válhat például a frissítésük is.

A .NET Core fejlesztése során nagy hangsúlyt fektettek a teljesítményre, ezért számos helyen tartalmaz teljesítménnyel kapcsolatos optimalizációkat a Frameworkhöz képest. Emellett a .NET Core újabb verziói sok esetben nem csak a Framework, hanem a Core előző verzióihoz képest is tartalmaznak teljesítménybeli előrelépést.

.NET Standard

A .NET Core implementálja a .NET Standard-et. A .NET Standard [3] nem egy keretrendszer, és nem is tartalmaz implementációt, hanem egy specifikáció, amit a különböző keretrendszerek megvalósíthatnak. A .NET Standard előírja az azt implementáló keretrendszerek számára, hogy milyen Base Class Library API-kat kell megvalósítani egy adott verziójának támogatásához, így egységessé téve az implementációkat. A .NET Standard segítségével megvalósítható a különböző .NET implementációk közti kompatibilitás.

.NET Standard: egységes interfész a .NET különböző implementációi között

A projektek a .NET egyes implementációi mellett magának a .NET Standardnek is megcélozhatják valamelyik verzióját, így elérhetővé válhatnak az összes, a .NET Standard adott verzióját támogató implementáció alatt is. Ennek segítségével például .NET Framework és .NET Core alatt is felhasználható kódrészleteket oszthatunk meg egy .NET Standard-et célzó projekt segítségével. Ilyen módon egyrészt univerzálisabb osztálykönyvtárakat hozhatunk létre, másrészt csökkenthetjük a kódduplikációt is.

Dotnet CLI

A .NET Core-hoz kapcsolódik a dotnet CLI [4] bevezetése is. Ez egy parancssoros eszköz, amelynek segítségével egyszerűen lehet különböző műveleteket parancssoros utasításokkal is végrehajtani. Generálhatunk a használatával például különböző projekteket, amiket képes lefordítani vagy futtatni is, de kezelhetők vele akár az Entity Framework migráció is, illetve a projektekben felhasznált NuGet csomagok is.

A dotnet eszköz számos beépített parancsot tartalmaz, amelyek részletesen paraméterezhetők, így testre tudjuk szabni a működésüket. Lehetőség van arra is, hogy létrehozzunk saját parancsokat is. Ezt többféleképp is megtehetjük, így használhatjuk a path környezeti változót vagy NuGet csomagokon keresztül is létrehozhatjuk a saját parancsainkat.

A dotnet CLI jól használható lehet CI-CD megoldásokhoz, ahol különféle fordítási, publikálási folyamatokat hajthatunk vele végre, de akár alternatívát nyújthat a Visual Studio-ból történő fejlesztésnek, illetve ki is egészítheti azt.

Az alábbi egyszerű példában például létrehozunk egy konzolos és egy class library projektet, amiket hozzáadunk egy szintén újonnan létrehozott solutionhöz, majd lefordítjuk a teljes solutiont és elindítjuk a konzolos alkalmazást:

dotnet new console –n ConsoleApp  
dotnet new classlib –n Lib  
dotnet new sln –n Test  
dotnet sln add ConsoleApp Lib  
dotnet build Test.sln  
dotnet run -p ConsoleApp  

Verziók

A .NET Core első stabil verziója 2016 júniusában jelent meg, jelenleg a 2.2-es az aktuális, a következő főverzió, a 3.0 pedig az idei év második felében érkezik. Az első verziókból még számos, korábban megszokott lehetőség hiányzott, ezek nagy része folyamatosan került bele az újabb kiadásokba.

.NET Core verziótörténet

Ilyen volt például a teljes SignalR csomag, aminek megjelenéséig a .NET Core 2.1-es verziójáig kellett várni, vagy említhető az Entity Framework Core is, ami még mindig számos részletben eltér a 6.3-as verziótól. A különbségek között említhető a több-több kapcsolatok vagy az öröklési hierarchia kezelése, ahol vannak nem támogatott funkciók a korábbi változathoz képest.

A .NET Core fejlődése azonban folyamatos, és nem kizárólag a Framework alatt meglévő funkciók implementálásáról szól, hanem újdonságok is megjelennek .NET Core alatt, amelyeknek egy része akár Framework alatt is elérhetővé válhat a későbbiekben.

Fontos megjegyezni, hogy a .NET Core nem fogja támogatni a .NET Framework teljes funkcionalitását, így egyes régebbi technológiák – mint például a Web Forms – nem lesznek átportolva Core alá.

A .NET Frameworkből többnyire csak egy verziót telepíthettünk egyszerre, azonban ez a Core bevezetésével megváltozott. Mivel a .NET Core támogatja a side-by-side telepítést is, így az SDK-nak, illetve a Runtime-nak egymás mellett több különböző verziója is telepítve lehet egy gépen.

Újdonságok a projektekben

Első ránézésre nincsenek hatalmas különbségek egy .NET Frameworkös és .NET Core-os projekt között, a felépítésük hasonló, nagyrészt ugyanazokkal a névterekkel és osztályokkal találkozhatunk mindkét keretrendszerben.

Főbb, szemmel is látható különbség a projekteket leíró csproj fájl új verziójában [5] és a függőségek kezelésében van. A csproj felépítése egyszerűbb, és ezzel együtt jóval rövidebb is lett a korábbi változatnál.

Az egyik fő változás, hogy a csproj már nem tartalmazza egyesével a projekt alá tartozó fájlokat, hanem a projekt mappájába másolt fájlok automatikusan a projekt részei lesznek. Így egy új fájl bemásolása után már nem kell kézzel hozzáadni ahhoz, hogy az a projekthez tartozzon. Új bejegyzés a csproj-ba csak akkor fog bekerülni, ha az a tartalmazáson kívül valami mást is jelez, például ha egy fájlon beállítjuk, hogy fordításkor mindig kerüljön a kimenetbe. De akkor is megjelenik a fájl a csproj-ban, ha eltávolítani szeretnénk azt a projektből.

Megszűnt a felhasznált NuGet csomagokat tartalmazó packages.config fájl, helyét a csproj-ban található PackageReference bejegyzések vették át. Ezzel kapcsolatos változás az is, hogy alapértelmezés szerint a letöltött NuGet-ek már nem solution-önként fognak külön mappába kerülni, hanem egy közös, a C:\Users-en belül elérhető globális helyen lesznek megtalálhatók.

Az alábbi csproj fájl egy üres, az alap Program.cs-t és két szöveges fájlt tartalmazó konzolos projekthez tartozik, amiben telepítve van az EPPlus. A régi verzió esetében ugyanez nagyjából kétszer ilyen hosszú lenne.

Látható, hogy a Program.cs nincs külön megemlítve, illetve az EPPlus függőségei sem jelennek meg. Csak a projekt típusa (.NET Core 2.2), a debug módban definiált TRACE és TEST konstansok, illetve az EPPlus csomag jelenik meg benne. A TextFile1 a beállított Copy Always miatt került be a csproj-ba, az TextFile2 pedig el lett távolítva magából a projektből, ezért jelenik meg.

<Project Sdk="Microsoft.NET.Sdk">  
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
    <DefineConstants>TRACE;TEST</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <None Remove="Assets\TextFile2.txt" />
  </ItemGroup>
  <ItemGroup>
    <PackageReference Include="EPPlus" Version="4.5.3.1" />
  </ItemGroup>
  <ItemGroup>
    <None Update="Assets\TextFile1.txt">
      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
    </None>
  </ItemGroup>
</Project>  

Összegzés

A .NET Core a Microsoft platformfüggetlen, nyílt forráskódú keretrendszere, amelynek fejlesztése során számos esetben más megközelítést alkalmaztak a .NET Frameworkhöz képest, így új, modernebb alapokra helyezve a .NET-et.

Funkcionalitás szempontjából kezdetben szűkebb lehetőségeket nyújtott a Frameworkkel szemben, azonban a Frameworkben elérhető funkciók egyre nagyobb része válik elérhetővé Core alatt is, illetve újdonságokkal is találkozhatunk az új keretrendszerben.

A .NET Framework a 4.8-as verzió után nem kap már nagyobb frissítéseket, így helyét az újonnan fejlesztett alkalmazások esetében teljesen át fogja venni a .NET Core.

Források

  1. https://referencesource.microsoft.com/
  2. https://github.com/dotnet/corefx
  3. https://docs.microsoft.com/en-us/dotnet/standard/net-standard
  4. https://docs.microsoft.com/en-us/dotnet/core/tools/?tabs=netcore2x
  5. https://docs.microsoft.com/en-us/dotnet/core/tools/csproj