Kódtárak fejlesztése a .NET parancssori felülettel

Ez a cikk bemutatja, hogyan írhat kódtárakat a .NET-hez a .NET parancssori felület használatával. A parancssori felület hatékony és alacsony szintű élményt nyújt, amely minden támogatott operációs rendszeren működik. Továbbra is létrehozhat kódtárakat a Visual Studióval, és ha ez az előnyben részesített élmény , tekintse meg a Visual Studio útmutatóját.

Előfeltételek

A számítógépen telepítve kell lennie a .NET SDK-nak .

A dokumentum .NET-keretrendszer verziókkal foglalkozó szakaszaihoz telepítenie kell a Windows rendszerű gépekre telepített .NET-keretrendszer.

Továbbá, ha támogatni szeretné a régebbi .NET-keretrendszer-célokat, telepítenie kell a célcsomagokat vagy a fejlesztői csomagokat a .NET-keretrendszer letöltési oldaláról. Tekintse meg ezt a táblázatot:

A .NET 5+ vagy a .NET Standard megcélzása

A projekt cél-keretrendszerét úgy szabályozhatja, hogy hozzáadja azt a projektfájlhoz (.csproj vagy .fsproj). A .NET 5+ vagy a .NET Standard célzása közötti választásról a .NET 5+ és a .NET Standard című témakörben talál útmutatást.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>
</Project>

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
  </PropertyGroup>
</Project>

Ha .NET-keretrendszer 4.0-s vagy újabb verziót szeretne megcélzni, vagy a .NET Standardban (például a .NET Standardban) elérhető .NET-keretrendszer api-t szeretne használni, olvassa el a következő szakaszokat, és ismerje meg, System.Drawinghogyan lehet többtargetet használni.

A .NET-keretrendszer

Ne feledje, hogy az itt használt .NET-keretrendszer verziók némelyike már nem támogatott. Tekintse meg a .NET-keretrendszer támogatási életciklus-szabályzattal kapcsolatos gyakori kérdéseket a nem támogatott verziókról.

Ha el szeretné érni a fejlesztők és projektek maximális számát, használja a .NET-keretrendszer 4.0-t alapkonfigurációként. A .NET-keretrendszer megcélzásához először használja a megfelelő Target Framework Moniker (TFM) eszközt, amely megfelel a támogatni kívánt .NET-keretrendszer verziónak.

Ezután szúrja be ezt a TFM-et a TargetFramework projektfájl szakaszába. Az alábbiakban például a 4.0-s .NET-keretrendszer céltárat kell írnia:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net40</TargetFramework>
  </PropertyGroup>
</Project>

Ennyi az egész! Bár ez csak .NET-keretrendszer 4-hez készült, használhatja a kódtárat a .NET-keretrendszer újabb verzióiban.

Többtarget

Előfordulhat, hogy meg kell céloznia a .NET-keretrendszer régebbi verzióit, ha a projekt támogatja a .NET-keretrendszer és a .NET-et is. Ebben a forgatókönyvben, ha újabb API-kat és nyelvi szerkezeteket szeretne használni az újabb célokhoz, használjon #if irányelveket a kódban. Előfordulhat, hogy az egyes célplatformokhoz különböző csomagokat és függőségeket kell hozzáadnia, hogy az egyes esetekhez szükséges különböző API-kat is tartalmazza.

Tegyük fel például, hogy van egy kódtára, amely HTTP-en keresztül végez hálózati műveleteket. A .NET Standard és a .NET-keretrendszer 4.5-ös vagy újabb verziói esetén használhatja az osztályt HttpClient a System.Net.Http névtérből. A .NET-keretrendszer korábbi verziói azonban nem rendelkeznek az HttpClient osztálysal, így a névtérből System.Net használhatja az WebClient osztályt ezek helyett.

A projektfájl így nézhet ki:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>netstandard2.0;net40;net45</TargetFrameworks>
  </PropertyGroup>

  <!-- Need to conditionally bring in references for the .NET Framework 4.0 target -->
  <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
    <Reference Include="System.Net" />
  </ItemGroup>

  <!-- Need to conditionally bring in references for the .NET Framework 4.5 target -->
  <ItemGroup Condition="'$(TargetFramework)' == 'net45'">
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Threading.Tasks" />
  </ItemGroup>
</Project>

Itt három fő változást fog látni:

1. A TargetFramework csomópontot lecserélte TargetFrameworksa rendszer, és három TFM-et fejez ki belül.
2. A célnak van egy <ItemGroup> csomópontja, amely net40 egyetlen .NET-keretrendszer referenciát kér le.
3. A célnak net45 van egy <ItemGroup> csomópontja, amely két .NET-keretrendszer hivatkozik.

Előfeldolgozó szimbólumok

A buildrendszer ismeri a következő, irányelvekben #if használt előprocesszorjeleket:

Íme egy példa a célonkénti feltételes fordítás használatára:

using System;
using System.Text.RegularExpressions;
#if NET40
// This only compiles for the .NET Framework 4 targets
using System.Net;
#else
 // This compiles for all other targets
using System.Net.Http;
using System.Threading.Tasks;
#endif

namespace MultitargetLib
{
    public class Library
    {
#if NET40
        private readonly WebClient _client = new WebClient();
        private readonly object _locker = new object();
#else
        private readonly HttpClient _client = new HttpClient();
#endif

#if NET40
        // .NET Framework 4.0 does not have async/await
        public string GetDotNetCount()
        {
            string url = "https://www.dotnetfoundation.org/";

            var uri = new Uri(url);

            string result = "";

            // Lock here to provide thread-safety.
            lock(_locker)
            {
                result = _client.DownloadString(uri);
            }

            int dotNetCount = Regex.Matches(result, ".NET").Count;

            return $"Dotnet Foundation mentions .NET {dotNetCount} times!";
        }
#else
        // .NET Framework 4.5+ can use async/await!
        public async Task<string> GetDotNetCountAsync()
        {
            string url = "https://www.dotnetfoundation.org/";

            // HttpClient is thread-safe, so no need to explicitly lock here
            var result = await _client.GetStringAsync(url);

            int dotNetCount = Regex.Matches(result, ".NET").Count;

            return $"dotnetfoundation.org mentions .NET {dotNetCount} times in its HTML!";
        }
#endif
    }
}

Ha ezzel a projekttel dotnet buildkészíti el a projektet, három könyvtárat fog látni a bin/ mappában:

net40/
net45/
netstandard2.0/

Ezek mindegyike tartalmazza az .dll egyes célfájlok fájljait.

Kódtárak tesztelése a .NET-en

Fontos, hogy több platformon is tesztelhető legyen. A dobozon kívül xUnit vagy MSTest is használható. Mindkettő tökéletesen alkalmas a könyvtár .NET-en való tesztelésére. A megoldás tesztelési projektekhez való beállítása a megoldás szerkezetétől függ. Az alábbi példa feltételezi, hogy a teszt- és forráskönyvtárak ugyanabban a legfelső szintű könyvtárban élnek.

1. Állítsa be a megoldást. Ezt a következő parancsokkal teheti meg:

   mkdir SolutionWithSrcAndTest
   cd SolutionWithSrcAndTest
   dotnet new sln
   dotnet new classlib -o MyProject
   dotnet new xunit -o MyProject.Test
   dotnet sln add MyProject/MyProject.csproj
   dotnet sln add MyProject.Test/MyProject.Test.csproj
   

   Ez projekteket hoz létre, és összekapcsolja őket egy megoldásban. A címtárnak SolutionWithSrcAndTest így kell kinéznie:

   /SolutionWithSrcAndTest
   |__SolutionWithSrcAndTest.sln
   |__MyProject/
   |__MyProject.Test/
   

2. Keresse meg a tesztprojekt könyvtárát, és adjon hozzá egy hivatkozást a MyProject.Test forrásból MyProject.

   cd MyProject.Test
   dotnet add reference ../MyProject/MyProject.csproj
   

3. Csomagok visszaállítása és projektek létrehozása:

   dotnet restore
   dotnet build
   

4. Ellenőrizze, hogy az xUnit fut-e a dotnet test parancs végrehajtásával. Ha az MSTest használatát választotta, akkor az MSTest-konzol futójának kell futnia.

Ennyi az egész! Mostantól parancssori eszközökkel tesztelheti a tárat az összes platformon. Ha most szeretné folytatni a tesztelést, hogy minden be van állítva, a kódtár tesztelése nagyon egyszerű:

1. Módosítsa a tárat.
2. Futtassa a teszteket a parancssorból a tesztkönyvtárban a paranccsal dotnet test .

