Fájlalapú alkalmazások

Ez a cikk a következőre vonatkozik: ✔️ .NET 10 SDK és újabb verziók

A fájlalapú alkalmazások lehetővé teszik a .NET-alkalmazások létrehozását, futtatását és közzétételét egyetlen C#-fájlból anélkül, hogy hagyományos projektfájlt hozna létre. Egyszerű alternatívát kínálnak a hagyományos .NET-projektekhez. Ez a megközelítés leegyszerűsíti a szkriptek, segédprogramok és kis alkalmazások fejlesztését. A .NET SDK automatikusan létrehozza a szükséges projektkonfigurációt a forrásfájlban lévő irányelvek alapján.

A következő fő előnyöket nyújtják:

Egyszerű alkalmazásokhoz csökkentett alapértelmezett kód.
Beágyazott konfigurációjú önálló forrásfájlok.
Alapértelmezés szerint engedélyezve van a natív AOT-közzététel.
Automatikus csomagolás .NET-eszközként.

Ebből a cikkből megtudhatja, hogyan hozhat létre, konfigurálhat és dolgozhat hatékonyan fájlalapú alkalmazásokkal.

Támogatott irányelvek

A fájlalapú alkalmazások előtaggal ellátott irányelveket #: használnak a build konfigurálásához és az alkalmazás futtatásához. A támogatott irányelvek a következők: #:package, #:project, #:propertyés #:sdk. Helyezze ezeket az irányelveket a C# fájl tetejére.

`#:package`

NuGet-csomaghivatkozást ad hozzá az alkalmazáshoz.

#:package Newtonsoft.Json
#:package Serilog@3.1.1
#:package Spectre.Console@*

Megjegyzés:

A verziószám kihagyása a csomagnév után jelenleg csak akkor működik, ha központi csomagkezelést használ egy Directory.Packages.props fájllal. Ellenkező esetben explicit módon adja meg a verziószámot, vagy adja hozzá @* a csomag neve után a legújabb verzió használatához.

`#:project`

Egy projektfájlt tartalmazó másik projektfájlra vagy könyvtárra hivatkozik.

#:project ../SharedLibrary/SharedLibrary.csproj

`#:property`

MSBuild tulajdonságértéket állít be.

#:property TargetFramework=net10.0
#:property PublishAot=false

`#:sdk`

Megadja a használni kívánt SDK-t. Alapértelmezett érték: Microsoft.NET.Sdk.

#:sdk Microsoft.NET.Sdk.Web
#:sdk Aspire.AppHost.Sdk@13.0.2

Parancssori felületi parancsok

A .NET CLI teljes körű támogatást nyújt a fájlalapú alkalmazásokhoz ismerős parancsokkal.

Alkalmazások futtatása

Használja a dotnet run parancsot a --file opcióval egy fájlalapú alkalmazás futtatásához:

dotnet run --file file.cs

Vagy használja a dotnet run fájl nevét követő parancsot:

dotnet run file.cs

Megjegyzés:

Amennyiben egy projektfájl létezik az aktuális munkakönyvtárban, a dotnet run file.cs projektet a --file opció nélkül futtatja, és az file.cs argumentumot a célalkalmazásnak adja át a visszamenőleges kompatibilitás megőrzése érdekében.

Vagy használja a rövidített szintaxist:

dotnet file.cs

Argumentumok átadása

Adjon át argumentumokat az alkalmazásnak a következő után --:

dotnet run file.cs -- arg1 arg2

Csőkód az stdinből

C# kód irányítása közvetlenül a dotnet run-hez a - argumentummal, standard bemenet használatával. Az - argumentum azt jelzi, hogy dotnet run a kódot a standard bemenetből olvassa be a fájl helyett. - Az argumentummal dotnet run nem keres az aktuális munkakönyvtárban más fájlokra, például indítási profilokra. A program létrehozásához és futtatásához továbbra is az aktuális könyvtár a munkakönyvtár.

PowerShell:

'Console.WriteLine("hello from stdin!");' | dotnet run -

Bash:

echo 'Console.WriteLine("hello from stdin!");' | dotnet run -

Ez a módszer hasznos gyors teszteléshez, egyszeri parancsok futtatásához vagy C#-kódot dinamikusan létrehozó rendszerhéj-szkriptekkel való integráláshoz.

