C# előfeldolgozási irányelvek

Bár a fordító nem rendelkezik külön előfeldolgozóval, az ebben a szakaszban leírt irányelveket úgy dolgozza fel, mintha lenne ilyen. Ezekkel az irányelvekkel segíthet a feltételes fordításban. A C és C++ direktíváktól eltérően nem használhatja ezeket az irányelveket makrók létrehozásához. Az előfeldolgozó direktívának kell lennie az egyetlen utasításnak egy sorban.

A C# nyelv referenciadokumentuma a C# nyelv legújabb kiadású verzióját ismerteti. Emellett a közelgő nyelvi kiadás nyilvános előzetes verziójú funkcióinak kezdeti dokumentációját is tartalmazza.

A dokumentáció azonosítja azokat a funkciókat, amelyeket először a nyelv utolsó három verziójában vagy az aktuális nyilvános előzetes verziókban vezetnek be.

Jótanács

Ha meg szeretné tudni, hogy mikor jelent meg először egy funkció a C#-ban, tekintse meg a C# nyelvi verzióelőzményeiről szóló cikket.

Fájlalapú alkalmazások

A fájlalapú alkalmazások olyan programok , amelyeket a (vagy bármely fájl) használatával dotnet run Program.cs lefordíthat és futtathat *.cs . A C#-fordító figyelmen kívül hagyja ezeket az előfeldolgozási irányelveket, de a buildelési rendszer elemzi őket a kimenet létrehozásához. Ezek az irányelvek figyelmeztetéseket generálnak, amikor egy projektalapú összeállításban találkoznak.

A C#-fordító figyelmen kívül hagyja azokat az előfeldolgozási irányelveket, amelyek a következővel #: kezdődnek: vagy #!.

Az #! előfeldolgozási irányelv lehetővé teszi, hogy a Unix-rendszerhéjak közvetlenül végrehajtsa a C#-fájlokat a használatával dotnet run. Példa:

#!/usr/bin/env dotnet run
Console.WriteLine("Hello");

Az előző kódrészlet tájékoztatja a Unix-rendszerhéjat, hogy végrehajtsa a fájlt a használatával dotnet run. A /usr/bin/env parancs megkeresi a futtatható fájlt a PATH-ban, így ez a dotnet módszer hordozhatóvá válik a különböző Unix- és macOS-disztribúciókban. A #! sornak kell lennie a fájl első sorának, és a következő tokenek alkotják a futtatandó programot. Engedélyeznie kell a C#-fájl végrehajtási (x) engedélyét a funkcióhoz.

A #: fájlalapú alkalmazásokban használt irányelveket a fájlalapú alkalmazásokra vonatkozó referencia ismerteti.

Más eszközök új jogkivonatokat adhatnak hozzá a #: konvenciót követően.

Null értékű környezet

Az #nullable előfeldolgozási irányelv beállítja a széljegyzeteket és figyelmeztető jelzőket a null értékű környezetben. Ez az irányelv szabályozza, hogy a null értékű széljegyzetek érvénybe lépnek-e, és hogy vannak-e null értékű figyelmeztetések. Mindegyik zászló le van tiltva vagy engedélyezve van.