A parancs meghívásakor dotnet test a kód automatikusan újraépül.

Több projekt használata

A nagyobb kódtárak esetében gyakori igény a funkciók különböző projektekben való elhelyezése.

Képzelje el, hogy olyan könyvtárat szeretne létrehozni, amely idiomatikus C# és F# nyelven használható. Ez azt jelentené, hogy a könyvtár felhasználói természetes módon fogyasztják a C# vagy az F# számára. A C#-ban például a következő módon használhatja a kódtárat:

using AwesomeLibrary.CSharp;

public Task DoThings(Data data)
{
    var convertResult = await AwesomeLibrary.ConvertAsync(data);
    var result = AwesomeLibrary.Process(convertResult);
    // do something with result
}

Az F#-ban a következőhöz hasonló lehet:

open AwesomeLibrary.FSharp

let doWork data = async {
    let! result = AwesomeLibrary.AsyncConvert data // Uses an F# async function rather than C# async method
    // do something with result
}

Az ilyen használati forgatókönyvek azt jelentik, hogy a hozzáférés alatt álló API-knak más struktúrával kell rendelkezniük a C# és az F# esetében. Ennek egyik gyakori módszere, ha egy kódtár összes logikáját egy alapprojektbe számítja, a C# és az F# projektek határozzák meg az adott alapprojektbe betárcsázó API-rétegeket. A szakasz többi része a következő neveket használja:

• AwesomeLibrary.Core – Egy alapvető projekt, amely a kódtár összes logikáját tartalmazza
• AwesomeLibrary.CSharp – Nyilvános API-kat tartalmazó projekt, amelyet C-ben való fogyasztásra szánnak#
• AwesomeLibrary.FSharp – Nyilvános API-kat tartalmazó projekt F nyelven való használatra#

Az alábbi parancsokat futtathatja a terminálon, hogy ugyanazt a struktúrát hozza létre, mint az útmutató:

mkdir AwesomeLibrary && cd AwesomeLibrary
dotnet new sln
mkdir AwesomeLibrary.Core && cd AwesomeLibrary.Core && dotnet new classlib
cd ..
mkdir AwesomeLibrary.CSharp && cd AwesomeLibrary.CSharp && dotnet new classlib
cd ..
mkdir AwesomeLibrary.FSharp && cd AwesomeLibrary.FSharp && dotnet new classlib -lang "F#"
cd ..
dotnet sln add AwesomeLibrary.Core/AwesomeLibrary.Core.csproj
dotnet sln add AwesomeLibrary.CSharp/AwesomeLibrary.CSharp.csproj
dotnet sln add AwesomeLibrary.FSharp/AwesomeLibrary.FSharp.fsproj

Ezzel hozzáadja a fenti három projektet és egy olyan megoldásfájlt, amely összekapcsolja őket. A megoldásfájl létrehozása és a projektek összekapcsolása lehetővé teszi a projektek legfelső szintű visszaállítását és létrehozását.

Projekt–projekt hivatkozás

A projektekre a legjobban úgy hivatkozhat, ha a .NET CLI használatával ad hozzá egy projekthivatkozást. Az AwesomeLibrary.CSharp és az AwesomeLibrary.FSharp projektkönyvtárakban a következő parancsot futtathatja:

dotnet add reference ../AwesomeLibrary.Core/AwesomeLibrary.Core.csproj

A AwesomeLibrary.CSharp és az AwesomeLibrary.FSharp projektfájljai mostantól az AwesomeLibrary.Core-ra fognak hivatkozni célkéntProjectReference. Ezt úgy ellenőrizheti, hogy megvizsgálja a projektfájlokat, és az alábbiakat látja bennük:

<ItemGroup>
  <ProjectReference Include="..\AwesomeLibrary.Core\AwesomeLibrary.Core.csproj" />
</ItemGroup>

Ezt a szakaszt manuálisan is hozzáadhatja minden projektfájlhoz, ha nem szeretné használni a .NET parancssori felületet.

Megoldás strukturálása

A többprojektes megoldások másik fontos eleme a jó átfogó projektstruktúra kialakítása. Tetszés szerint rendszerezheti a kódot, és amíg az egyes projekteket a megoldásfájlhoz dotnet sln addcsatolja, futtathatja és dotnet build a megoldás szintjén is.dotnet restore