Alkalmazások létrehozása

Állítsa össze a fájlalapú alkalmazást a dotnet build következő paranccsal:

dotnet build file.cs

Az SDK létrehoz egy virtuális projektet, és létrehozza az alkalmazást. Alapértelmezés szerint a build kimenete a rendszer ideiglenes könyvtárába kerül a <temp>/dotnet/runfile/<appname>-<appfilesha>/bin/<configuration>/ alá.

Használja a --output opciót a dotnet build parancs mellett, hogy megadjon egy másik elérési utat. Új alapértelmezett kimeneti elérési út definiálásához állítsa be a OutputPath tulajdonságot a fájl tetején a következő irányelv használatával: #:property OutputPath=./output.

Buildkimenetek tisztítása

Távolítsa el a buildösszetevőket a dotnet clean következő paranccsal:

dotnet clean file.cs

Fájlalapú alkalmazások gyorsítótárának törlése a címtárban:

dotnet clean file-based-apps

Az --days opciót az előző paranccsal használva megadhatja, hogy az artefakt mappának hány napig kell használaton kívül legyen az eltávolítás előtt. Az alapértelmezett napok száma 30.

Alkalmazások közzététele

A fájlalapú alkalmazások alapértelmezés szerint engedélyezik a natív AOT-közzétételt, optimalizált, önálló végrehajtható elemeket hozva létre. Tiltsa le ezt a funkciót a fájl tetején lévő hozzáadással #:property PublishAot=false .

dotnet publish A parancs használatával hozzon létre egy független végrehajtható fájlt:

dotnet publish file.cs

A végrehajtható fájl alapértelmezett helye egy artifacts könyvtár a .cs fájl mellett, az alkalmazásról elnevezett alkönyvtárral. Használja a --output opciót a dotnet publish parancs mellett, hogy megadjon egy másik elérési utat.

Csomag eszközként

Csomagolja be a fájlalapú alkalmazást .NET-eszközként a dotnet pack következő paranccsal:

dotnet pack file.cs

A fájlalapú alkalmazások alapértelmezés szerint be vannak állítva PackAsTool=true. Tiltsa le ezt a beállítást úgy, hogy a fájl tetején elhelyezi a #:property PackAsTool=false elemet.

Konvertálás projektté

A fájlalapú alkalmazás konvertálása hagyományos projektté a dotnet project convert következő paranccsal:

dotnet project convert file.cs

Ez a parancs másolatot készít a .cs fájlról, és létrehoz egy .csproj olyan fájlt, amely egyenértékű SDK-elemeket, tulajdonságokat és csomaghivatkozásokat tartalmaz az eredeti fájl irányelvei #: alapján. Mindkét fájl az eredeti .cs fájl mellett található, az alkalmazáshoz elnevezett könyvtárba kerül, amely érintetlen marad.

Függőségek helyreállítása

A fájlban hivatkozott NuGet-csomagok visszaállítása a dotnet restore következő paranccsal:

dotnet restore file.cs

Alapértelmezés szerint a visszaállítás implicit módon fut az alkalmazás létrehozásakor vagy futtatásakor. Azonban az implicit visszaállítás elkerülése érdekében átadhatja a --no-restore mind a dotnet build felépítéséhez, mind a dotnet run futtatásához használható parancsoknak.

Alapértelmezés szerint tartalmazott elemek

A fájlalapú alkalmazások automatikusan tartalmaznak bizonyos fájltípusokat a fordításhoz és a csomagoláshoz.

Alapértelmezés szerint az egyetlen C#-fájl szerepel a fájlban.

A különböző SDK-k más fájltípusokat is tartalmaznak:

Microsoft.NET.Sdk.Web konfigurációs fájlokat tartalmaz *.json .
A nem alapértelmezett SDK-k közé tartoznak a ResX-erőforrásfájlok.

Natív AOT-közzététel

A fájl alapú alkalmazások alapértelmezés szerint engedélyezik a natív előzetes (AOT) fordítást. Ez a funkció optimalizált, önálló végrehajtható elemeket hoz létre gyorsabb indítással és kisebb memóriaigénylel.

Ha le kell tiltania a natív AOT-t, használja a következő beállítást:

#:property PublishAot=false

További információ a natív AOT-ról: Natív AOT-telepítés.

Felhasználói titkos kódok