Mindkét környezetet megadhatja a projekt szintjén (a C# forráskódján kívül), ha hozzáadja az Nullable elemet az PropertyGroup elemhez. A #nullable irányelv szabályozza a széljegyzeteket és a figyelmeztető jelzőket, és elsőbbséget élvez a projektszintű beállításokkal szemben. Az irányelv beállítja az általa vezérelt jelzőt, amíg egy másik irányelv felül nem bírálja azt, vagy a forrásfájl végéig.

Az irányelvek hatása a következő:

#nullable disable: A null értékű környezet beállítása letiltott.
#nullable enable: A null értékű környezet beállítása engedélyezett.
#nullable restore: Visszaállítja a nullázható környezetet a projektbeállításokhoz.
#nullable disable annotations: A null értékű környezetben a széljegyzetek jelzőjének beállítása letiltott.
#nullable enable annotations: Beállítja a megjegyzések jelzőjét a nullázható környezetben engedélyezett.
#nullable restore annotations: Visszaállítja a null értékű környezetben lévő széljegyzetjelzőt a projektbeállításokra.
: A null értékű környezet figyelmeztető jelzőjeletiltva .
#nullable enable warnings: A nulla értékű környezet figyelmeztető jelzőjének beállítása bekapcsolva.
#nullable restore warnings: Visszaállítja a figyelmeztető jelzőt a null értékű környezetben a projektbeállításokra.

Feltételes fordítás

A feltételes fordítás szabályozásához használjon négy előfeldolgozási utasítást:

#if: Feltételes fordítás indítása. A fordító csak akkor fordítja le a kódot, ha a megadott szimbólum meg van határozva.
#elif: Bezárja az előző feltételes fordítást, és megnyit egy új feltételes fordítást a megadott szimbólum megadása alapján.
#else: Bezárja az előző feltételes fordítást, és új feltételes fordítást nyit meg, ha az előző megadott szimbólum nincs definiálva.
#endif: Bezárja az előző feltételes fordítást.

A buildrendszer az előre definiált előfeldolgozó szimbólumokkal is tisztában van, amelyek az SDK-stílusú projektek különböző cél-keretrendszereit jelölik. Olyan alkalmazások létrehozásakor hasznosak, amelyek több .NET-verziót is megcélzhatnak.

Cél-keretrendszerek	Szimbólumok	További szimbólumok (.NET 5+ SDK-kban érhető el)	Platformszimbólumok (csak operációsrendszer-specifikus TFM megadásakor)
.NET-keretrendszer	`NETFRAMEWORK`, `NET481`, `NET48`, `NET472`, `NET471`, `NET47NET462`, `NET461`, `NET46`, `NET452`, `NET451`, `NET45`, , `NET40`, , , `NET35NET20`	`NET48_OR_GREATER`, `NET472_OR_GREATER`, `NET471_OR_GREATER`, `NET47_OR_GREATER`, `NET462_OR_GREATERNET461_OR_GREATER`, `NET46_OR_GREATER`, `NET452_OR_GREATER`, `NET451_OR_GREATER`, `NET45_OR_GREATER`, `NET40_OR_GREATER`, , , `NET35_OR_GREATERNET20_OR_GREATER`
.NET Standard	`NETSTANDARD`, `NETSTANDARD2_1`, `NETSTANDARD2_0`, `NETSTANDARD1_6`, `NETSTANDARD1_5NETSTANDARD1_4`, `NETSTANDARD1_3`, `NETSTANDARD1_2`, , `NETSTANDARD1_1NETSTANDARD1_0`	`NETSTANDARD2_1_OR_GREATER`, `NETSTANDARD2_0_OR_GREATER`, `NETSTANDARD1_6_OR_GREATER`, `NETSTANDARD1_5_OR_GREATERNETSTANDARD1_4_OR_GREATER`, `NETSTANDARD1_3_OR_GREATER`, `NETSTANDARD1_2_OR_GREATER`, , `NETSTANDARD1_1_OR_GREATERNETSTANDARD1_0_OR_GREATER`
.NET 5+ (és .NET Core)	`NET`, `NET10_0`, `NET9_0`, `NET8_0`, `NET7_0`, `NET6_0NET5_0`, `NETCOREAPP`, `NETCOREAPP3_1`, `NETCOREAPP3_0`, `NETCOREAPP2_2`, `NETCOREAPP2_1`, , `NETCOREAPP2_0`, , , `NETCOREAPP1_1NETCOREAPP1_0`	`NET10_0_OR_GREATER`, `NET9_0_OR_GREATER`, `NET8_0_OR_GREATER`, `NET7_0_OR_GREATER`, `NET6_0_OR_GREATERNET5_0_OR_GREATER`, `NETCOREAPP3_1_OR_GREATER`, `NETCOREAPP3_0_OR_GREATER`, `NETCOREAPP2_2_OR_GREATER`, `NETCOREAPP2_1_OR_GREATER`, `NETCOREAPP2_0_OR_GREATER`, , , `NETCOREAPP1_1_OR_GREATERNETCOREAPP1_0_OR_GREATER`	`ANDROID`, `BROWSER`, `IOS`, `MACCATALYSTMACOS`, `TVOS`, `WINDOWS` `[OS][version]` (például `IOS15_1`), `[OS][version]_OR_GREATER` (például `IOS15_1_OR_GREATER`)

Feljegyzés

A verzió nélküli szimbólumok a megcélzott verziótól függetlenül vannak definiálva.
A verzióspecifikus szimbólumok csak a megcélzott verzióhoz vannak definiálva.
A <framework>_OR_GREATER szimbólumok a megcélzott verzióhoz és az összes korábbi verzióhoz vannak definiálva. Ha például a 2.0-s .NET-keretrendszer céloz meg, a következő szimbólumok vannak definiálva: NET20, NET20_OR_GREATER, NET11_OR_GREATERés NET10_OR_GREATER.
A NETSTANDARD<x>_<y>_OR_GREATER szimbólumok csak a .NET Standard célokhoz vannak definiálva, a .NET Standardot implementáló célokhoz nem, például a .NET Core-hoz és a .NET-keretrendszer.
Ezek eltérnek az MSBuild TargetFramework tulajdonság és a NuGet által használt célkeret-monikerektől (TFM-ek).

Feljegyzés

Hagyományos, nem SDK stílusú projektek esetén manuálisan kell konfigurálnia a Visual Studio különböző cél-keretrendszereihez tartozó feltételes fordítási szimbólumokat a projekt tulajdonságlapjain keresztül.

Más előre definiált szimbólumok közé tartoznak a konstansok és DEBUG az TRACE állandók. A #define projekthez beállított értékek felülbírálása. A DEBUG szimbólum például automatikusan be van állítva a buildkonfiguráció tulajdonságaitól ("Hibakeresés" vagy "Kiadás" módtól függően).

A C#-fordító csak akkor fordítja le a kódot az irányelv és #if az #endif irányelv között, ha a megadott szimbólum definiálva van, vagy nincs definiálva a ! nem operátor használatakor. A C és a C++ billentyűvel ellentétben nem rendelhet számértéket szimbólumhoz. A C# #if utasítása logikai, és csak azt ellenőrzi, hogy a szimbólum definiálva van-e. A rendszer például a következő kódot fordítja le, amikor DEBUG meg van adva:

#if DEBUG
    Console.WriteLine("Debug version");
#endif

A rendszer a következő kódot fordítja le, ha MYTEST nincs definiálva:

#if !MYTEST
    Console.WriteLine("MYTEST is not defined");
#endif

Használja az operátorokat == (egyenlőség) és != (egyenlőtlenséget) az értékek true vagy falsea bool . true azt jelenti, hogy a szimbólum definiálva van. Az utasítás #if DEBUG jelentése megegyezik a .#if (DEBUG == true) && A (és), || (vagy) és ! (nem) operátorokkal kiértékelheti, hogy több szimbólum van-e definiálva. A szimbólumokat és operátorokat zárójelekkel is csoportosíthatja.

Az alábbi példa egy összetett irányelvet mutat be, amely lehetővé teszi a kód számára, hogy kihasználja az újabb .NET-funkciókat, miközben visszamenőlegesen kompatibilis marad. Tegyük fel például, hogy NuGet-csomagot használ a kódban, de a csomag csak a .NET 6-os és újabb verziót, valamint a .NET Standard 2.0-s és újabb verziót támogatja:

#if (NET6_0_OR_GREATER || NETSTANDARD2_0_OR_GREATER)
    Console.WriteLine("Using .NET 6+ or .NET Standard 2+ code.");
#else
    Console.WriteLine("Using older code that doesn't support the above .NET versions.");
#endif

#if #elseaz , , #elif#endif#defineés #undef irányelvek mellett egy vagy több szimbólum meglétén alapuló kód belefoglalását vagy kizárását is lehetővé teszi. A feltételes fordítás hasznos lehet egy hibakeresési build kódjának összeállításakor vagy egy adott konfiguráció összeállításakor.

#elif lehetővé teszi összetett feltételes irányelv létrehozását. A fordító kiértékeli a #elif kifejezést, ha sem az előző#if, sem az előző, nem kötelező, #elif irányelvkifejezések nem értékelik ki.true Ha egy #elif kifejezés kiértékelése trueígy történik, a fordító kiértékeli a következő feltételes irányelv és a #elif következő feltételes direktíva közötti összes kódot. Példa:

#define VC7
//...
#if DEBUG
    Console.WriteLine("Debug build");
#elif VC7
    Console.WriteLine("Visual Studio 7");
#endif

#else lehetővé teszi összetett feltételes irányelv létrehozását. Ha az előző #if vagy a (nem kötelező) #elif irányelvek egyik kifejezése sem értékelhető ki true, a fordító kiértékeli az összes kódot #else a következő és a között #endif. #endif után a következő előfeldolgozó direktívának #elsekell lennie.

#endif meghatározza az irányelvvel #if kezdődő feltételes irányelv végét.

Az alábbi példa bemutatja, hogyan definiálhat szimbólumokat egy MYTEST fájlban, majd tesztelheti a szimbólumok és DEBUG szimbólumok MYTEST értékeit. A példa kimenete attól függ, hogy hibakeresési vagy kiadási konfigurációs módban építette-e a projektet.

#define MYTEST
using System;
public class MyClass
{
    static void Main()
    {
#if (DEBUG && !MYTEST)
        Console.WriteLine("DEBUG is defined");
#elif (!DEBUG && MYTEST)
        Console.WriteLine("MYTEST is defined");
#elif (DEBUG && MYTEST)
        Console.WriteLine("DEBUG and MYTEST are defined");
#else
        Console.WriteLine("DEBUG and MYTEST are not defined");
#endif
    }
}

Az alábbi példa bemutatja, hogyan tesztelhet különböző cél-keretrendszereket, hogy lehetőség szerint újabb API-kat használjon:

public class MyClass
{
    static void Main()
    {
#if NET40
        WebClient _client = new WebClient();
#else
        HttpClient _client = new HttpClient();
#endif
    }
    //...
}

Szimbólumok definiálása

A feltételes fordításhoz az alábbi két előfeldolgozási direktívával definiálhat vagy nem definiálhat szimbólumokat:

#define: Adjon meg egy szimbólumot.
#undef: Jel jelének megjelölése.

Szimbólum definiálására használható #define . Ha a szimbólumot használja a #if irányelvnek átadott kifejezésként, a kifejezés truelesz, ahogy az alábbi példa is mutatja:

#define VERBOSE

#if VERBOSE
   Console.WriteLine("Verbose output version");
#endif

Feljegyzés

A C#-ban a primitív állandókat a const kulcsszó használatával kell definiálni. A const deklaráció olyan tagot static hoz létre, amely futásidőben nem módosítható. Az #define irányelv nem használható állandó értékek deklarálására, ahogyan az általában C és C++ nyelven történik. Ha több ilyen állandóval rendelkezik, érdemes lehet külön "Állandók" osztályt létrehozni a megtartásukhoz.

A fordítás feltételeinek megadásához használjon szimbólumokat. Tesztelje a szimbólumot vagy #if#elifa . A feltételes fordítást is használhatja ConditionalAttribute . Szimbólumot definiálhat, de nem rendelhet értéket szimbólumhoz. Az #define irányelvnek meg kell jelennie a fájlban, mielőtt olyan utasításokat használ, amelyek nem is előfeldolgozási irányelvek. Szimbólumot a DefineConstants fordítóbeállítással is definiálhat. Jel megjelölésének törlése a következő használatával #undef: .

Régiók meghatározása

Az alábbi két előprocesszor-direktíva használatával tagolható kódrégiók definiálása:

#region: Indítsa el a régiót.
#endregion: Egy régió befejezése.

#region lehetővé teszi egy kódblokk megadását, amelyet kibonthat vagy összecsukhat a kódszerkesztő vázlatos funkciójának használatakor. Hosszabb kódfájlok esetén célszerű összecsukni vagy elrejteni egy vagy több régiót, hogy a jelenleg használt fájlrészre összpontosíthasson. Az alábbi példa bemutatja, hogyan definiálhat régiót:

#region MyClass definition
public class MyClass
{
    static void Main()
    {
    }
}
#endregion

A #region blokkokat egy #endregion irányelvvel kell megszüntetni. A #region blokkok nem fedhetik át a blokkokat #if . A blokkok #region azonban beágyazhatók egy #if blokkba, és egy #if blokk beágyazható egy #region blokkba.

Hiba- és figyelmeztetési információk

A következő irányelvek segítségével hozhat létre felhasználó által definiált fordítóhibákat és figyelmeztetéseket, valamint vezérlősor-információkat:

#error: Fordítóhiba létrehozása egy megadott üzenettel.
#warning: Állítson elő egy fordító figyelmeztetést egy adott üzenettel.
#line: Módosítsa a fordítóüzenetekkel nyomtatott sorszámot.

CS1029 felhasználó által definiált hiba generálására használható #error a kód egy adott helyről. Példa:

#error Deprecated code in this method.

Feljegyzés

A fordító speciális módon kezeli #error version , és egy CS8304 nevű fordítóhibát jelent a használt fordítót és nyelvi verziót tartalmazó üzenettel.

CS1030 szintű fordítói figyelmeztetés létrehozásához használható #warning a kód egy adott helyről. Példa:

#warning Deprecated code in this method.

Segítségével #line módosíthatja a fordító sorszámozását, és (opcionálisan) a fájlnév kimenetét hibák és figyelmeztetések esetén.

Az alábbi példa bemutatja, hogyan jelenthet két, sorszámhoz társított figyelmeztetést. Az #line 200 irányelv arra kényszeríti a következő sor számát, hogy 200 legyen (bár az alapértelmezett érték a 6. szám), és a következő #line irányelvig a fájlnév "Speciális" néven lesz jelentve. Az #line default irányelv a sorszámozást az alapértelmezett számozásra adja vissza, amely megszámlálja az előző irányelv által újraszámozott sorokat.

class MainClass
{
    static void Main()
    {
#line 200 "Special"
        int i;
        int j;
#line default
        char c;
        float f;
#line hidden // numbering not affected
        string s;
        double d;
    }
}

A fordítás a következő kimenetet hozza létre:

Special(200,13): warning CS0168: The variable 'i' is declared but never used
Special(201,13): warning CS0168: The variable 'j' is declared but never used
MainClass.cs(9,14): warning CS0168: The variable 'c' is declared but never used
MainClass.cs(10,15): warning CS0168: The variable 'f' is declared but never used
MainClass.cs(12,16): warning CS0168: The variable 's' is declared but never used
MainClass.cs(13,16): warning CS0168: The variable 'd' is declared but never used

Az #line irányelv a buildelési folyamat egy automatizált, köztes lépésében használható. Ha például eltávolítja a sorokat az eredeti forráskódfájlból, de továbbra is azt szeretné, hogy a fordító a fájl eredeti sorszámozása alapján hozzon létre kimenetet, eltávolíthatja a sorokat, majd szimulálhatja az eredeti sor számozását a használatával #line.

Az #line hidden irányelv elrejti az egymást követő sorokat a hibakereső elől, így amikor a fejlesztő végiglép a kódon, az a #line hidden és a következő #line irányelv (feltételezve, hogy ez nem egy másik #line hidden irányelv) közötti vonalak lépnek át. Ez a beállítás lehetővé teszi, hogy ASP.NET különbséget tegyen a felhasználó által definiált és a gép által létrehozott kód között. Bár ASP.NET a funkció elsődleges felhasználója, valószínű, hogy több forrásgenerátor használja.

Az #line hidden irányelv nem befolyásolja a fájlneveket és a sorszámokat a hibajelentésben. Ez azt jelenti, hogy ha a fordító hibát talál egy rejtett blokkban, a fordító jelenti a hiba aktuális fájlnevét és sorszámát.

Az #line filename irányelv meghatározza a fordító kimenetében megjeleníteni kívánt fájlnevet. Alapértelmezés szerint a forráskódfájl tényleges nevét használja a rendszer. A fájlnévnek idézőjelekben ("") kell lennie, és egy sorszámot kell követnie.

A #line irányelv új formáját használhatja:

#line (1, 1) - (5, 60) 10 "partial-class.cs"
/*34567*/int b = 0;

Az űrlap összetevői a következők:

(1, 1): Az irányelv szerinti sor első karakterének kezdővonala és oszlopa. Ebben a példában a következő sort az 1. sor, 1. oszlop jelenti.
(5, 60): A megjelölt régió záró sora és oszlopa.
10: Az irányelv érvénybe lépő oszlopeltolása #line . Ebben a példában a 10. oszlop az első oszlop. A deklaráció int b = 0; az oszlopban kezdődik. A mező nem kötelező. Ha nincs megadva, az irányelv az első oszlopra lép érvénybe.
"partial-class.cs": A kimeneti fájl neve.

Az előző példa a következő figyelmeztetést hozza létre:

partial-class.cs(1,5,1,6): warning CS0219: The variable 'b' is assigned but its value is never used

Az újrakészítés után a változó b a fájl partial-class.cselső sorában, a 6. karakternél található.

A tartományspecifikus nyelvek (DSL-k) általában ezt a formátumot használják, hogy jobb leképezést biztosítsanak a forrásfájlból a létrehozott C#-kimenetre. A kiterjesztett #line irányelv leggyakoribb használata a generált fájlban megjelenő figyelmeztetések vagy hibák újbóli leképezése az eredeti forrásra. Vegyük például ezt a borotvalapot:

@page "/"
Time: @DateTime.NowAndThen

A tulajdonság DateTime.Now helytelenül van begépelve.DateTime.NowAndThen A razor-kódrészlethez létrehozott C# a következőhöz hasonlóan néz ki:page.g.cs

  _builder.Add("Time: ");
#line (2, 6) - (2, 27) 15 "page.razor"
  _builder.Add(DateTime.NowAndThen);

Az előző kódrészlet fordítói kimenete a következő:

page.razor(2, 2, 2, 27)error CS0117: 'DateTime' does not contain a definition for 'NowAndThen'

A page.razor 2. sorának 6. oszlopában kezdődik a @DateTime.NowAndThen szöveg, amelyet az irányelv (2, 6) jegyez fel. Az @DateTime.NowAndThen kiterjedése a 2. sor 27. oszlopánál ér véget, amit az irányelv (2, 27) jelez. A DateTime.NowAndThen szövege a page.g.cs15. oszlopában kezdődik, amit a 15 jelez az irányelvben. A fordító a hibát a page.razorhelyén jelenti. A fejlesztő közvetlenül a forráskódban szereplő hibára tud navigálni, nem pedig a létrehozott forrásra.

Ha további példákat szeretne látni erre a formátumra, tekintse meg a példákról szóló szakaszban található funkcióspecifikációt .

Pragmas

A fordító #pragma speciális utasítások beolvasásával készíti el a fájlt, ahol megjelenik. A fordítónak támogatnia kell a használt pragmákat. Más szóval nem hozhat #pragma létre egyéni előfeldolgozási utasításokat.

#pragma warning: Figyelmeztetések engedélyezése vagy letiltása.
#pragma checksum: Ellenőrzőösszeg létrehozása.

#pragma pragma-name pragma-arguments

pragma-name a felismert pragma neve. pragma-arguments a pragma-specifikus argumentumok.

#pragma figyelmeztetés

#pragma warning bizonyos figyelmeztetéseket engedélyezhet vagy letilthat. A #pragma warning disable format és #pragma warning enable format szabályozza, hogy a Visual Studio hogyan formázzon kódblokkokat.

#pragma warning disable warning-list
#pragma warning restore warning-list

warning-list a figyelmeztető számok vesszővel tagolt listája, például 414, CS3021. A "CS" előtag nem kötelező. Ha nem ad meg figyelmeztetési számokat, letiltja az összes figyelmeztetést, disable és restore engedélyezi az összes figyelmeztetést.

Feljegyzés

Ha figyelmeztető számokat szeretne keresni a Visual Studióban, hozza létre a projektet, majd keresse meg a figyelmeztető számokat a Kimenet ablakban.

A disable művelet a forrásfájl következő sorától kezdve lép érvénybe. A figyelmeztetés a következő sorban restorelesz visszaállítva: . Ha nincs restore a fájlban, a figyelmeztetések visszaállítják az alapértelmezett állapotukat az ugyanabban a fordításban lévő későbbi fájlok első sorában.

// pragma_warning.cs
using System;

#pragma warning disable 414, CS3021
[CLSCompliant(false)]
public class C
{
    int i = 1;
    static void Main()
    {
    }
}
#pragma warning restore CS3021
[CLSCompliant(false)]  // CS3021
public class D
{
    int i = 1;
    public static void F()
    {
    }
}

A warning pragma egy másik formája letiltja vagy visszaállítja a Visual Studio formázási parancsait kódblokkokban:

#pragma warning disable format
#pragma warning restore format

A Visual Studio formátumparancsai nem módosítják a szöveget kódblokkokban, ahol a disable format érvényben van. A formázási parancsok ( például Ctrl+K, Ctrl+D) nem módosítják a kód ezen régiói. Ez a pragma segítségével részletesen szabályozhatja a kód vizuális megjelenítését.

#pragma ellenőrzőösszeg

Ellenőrzőösszegeket hoz létre a forrásfájlokhoz ASP.NET lapok hibakereséséhez.

#pragma checksum "filename" "{guid}" "checksum bytes"

Az irányelv "filename" a fájl neveként használja a módosítások vagy frissítések figyelésére, "{guid}" a kivonatoló algoritmus globálisan egyedi azonosítójaként (GUID), valamint "checksum_bytes" az ellenőrzőösszeg bájtjait képviselő hexadecimális számjegyek sztringjeként. Páros számú hexadecimális számjegyet kell megadnia. A páratlan számú számjegy fordítási időt jelző figyelmeztetést eredményez, és a rendszer figyelmen kívül hagyja az irányelvet.

A Visual Studio hibakeresője ellenőrzőösszeget használ annak ellenőrzéséhez, hogy mindig a megfelelő forrást találja-e meg. A fordító kiszámítja egy forrásfájl ellenőrzőösszegét, majd kibocsátja a kimenetet a programadatbázis (PDB) fájlba. A hibakereső a PDB használatával hasonlítja össze a forrásfájlhoz kiszámított ellenőrzőösszeget.

Ez a megoldás nem működik ASP.NET projektek esetében, mert a kiszámított ellenőrzőösszeg a létrehozott forrásfájlhoz tartozik, nem pedig a .aspx fájlhoz. A probléma #pragma checksum megoldásához ellenőrzőösszeg-támogatást biztosít ASP.NET lapokhoz.

Amikor ASP.NET projektet hoz létre a Visual C#-ban, a létrehozott forrásfájl egy ellenőrzőösszeget tartalmaz a .aspx fájlhoz, amelyből a forrás létrejön. A fordító ezután beírja ezeket az adatokat a PDB-fájlba.

Ha a fordító nem talál utasítást #pragma checksum a fájlban, kiszámítja az ellenőrzőösszeget, és az értéket a PDB-fájlba írja.

class TestClass
{
    static int Main()
    {
        #pragma checksum "file.cs" "{406EA660-64CF-4C82-B6F0-42D48172A799}" "ab007f1d23d9" // New checksum
    }
}

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2026-01-22

Megosztás:

C# előfeldolgozási irányelvek

Fájlalapú alkalmazások

Null értékű környezet

Feltételes fordítás

Szimbólumok definiálása

Régiók meghatározása

Hiba- és figyelmeztetési információk

Pragmas

#pragma figyelmeztetés

#pragma ellenőrzőösszeg

Visszacsatolás

További források