Részleges osztályok és módszerek (C# programozási útmutató)

Egy osztály, egy struktúra, egy interfész vagy metódus definícióját feloszthatja két vagy több forrásfájlra. Minden forrásfájl tartalmaz egy szakaszt a típus- vagy metódusdefinícióból, és az alkalmazás fordításakor az összes rész össze lesz állítva.

Részleges osztályok

Az osztálydefiníciók felosztása több esetben is kívánatos:

• Az osztály különálló fájlokon való deklarálása lehetővé teszi, hogy egyszerre több programozó is dolgozzon rajta.
• Az osztályhoz anélkül adhat hozzá kódot, hogy újra létre kellene hoznia az automatikusan létrehozott forrásfájlt. A Visual Studio ezt a megközelítést használja a Windows Forms, a webszolgáltatás burkolókódja stb. létrehozásakor. Létrehozhat olyan kódot, amely ezeket az osztályokat használja anélkül, hogy módosítania kellene a Visual Studio által létrehozott fájlt.
• A forrásgenerátorok további funkciókat hozhatnak létre egy osztályban.

Osztálydefiníció felosztásához használja a részleges kulcsszómódosítót az itt látható módon:

public partial class Employee
{
    public void DoWork()
    {
    }
}

public partial class Employee
{
    public void GoToLunch()
    {
    }
}

A partial kulcsszó azt jelzi, hogy az osztály, a szerkezet vagy a felület más részei definiálhatók a névtérben. Minden résznek a kulcsszót kell használnia partial . A végső típus létrehozásához minden résznek rendelkezésre kell állnia fordításkor. Minden résznek azonos akadálymentességgel kell rendelkeznie, például public, privatestb.

Ha bármely rész absztraktnak van deklarálva, akkor a teljes típus absztraktnak minősül. Ha bármely részt lezártnak nyilvánítottak, akkor az egész típust lezártnak kell tekinteni. Ha bármelyik rész alaptípust deklarál, akkor az egész típus örökli ezt az osztályt.

Az alaposztályt meghatározó összes résznek meg kell egyeznie, de az alaposztályt kihagyó részek továbbra is öröklik az alaptípust. Az alkatrészek különböző alapillesztőket adhatnak meg, a végső típus pedig az összes részleges deklaráció által felsorolt interfészeket implementálja. A részleges definícióban deklarált osztály-, szerkezet- vagy felülettagok az összes többi rész számára elérhetők. A végső típus a fordítási időpontban lévő összes rész kombinációja.

Feljegyzés

A partial módosító nem érhető el delegált vagy számbavételi deklarációkban.

Az alábbi példa azt mutatja be, hogy a beágyazott típusok részlegesek lehetnek, még akkor is, ha a beágyazott típus nem részleges.

class Container
{
    partial class Nested
    {
        void Test() { }
    }

    partial class Nested
    {
        void Test2() { }
    }
}

Fordításkor a részleges típusú definíciók attribútumai egyesülnek. Vegyük például a következő deklarációkat:

[SerializableAttribute]
partial class Moon { }

[ObsoleteAttribute]
partial class Moon { }

Egyenértékűek a következő deklarációkkal:

[SerializableAttribute]
[ObsoleteAttribute]
class Moon { }

Az alábbiak egyesülnek az összes részleges típusú definícióval:

• XML-megjegyzések
• Felületek
• általános típusú paraméterattribútumok
• osztályattribútumok
• tagok

Vegyük például a következő deklarációkat:

partial class Earth : Planet, IRotate { }
partial class Earth : IRevolve { }

Egyenértékűek a következő deklarációkkal:

class Earth : Planet, IRotate, IRevolve { }

Korlátozások

A részleges osztálydefiníciók használatakor több szabályt is be kell tartani:

• Az azonos típusú részeknek szánt részleges típusdefiníciókat a következővel partialkell módosítani: A következő osztálydeklarációk például hibát okoznak:

  public partial class A { }
  //public class A { }  // Error, must also be marked partial
  

• A partial módosító csak közvetlenül a kulcsszó vagy a kulcsszó classstructinterfaceelőtt jelenhet meg.
• A beágyazott részleges típusok a részleges típusú definíciókban engedélyezettek az alábbi példában látható módon:

  partial class ClassWithNestedClass
  {
      partial class NestedClass { }
  }
  
  partial class ClassWithNestedClass
  {
      partial class NestedClass { }
  }
  

• Az azonos típusú részeknek szánt részleges típusú definíciókat ugyanabban a szerelvényben és ugyanabban a modulban (.exe vagy .dll fájlban) kell definiálni. A részleges definíciók nem terjedhetnek ki több modulra.
• Az osztálynévnek és az általános típusú paramétereknek meg kell egyeznie az összes részleges típusú definícióban. Az általános típusok lehetnek részlegesek. Minden részleges deklarációnak azonos sorrendben kell ugyanazokat a paraméterneveket használnia.
• A részleges típusú definíciókban az alábbi kulcsszavak megadása nem kötelező, de ha egy részleges típusú definícióban szerepel, nem ütközhet egy másik részleges definícióban megadott kulcsszavakkal ugyanahhoz a típushoz:
  • public
  • Privát
  • Védett
  • Belső
  • Absztrakt
  • Lezárt
  • alaposztály
  • új módosító (beágyazott részek)
  • általános korlátozások

További információ: Típusparaméterek korlátozásai.

Példák

Az alábbi példában az osztály Coordsmezői és konstruktora egy részleges osztálydefinícióban deklarálva van, PrintCoordsa tag pedig egy másik részleges osztálydefinícióban van deklarálva.

public partial class Coords
{
    private int x;
    private int y;

    public Coords(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

public partial class Coords
{
    public void PrintCoords()
    {
        Console.WriteLine("Coords: {0},{1}", x, y);
    }
}

class TestCoords
{
    static void Main()
    {
        Coords myCoords = new Coords(10, 15);
        myCoords.PrintCoords();

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output: Coords: 10,15

Az alábbi példa azt mutatja be, hogy részleges szerkezeteket és interfészeket is fejleszthet.

partial interface ITest
{
    void Interface_Test();
}

partial interface ITest
{
    void Interface_Test2();
}

partial struct S1
{
    void Struct_Test() { }
}

partial struct S1
{
    void Struct_Test2() { }
}

Részleges metódusok

Egy részleges osztály vagy szerkezet tartalmazhat részleges metódust. Az osztály egyik része tartalmazza a metódus aláírását. Egy implementáció definiálható ugyanabban a részben vagy egy másik részben.

Nem szükséges implementálás részleges metódushoz, ha az aláírás betartja a következő szabályokat:

• A deklaráció nem tartalmaz hozzáférési módosítókat. A metódus alapértelmezés szerint rendelkezik private hozzáféréssel.
• A visszatérési típus a következő void: .
• Egyik paraméter sem rendelkezik a out módosítóval.
• A metódus deklarációja nem tartalmazhat az alábbi módosítókat:
  • Virtuális
  • Felülbírálja
  • Lezárt
  • Új
  • extern

A metódus és a metódushoz intézett összes hívás a fordításkor törlődik, ha nincs implementáció.

Minden olyan metódusnak, amely nem felel meg az összes korlátozásnak (például public virtual partial void metódusnak), implementálást kell biztosítania. Ezt a megvalósítást egy forrásgenerátor szolgáltathatja.

A részleges metódusok lehetővé teszik, hogy az osztály egy részének végrehajtója deklaráljon egy metódust. Az osztály egy másik részének implementátora meghatározhatja ezt a metódust. Két olyan forgatókönyv van, ahol ez a szétválasztás hasznos: sablonokat, amelyek sablonokat hoznak létre a kazánlemez kódját és a forrásgenerátorokat.

• Sablonkód: A sablon fenntart egy metódusnevet és aláírást, hogy a létrehozott kód meghívhassa a metódust. Ezek a metódusok azokat a korlátozásokat követik, amelyek lehetővé teszik a fejlesztők számára, hogy eldöntsék, implementálják-e a metódust. Ha a metódus nincs implementálva, akkor a fordító eltávolítja a metódus aláírását és a metódushoz érkező összes hívást. A metódushoz intézett hívások, beleértve a hívások argumentumainak kiértékelése során esetlegesen előforduló eredményeket is, futásidőben nem lesznek hatással. Ezért a részleges osztályban lévő kódok szabadon használhatnak részleges metódust, még akkor is, ha az implementáció nincs megadva. Fordítási és futásidejű hibák nem következnek be, ha a metódust meghívják, de nem implementálják.
• Forrásgenerátorok: A forrásgenerátorok implementációt biztosítanak a metódusokhoz. Az emberi fejlesztő hozzáadhatja a metódusdeklarációt (gyakran a forrásgenerátor által beolvasott attribútumokkal). A fejlesztő írhat olyan kódot, amely meghívja ezeket a metódusokat. A forrásgenerátor a fordítás során fut, és biztosítja a megvalósítást. Ebben a forgatókönyvben a nem implementálható részleges módszerekre vonatkozó korlátozásokat gyakran nem követik.

// Definition in file1.cs
partial void OnNameChanged();

// Implementation in file2.cs
partial void OnNameChanged()
{
  // method body
}

• A részleges metódus deklarációinak a környezeti kulcsszó részlegesével kell kezdődniük.
• A részleges metódus aláírásának a részleges típus mindkét részén meg kell egyeznie.
• A részleges metódusok statikus és nem biztonságos módosítókkal rendelkezhetnek.
• A részleges metódusok lehetnek általánosak. A korlátozásoknak meg kell egyeznie a definiálási és végrehajtási módszer deklarálásával. A paraméter- és típusparaméterneveknek nem kell megegyeznie a implementálási deklarációban, mint a meghatározóban.
• Delegálhat egy definiált és implementált részleges metódust, de nem olyan részleges metódusra, amely nem rendelkezik implementációval.

C# nyelvi specifikáció

További információ: Részleges típusok és részleges metódusok a C# nyelvspecifikációjában. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása. A részleges metódusok további funkcióit a szolgáltatás specifikációja határozza meg.

Lásd még

• Osztályok
• Struktúratípusok
• Felületek
• részleges (típus)