A fájlalapú alkalmazások a teljes fájl elérési útjának kivonata alapján létrehoznak egy stabil felhasználói titkos kódazonosítót. Ez az azonosító lehetővé teszi, hogy a bizalmas konfigurációt a forráskódtól elkülönítve tárolja.

A felhasználói titkos kódok ugyanúgy érhetők el, mint a hagyományos projektek:

dotnet user-secrets set "ApiKey" "your-secret-value" --file file.cs

A fájlalapú alkalmazások felhasználói titkos kulcsainak listázása:

dotnet user-secrets list --file file.cs

A dotnet user-secrets list parancs kinyomtatja a titkos kulcsok értékét. Ezt a parancsot ne helyezze nyilvános környezetben futó szkriptekbe.

További információ: Az alkalmazás titkos kulcsainak biztonságos tárolása a fejlesztés során.

Profilok indítása

A fájlalapú alkalmazások támogatják az indítási profilokat annak konfigurálásához, hogy az alkalmazás hogyan fut a fejlesztés során. Ahelyett, hogy indítási profilokat helyezne el a Properties/launchSettings.jsonfájlalapú alkalmazásokban, használhatnak a forrásfájllal azonos könyvtárban elnevezett [ApplicationName].run.json lapos indítási beállításokat.

Lapos indítási beállítások fájlja

Hozzon létre egy indítási beállítások fájlt az alkalmazásról elnevezve. Ha például a fájlalapú alkalmazásod app.cs, hozzon létre egy app.run.json-t ugyanabban a könyvtárban:

{
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "https": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Több fájlalapú alkalmazás

Ha több fájlalapú alkalmazás van ugyanabban a könyvtárban, mindegyik alkalmazás saját indítási beállításfájllal rendelkezhet:

📁 myapps/
├── foo.cs
├── foo.run.json
├── bar.cs
└── bar.run.json

Profil kiválasztása

A .NET CLI a következő prioritással választja ki az indítási profilokat:

Az --launch-profile opció által megadott profil.
A környezeti változó által DOTNET_LAUNCH_PROFILE megadott profil.
Az indítási beállítások fájlban definiált első profil.

Futtatás egy adott profillal:

dotnet run app.cs --launch-profile https

Hagyományos indítási beállítások

A fájlalapú alkalmazások a hagyományos Properties/launchSettings.json fájlt is támogatják. Ha mindkét fájl létezik, a hagyományos hely elsőbbséget élvez. Ha mindkét fájl jelen van, a .NET CLI figyelmeztetést naplóz a használt fájl pontosítása érdekében.

Rendszerhéj végrehajtása

Engedélyezze a fájlalapú alkalmazások közvetlen végrehajtását Unix-szerű rendszereken egy shebang sor és végrehajtható engedélyek használatával.

Adjon hozzá egy shebangot a fájl tetején:

#!/usr/bin/env dotnet
#:package Spectre.Console

using Spectre.Console;

AnsiConsole.MarkupLine("[green]Hello, World![/]");

A fájl végrehajthatóvá tétele:

chmod +x file.cs

Futtatás közvetlenül:

./file.cs

Megjegyzés:

Használjon LF vonalvégződéseket ahelyett, hogy CRLF-et használnának, amikor shebangot ad hozzá. Ne tartalmazzon BOM-ot a fájlban.

Implicit buildfájlok

A fájlalapú alkalmazások tiszteletben tartják az MSBuild és NuGet konfigurációs fájlokat ugyanabban a könyvtárban vagy szülőkönyvtárban. Ezek a fájlok befolyásolják, hogy az SDK hogyan hozza létre az alkalmazást. Ügyeljen ezekre a fájlokra a fájlalapú alkalmazások rendszerezése során.

`Directory.Build.props`

Olyan MSBuild tulajdonságokat határoz meg, amelyek a címtárfában lévő összes projektre vonatkoznak. A fájlalapú alkalmazások öröklik ezeket a tulajdonságokat.

`Directory.Build.targets`

Meghatározza az MSBuild-célokat és az egyéni buildlogikát. A fájlalapú alkalmazások a buildelés során hajtják végre ezeket a célokat.

`Directory.Packages.props`

Engedélyezi a központi csomagkezelést a NuGet-függőségekhez. A fájlalapú alkalmazások központilag felügyelt csomagverziókat használhatnak.

`nuget.config`

Konfigurálja a NuGet-csomagforrásokat és -beállításokat. A fájlalapú alkalmazások ezeket a konfigurációkat használják a csomagok visszaállításakor.

`global.json`

A használni kívánt .NET SDK-verziót adja meg. A fájlalapú alkalmazások tiszteletben tartják ezt a verzióválasztást.

Gyorsítótárazás a build alatt

A .NET SDK gyorsítótárazza a build kimeneteket, hogy javítsa a teljesítményt a következő hívások dotnet run során. Ez a gyorsítótárazási rendszer kizárólag a fájlalapú alkalmazásokra jellemző.

A gyorsítótár viselkedése

Az SDK-gyorsítótárak a következő alapján építik ki a kimeneteket:

Forrásfájl tartalma.
irányelv beállítása
SDK-verzió.
Implicit build-fájl létezése és tartalma.

A gyorsítótárazás javítja a build teljesítményét, de zavart okozhat, ha:

Az implicit buildfájlok módosításai nem aktiválják az újraépítéseket.
A fájlok különböző könyvtárakba való áthelyezése nem érvényteleníti a gyorsítótárat.

Áthidaló megoldások

A fájlalapú alkalmazások gyorsítótár-összetevőinek törlése a következő paranccsal:

dotnet clean file-based-apps

Tiszta build kényszerítése a gyorsítótár megkerüléséhez:
```
dotnet clean file.cs
dotnet build file.cs
```

Mappaelrendezési javaslatok

Gondosan rendszerezze a fájlalapú alkalmazásokat, hogy elkerülje a hagyományos projektekkel és implicit buildfájlokkal való ütközéseket.

Projektfájl-kúpok elkerülése

Ne helyezzen fájlalapú alkalmazásokat a projekt címtárstruktúrájába .csproj . A projektfájl implicit buildfájljai és beállításai zavarhatják a fájlalapú alkalmazást.

❌ Nem ajánlott:

📁 MyProject/
├── MyProject.csproj
├── Program.cs
└──📁 scripts/
    └── utility.cs  // File-based app - bad location

✅ Ajánlott:

📁 MyProject/
├── MyProject.csproj
└── Program.cs
📁 scripts/
└── utility.cs  // File-based app - good location

Ügyeljen az implicit fájlokra

A szülőkönyvtárak implicit buildfájljai az alkönyvtárak összes fájlalapú alkalmazására hatással vannak. Különálló könyvtárakat hozhat létre a fájlalapú alkalmazásokhoz, ha különböző buildkonfigurációkra van szüksége.

❌ Nem ajánlott:

📁 repo/
├── Directory.Build.props  // Affects everything below
├── app1.cs
└── app2.cs

✅ Ajánlott:

📁 repo/
├── Directory.Build.props
├──📁 projects/
│   └── MyProject.csproj
└──📁 scripts/
    ├── Directory.Build.props  // Isolated configuration
    ├── app1.cs
    └── app2.cs

Lásd még

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2026-01-08

Megosztás:

Fájlalapú alkalmazások

Támogatott irányelvek

#:package

#:project

#:property

#:sdk

Parancssori felületi parancsok

Alkalmazások futtatása

Argumentumok átadása

Csőkód az stdinből

Alkalmazások létrehozása

Buildkimenetek tisztítása

Alkalmazások közzététele

Csomag eszközként

Konvertálás projektté

Függőségek helyreállítása

Alapértelmezés szerint tartalmazott elemek

Natív AOT-közzététel

Felhasználói titkos kódok

Profilok indítása

Lapos indítási beállítások fájlja

Több fájlalapú alkalmazás

Profil kiválasztása

Hagyományos indítási beállítások

Rendszerhéj végrehajtása

Implicit buildfájlok

Directory.Build.props

Directory.Build.targets

Directory.Packages.props

nuget.config

global.json

Gyorsítótárazás a build alatt

A gyorsítótár viselkedése

Áthidaló megoldások

Mappaelrendezési javaslatok

Projektfájl-kúpok elkerülése

Ügyeljen az implicit fájlokra

Lásd még

Visszacsatolás

További források

`#:package`

`#:project`

`#:property`

`#:sdk`

`Directory.Build.props`

`Directory.Build.targets`

`Directory.Packages.props`

`nuget.config`

`global.json`