Előfeldolgozó

A C és C++ nyelvek igen fontos és hasznos eleme az előfeldolgozó, másnéven a preprocesszor. Emiatt a nyelv fordítása két lépcsős. Először az előfeldolgozó utasításai kerülnek feldolgozásra és csak ezután történik meg a tényleges nyelvi fordítás.

Az előfeldolgozó megítélése ambivalens, mivel hasznos, viszont sok galibát tud okozni. A galibák többsége abból fakad, hogy az előfeldolgozó utasításaival létrehozhatóak makrók, amik úgy viselkednek, mint a függvények, viszont tényleges függvényhívást nem váltanak ki, mivel a feldolgozáskor a hívás helyére egyszerűen csak bemásolódik a kód.

//c++ makró példa
#include <iostream>

using namespace std;

#define egy cout
#define ketto <<
#define harom "Hello World!\n"

int main()
{
   //ide az egy ketto és harom szimbólum értékei másolódnak be.
   //Látszólag azonban bővítettük a nyelvet új kulcsszókkal
   egy ketto harom;
   return 0;
}

A program kimenete:

Hello World!

Ezért a makrókban nagyon nehéz hibát keresni. Emiatt C# esetén nem létezik a klasszikus értelemben vett előfeldolgozó. Makrók és összetett szimbólumok nem definiálhatók. Az egyszerű szimbólumok logikai típusként foghatók fel és C# esetén leginkább feltételes fordítás létrehozásának eszközei.

Feltételes fordítás alatt az értendő, hogy például adott egy program demó és teljes verziója. Gazdasági okokból a teljes verzió fejlesztésén dolgozik a csapat gőzerővel, viszont jó lenne néha egy demó verziót kiadni.

Ebben az esetben két lehetőség előtt áll a fejlesztőcsapat. Lemásolja a meglévő teljes verziót egy másik projektbe, majd törli a felesleges részeket. Ez minden egyes demó változat létrehozásakor iszonyatosan sok munkával járhat.

A másik, gazdaságosabb és hatékonyabb megoldás a feltételes fordítás. Az előfeldolgozó eszközeivel a demó verzióban egy feltételesen forduló blokkban megjelöljük a nem kívánatos részeket.

Ezután a program fordításakor és kiadásakor csupán annyi teendő van, hogy definiáljuk (vagy nem) a megfelelő szimbólumot, amit a feltételes blokkjaink figyelnek és máris két verziójával rendelkezhetünk a szoftvernek.

Az előfeldolgozó utasításai kettőskereszt karakterrel kezdődnek. A következő utasítások támogatottak:

#if
#else
#endif
#elif
#region
#endregion
#define

A #define utasítással tudunk szimbólumot definiálni. A szimbólumnak értéke nem lehet. Alapértelmezetten a környezet két szimbólumot definiál nekünk: ezek a DEBUG és a RELEASE, amelyek a két alapvetÅ‘ fordítási konfigurációt (Build Configuration) határozzák meg.

A Debug változat a hibakeresésre szánt változata egy programnak. Ezen változat kiegészítő nyomkövetési információkat tartalmaz a hibakereső (debugger) számára. Éles környezetbe ilyet nem érdemes kiadni, mivel lassabban fut, mint a Release változat.

A Release változat nem tartalmazza a hibakereséshez szükséges extra információkat, így gyorsabban tud futni. Cserébe nem tudunk benne hibát keresni. Végfelhasználóknak a programunknak ezen változatát érdemes kiadni.

A build konfigurációk között az eszköztáron tudunk egyszerűen váltani. Saját Build konfigurációk is készíthetők a Configuration manager segítségével.

A #define egy szimbólumot csak az adott fájl számára definiál. A #define utasítások csak a fájl elején lehetnek, még a tényleges C# kód elÅ‘tt.

Ha egész projekt szinten szeretnénk definiálni egy szimbólumot, akkor azt a projekt tulajdonságainál tudjuk megtenni, a Build lapon. Itt az első beállítási lehetőség a Conditional compilation symbols sor. Itt vesszővel elválasztva megadhatjuk az egész projekt fordításánál definiált szimbólumokat.

Megjegyzem, hogy konfiguráció váltás esetén a projekt beállításai is megváltoznak, mivel minden konfigurációhoz külön tárolódnak a projekt beállítások. Tehát, ha valami szimbólumot beállítunk Debug konfigurációban, az nem fog öröklődni, másolódni a Release konfigurációba.

Azért, hogy a szimbólumok és a változónevek között egyértelműen különbséget lehessen tenni, kódolási konvencióként elfogadott, hogy az előfeldolgozó szimbólumait csupa nagybetűvel adjuk meg.

A #region utasítás egy régiót határoz meg a forráskódunkon belül. Arra használható, hogy a kód már kész régióit átláthatóbbá, összecsukhatóvá tegyük, akár blokkon kívül, vagy belül. Ez az egyetlen olyan elÅ‘feldolgozó utasítás, ami inkább a kód átláthatóságát hivatott javítani.

A #region utasítás után egy tetszÅ‘legesen hosszú szövegnek kell állna. Ez a szöveg fog megjelenni a szerkesztÅ‘ben, ha a blokk össze van csukva. A blokk végét az #endregion utasítás határozza meg. A régiók egymásba úgy nem ágyazhatóak, mint a hagyományos vezérlési blokkok.

Az #if, #elif, #else, #endif utasításokkal szimbólumok meglétét tudjuk ellenÅ‘rizni. Az utasítások működései megegyeznek a hagyományos nyelvi if, else, else if utasításokkal. Ugyanúgy feltétel esetén több szimbólum is megadható VAGY (II), ÉS (&&), NEM (!) kapcsolat segítségével.

Az alábbi példa az előfeldolgozó használatát mutatja be:

#define TESZT
using System;

namespace PeldaElofeldolgozo
{
    class Program
    {
        static void Main(string[] args)
        {
            #region összecsukható régió
            //ide egy komolyabb kód szösszenet írható
            //ami összecsukható lesz Visual Studio-ban
            #endregion

#if DEBUG
            Console.WriteLine("DEBUG mód!");
#if TESZT
            Console.WriteLine("Teszt definiálva");
#endif
#else
            Console.WriteLine("RELEASE mód!");
#if TESZT
            Console.WriteLine("Teszt definiálva");
#endif
#endif
            Console.ReadKey();
        }
    }
}

A program kimenete RELASE konfigurációban:

RELEASE mód!
Teszt definiálva