Irányított események áttekintése

A Windows Presentation Foundation (WPF) alkalmazásfejlesztői és az összetevő-szerzők átirányított eseményeket használhatnak az események elemfán keresztüli propagálására, és meghívhatnak eseménykezelőket a fa több figyelőjén. Ezek a funkciók nem találhatók a közös nyelvi futtatókörnyezeti (CLR) eseményekben. Számos WPF-esemény átirányított esemény, például ButtonBase.Click. Ez a cikk az irányított események alapvető fogalmait ismerteti, és útmutatást nyújt az irányított eseményekre való reagálás időpontjáról és módjáról.

Előfeltételek

Ez a cikk alapszintű ismereteket feltételez a közös nyelvi futtatókörnyezetről (CLR), az objektumorientált programozásról, valamint arról, hogy a WPF-elemelrendezés hogyan fogható fel faként. A cikkben szereplő példák követéséhez segít, ha ismeri az Extensible Application Markup Language (XAML) nyelvet, és ismeri a WPF-alkalmazások írásának módját.

Mi az irányított esemény?

Az irányított eseményeket funkcionális vagy megvalósítási szempontból is megfontolhatja:

• Funkcionális szempontból az irányított esemény olyan eseménytípus, amely egy elemfa több figyelőjén is meghívhat kezelőket, nem csak az eseményforráson. Az eseményfigyelő az az elem, amelyben egy eseménykezelőt csatolnak és meghívnak. Az eseményforrás az az elem vagy objektum, amely eredetileg eseményt emelt ki.

• Implementáció szempontjából az irányított esemény a WPF eseményrendszerben regisztrált esemény, amelyet az RoutedEvent osztály egy példánya is alátámaszt, és amelyet a WPF eseményrendszer dolgoz fel. Az irányított eseményeket általában egy CLR-esemény "burkolójával" implementálják, amely lehetővé teszi a kezelők csatolását az XAML-ben és a kód mögött, ahogyan egy CLR-eseménynél tenné.

A WPF-alkalmazások általában sok olyan elemet tartalmaznak, amelyeket XAML-ben deklaráltak vagy kódban hoztak létre. Az alkalmazás elemei az elemfán belül találhatók. Az irányított esemény definiálásának módjától függően, ha az esemény egy forráselemen van előállítva:

• Buborékok felfelé az elemfán a forráselemtől a gyökérelemig, amely általában egy oldal vagy ablak.
• A gyökérelemtől a forráselemig lefelé halad az elemfán.
• Nem halad át az elemfán, és csak a forráselemen fordul elő.

Vegye figyelembe a következő részleges elemfát:

<Border Height="30" Width="200" BorderBrush="Gray" BorderThickness="1">
    <StackPanel Background="LightBlue" Orientation="Horizontal" Button.Click="YesNoCancelButton_Click">
        <Button Name="YesButton">Yes</Button>
        <Button Name="NoButton">No</Button>
        <Button Name="CancelButton">Cancel</Button>
    </StackPanel>
</Border>

Az elemfa a következőképpen jelenik meg:

A három gomb mindegyike lehetséges Click eseményforrás. Ha az egyik gombra kattint, az a gombról a gyökérelemre felbuboró eseményt emeli Click ki. Az Button és Border az elemek nem rendelkeznek eseménykezelőkkel, de igen StackPanel . Lehetséges, hogy a fában magasabban lévő, nem látható elemekhez is vannak Click eseménykezelők csatlakoztatva. Amikor az Click esemény eléri az StackPanel elemet, a WPF eseményrendszer meghívja a YesNoCancelButton_Click hozzá csatolt kezelőt. A példában szereplő Click esemény eseményútvonala: Button - ->StackPanel ->Border> egymást követő szülőelemek.

Megjegyzés:

Az eredetileg átirányított eseményt generáló elem az RoutedEventArgs.Source eseménykezelő paraméterei között lesz azonosítva. Az eseményfigyelő az az elem, amelyben az eseménykezelő hozzá van kapcsolva és meghívva van, és az eseménykezelő paramétereiben feladóként van azonosítva.

Az irányított események legfelső szintű forgatókönyvei

Íme néhány olyan forgatókönyv, amely motiválta az irányított esemény fogalmát, és megkülönbözteti azt egy tipikus CLR-eseménytől:

• Vezérlők összetétele és beágyazása: A WPF különböző vezérlői gazdag tartalommodellel rendelkeznek. Elhelyezhet például egy képet egy Buttonolyan helyen, amely hatékonyan kibővíti a gomb vizualizációs fáját. A hozzáadott képnek azonban nem szabad megtörnie a gomb találattesztelési viselkedését, amelynek válaszolnia kell, amikor a felhasználó a kép képpontjaira kattint.

• Egyedi kezelő csatlakoztatási pontjai: Regisztrálhat egy kezelőt az egyes gombok eseményeihez Click , de az irányított eseményekkel egyetlen kezelőt csatolhat az előző XAML-példában látható módon. Ez lehetővé teszi az elemfa módosítását az egyes kezelő alatt, például további gombok hozzáadását vagy eltávolítását anélkül, hogy regisztrálnia kellene az egyes gombok eseményeit Click . Az esemény létrehozásakor a Click kezelőlogika meghatározhatja, hogy honnan származik az esemény. A korábban bemutatott XAML elemfában megadott következő kezelő tartalmazza ezt a logikát:

  private void YesNoCancelButton_Click(object sender, RoutedEventArgs e)
  {
      FrameworkElement sourceFrameworkElement = e.Source as FrameworkElement;
      switch (sourceFrameworkElement.Name)
      {
          case "YesButton":
              // YesButton logic.
              break;
          case "NoButton":
              // NoButton logic.
              break;
          case "CancelButton":
              // CancelButton logic.
              break;
      }
      e.Handled = true;
  }
  

  Private Sub YesNoCancelButton_Click(sender As Object, e As RoutedEventArgs)
      Dim frameworkElementSource As FrameworkElement = TryCast(e.Source, FrameworkElement)
  
      Select Case frameworkElementSource.Name
          Case "YesButton"
              ' YesButton logic.
          Case "NoButton"
              ' NoButton logic.
          Case "CancelButton"
              ' CancelButton logic.
      End Select
  
      e.Handled = True
  End Sub
  

• Osztálykezelés: Az irányított események támogatják az osztályban definiált osztályesemény-kezelőt . Az osztálykezelők egy eseményt kezelnek, mielőtt bármely példánykezelő ugyanarra az eseményre az osztály bármely példányán reagálna.

• Eseményre való hivatkozás tükröződés nélkül: Minden átirányított esemény létrehoz egy RoutedEvent mezőazonosítót, amely olyan robusztus eseményazonosítási technikát biztosít, amely nem igényel statikus vagy futásidejű tükrözést az esemény azonosításához.

Az irányított események implementálása

Az irányított esemény a WPF eseményrendszerben regisztrált, az RoutedEvent osztály egy példánya által támogatott és a WPF eseményrendszer által feldolgozott esemény. A RoutedEventregisztrációból beszerzett példányt általában az azt regisztráló osztály tagjaként public static readonly tárolja a rendszer. Ezt az osztályt nevezik "tulajdonos" eseményosztálynak. Az irányított események általában azonos nevű CLR-esemény „csomagolót” implementálnak. A CLR eseményburkoló add és remove metódusokat tartalmaz, amelyek lehetővé teszik a kezelők csatlakoztatását XAML-ben és a kód-behindban, nyelvspecifikus eseményszintaxis segítségével. A add és remove hozzáférési modulok felülbírálják a CLR-implementációt, és meghívják az irányított esemény AddHandler és RemoveHandler metódusait. Az irányított eseményhátralék- és kapcsolati mechanizmus fogalmilag hasonló ahhoz, ahogyan a függőségi tulajdonság egy CLR-tulajdonság, amelyet az DependencyProperty osztály biztosít, és amely regisztrálva van a WPF tulajdonságrendszerben.

Az alábbi példa regisztrálja az Tap irányított eseményt, tárolja a visszaadott RoutedEvent példányt, és megvalósít egy CLR-eseményburkolót.

// Register a custom routed event using the Bubble routing strategy.
public static readonly RoutedEvent TapEvent = EventManager.RegisterRoutedEvent(
    name: "Tap",
    routingStrategy: RoutingStrategy.Bubble,
    handlerType: typeof(RoutedEventHandler),
    ownerType: typeof(CustomButton));

// Provide CLR accessors for adding and removing an event handler.
public event RoutedEventHandler Tap
{
    add { AddHandler(TapEvent, value); }
    remove { RemoveHandler(TapEvent, value); }
}

' Register a custom routed event using the Bubble routing strategy.
Public Shared ReadOnly TapEvent As RoutedEvent = EventManager.RegisterRoutedEvent(
    name:="Tap",
    routingStrategy:=RoutingStrategy.Bubble,
    handlerType:=GetType(RoutedEventHandler),
    ownerType:=GetType(CustomButton))

' Provide CLR accessors for adding and removing an event handler.
Public Custom Event Tap As RoutedEventHandler
    AddHandler(value As RoutedEventHandler)
        [AddHandler](TapEvent, value)
    End AddHandler

    RemoveHandler(value As RoutedEventHandler)
        [RemoveHandler](TapEvent, value)
    End RemoveHandler

    RaiseEvent(sender As Object, e As RoutedEventArgs)
        [RaiseEvent](e)
    End RaiseEvent
End Event

Útválasztási stratégiák

Az irányított események három útválasztási stratégia egyikét használják:

• Buborékolás: Kezdetben a rendszer meghívja az eseményforrás eseménykezelőinek adatait. Az átirányított esemény ezután az egymást követő szülőelemekre irányítja, és meghívja az eseménykezelőket, amíg el nem éri az elemfa gyökerét. A legtöbb átirányított esemény a buborékos útválasztási stratégiát használja. Az összetett vezérlők vagy egyéb felhasználói felületi elemek bemenetének vagy állapotváltozásának jelentésére általában a buborékos útvonalú események szolgálnak.

• Bújtatás: Kezdetben a rendszer meghívja az elemfa gyökerénél lévő eseménykezelőket. Az irányított esemény ezután az egymást követő gyermekelemekhez jut el, és sorrendben aktiválja azok eseménykezelőit, míg végül eléri az esemény forrását. Az bújtatási útvonalat követő eseményeket előzetes eseményeknek is nevezik. A WPF bemeneti eseményei általában előzetes verziójú és buborékos párként vannak implementálva.

• Közvetlen: Csak az eseményforrás eseménykezelői lesznek meghívva. Ez a nem útválasztási stratégia hasonló a Windows Forms felhasználói felületi keretrendszer eseményeihez, amelyek szabványos CLR-események. A CLR-eseményektől eltérően a közvetlen átirányítású események támogatják az osztálykezelést , és az EventSetters és az EventTriggers is használhatja.

Miért érdemes átirányított eseményeket használni?

Alkalmazásfejlesztőként nem kell mindig tudnia vagy gondoskodnia arról, hogy a kezelt esemény irányított eseményként legyen implementálva. Az irányított események speciális viselkedéssel rendelkeznek, de ez a viselkedés nagyrészt láthatatlan, ha az eseményt azon az elemen kezeli, amely kiváltotta. Az irányított események azonban akkor relevánsak, ha egy eseménykezelőt egy szülőelemhez szeretne csatolni a gyermekelemek által kiváltott események kezelése érdekében, például egy összetett vezérlőn belül.

Az irányított eseményfigyelőknek nincs szükségük az általuk kezelt irányított eseményekre, hogy az osztályuk tagjai legyenek. Bármely UIElement vagy ContentElement lehet eseményfigyelő bármilyen irányított eseményhez. Mivel a vizuális elemek UIElement vagy ContentElement miatt jönnek létre, az irányított eseményeket fogalmi "interfészként" használhatja, amely támogatja az eseményinformációk cseréjét az alkalmazás különböző elemei között. Az irányított események "interfész" fogalma különösen a bemeneti eseményekre vonatkozik.

Az irányított események támogatják az eseményinformációk cseréjét az eseményútvonal elemei között, mivel minden figyelő hozzáfér ugyanahhoz az eseményadat-példányhoz. Ha egy elem módosít valamit az eseményadatokban, az az eseményútvonal későbbi elemei számára is látható lesz.

Az útválasztási szemponton kívül az alábbi okokból dönthet úgy, hogy a szabványos CLR-esemény helyett egy irányított eseményt implementál:

• Egyes WPF-stílus- és templatálási funkciók, például az EventSetters és az EventTriggers megkövetelik, hogy a hivatkozott esemény irányított esemény legyen.

• Az irányított események támogatják azokat az osztályesemény-kezelőket , amelyek a figyelőosztály bármely példányán egy adott eseményhez tartozó példánykezelők előtt kezelik az eseményeket. Ez a funkció azért hasznos a vezérlőtervezésben, mert az osztálykezelő olyan eseményvezérelt osztályviselkedéseket kényszeríthet ki, amelyeket egy példánykezelő nem tilthat le véletlenül.

Irányított eseménykezelő csatolása és implementálása

Az XAML-ben egy eseménykezelőt csatol egy elemhez úgy, hogy az eseménynevet attribútumként deklarálja az eseményfigyelő elemen. Az attribútum értéke a kezelő metódus neve. A kezelőmetódust az XAML lap részleges osztálya mögötti kódban kell implementálnia. Az eseményfigyelő az az elem, amelyhez az eseménykezelőt csatolja és amely meghívásra kerül.

A figyelőosztály tagjaként (örökölt vagy más módon örökölt) eseményhez az alábbiak szerint csatolhat kezelőt:

<Button Name="Button1" Click="Button_Click">Click me</Button>

Ha az esemény nem tagja a figyelő osztályának, akkor a minősített eseménynevet a következő formában kell használnia <owner type>.<event name>: . Ha például az StackPanel osztály nem implementálja az Click eseményt, akkor csatolnia kell egy kezelőt a StackPanel elemhez a Click eseményhez, amely az adott elemhez buborékol, és ehhez a minősített eseménynév szintaxisát kell használnia.

<StackPanel Name="StackPanel1" Button.Click="Button_Click">
    <Button>Click me</Button>
</StackPanel>

A kód mögötti eseménykezelő metódus aláírásának meg kell egyeznie az irányított esemény delegált típusával. Az sender esemény delegáltjának RoutedEventHandler paramétere Click határozza meg azt az elemet, amelyhez az eseménykezelő hozzá van kapcsolva. A args meghatalmazott paramétere RoutedEventHandler tartalmazza az eseményadatokat. Az eseménykezelő kompatibilis kód mögötti implementációja Button_Click a következő lehet:

private void Button_Click(object sender, RoutedEventArgs e)
{
    // Click event logic.
}

Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    ' Click event logic.
End Sub

Bár RoutedEventHandler az alapszintű irányított eseménykezelő delegált, egyes vezérlők vagy megvalósítási forgatókönyvek eltérő meghatalmazottakat igényelnek, amelyek speciálisabb eseményadatokat támogatnak. Az irányított esemény esetében például a DragEnter kezelőnek implementálnia kell a meghatalmazottat DragEventHandler . Így a kezelőkód hozzáférhet az DragEventArgs.Data eseményadatokban található tulajdonsághoz, amely tartalmazza a vágólap tartalmát a húzás műveletéből.

Az irányított eseménykezelők hozzáadásának XAML-szintaxisa megegyezik a standard CLR-eseménykezelőkével. További információ az eseménykezelők XAML-be történő hozzáadásáról a WPF-ben: XAML. Az eseménykezelő XAML használatával történő csatolásának teljes példáját az irányított események kezelése című témakörben talál.

Ha kód használatával szeretne eseménykezelőt csatolni egy irányított eseményhez, általában két lehetőség közül választhat:

• Közvetlenül hívja meg a metódust AddHandler . Az irányított eseménykezelők mindig így csatolhatók. Ez a példa egy eseménykezelőt Click csatol egy gombhoz a AddHandler következő módszerrel:

  Button1.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler(Button_Click));
  

  Button1.[AddHandler](ButtonBase.ClickEvent, New RoutedEventHandler(AddressOf Button_Click))
  

  Ha egy kezelőt szeretne csatolni a gomb eseményéhez Click az esemény útvonalának egy másik eleméhez, például egy StackPanel elnevezett elemhez StackPanel1:

  StackPanel1.AddHandler(ButtonBase.ClickEvent, new RoutedEventHandler(Button_Click));
  

  StackPanel1.[AddHandler](ButtonBase.ClickEvent, New RoutedEventHandler(AddressOf Button_Click))
  

• Ha az irányított esemény CLR-eseményburkolót implementál, a nyelvspecifikus eseményszintaxissal ugyanúgy adjon hozzá eseménykezelőket, mint egy szabványos CLR-eseményhez. A legtöbb meglévő WPF-hez irányított esemény implementálja a CLR-burkolót, így lehetővé teszi a nyelvspecifikus eseményszintaxis használatát. Ez a példa nyelvspecifikus szintaxissal csatol egy Click eseménykezelőt egy gombhoz:

  Button1.Click += Button_Click;
  

  AddHandler Button1.Click, AddressOf Button_Click
  

Az eseménykezelő kódban való csatolására példa: Eseménykezelő hozzáadása kóddal. Ha a Visual Basicben kódol, a Handles kulcsszóval kezelőket is hozzáadhat a kezelői deklarációk részeként. További információkért lásd a(z) Visual Basic és WPF eseménykezelésrészt.

A kezelt

Az összes átirányított esemény közös alaposztályt használ az eseményadatokhoz, vagyis az RoutedEventArgs osztályhoz. Az RoutedEventArgs osztály határozza meg a logikai Handled tulajdonságot. A tulajdonság célja, Handled hogy az eseményútvonal bármely eseménykezelője megjelölje a kezelt eseményt. Ha egy eseményt kezelve szeretne megjelölni, állítsa az eseménykezelő kódban szereplő értékre Handledtrue .

Az Handled értéke befolyásolja, hogyan dolgozzák fel az irányított eseményt, miközben végighalad az eseményútvonalon. Ha Handled szerepel egy irányított esemény megosztott eseményadataiban true, akkor az eseményútvonalon további elemekhez csatolt kezelőket általában nem hívják meg az adott eseményre. A leggyakoribb kezelői forgatókönyvek esetében az esemény megjelölése kezelveként hatékonyan megakadályozza, hogy az eseményútvonal mentén a későbbi kezelők, akár példány- vagy osztálykezelők, válaszoljanak az adott eseménypéldányra. Olyan ritka esetekben, amikor az eseménykezelőnek válaszolnia kell az irányított eseményekre, amelyek kezeltnek lettek jelölve, a következőket teheti:

• Csatolja a kezelőt a kód mögött a AddHandler(RoutedEvent, Delegate, Boolean) túlterhelés használatával, a handledEventsToo paraméter következőre van true állítva.

• Állítsa be az HandledEventsToo attribútumot EventSetter értékként true.

A koncepció Handled befolyásolhatja az alkalmazás tervezését és az eseménykezelők kódját. Az irányított események feldolgozására szolgáló egyszerű protokollként fogható Handled fel. A protokoll használatának menete az Ön feladata, de a paraméter várható használata a Handled következő:

• Ha egy irányított esemény kezeléseként van megjelölve, akkor az útvonal más elemeinek nem kell újra kezelniük.

• Ha egy irányított esemény nincs kezelveként megjelölve, akkor az eseményútvonal korábbi figyelői nem rendelkeznek az esemény kezelőjével, vagy egyik regisztrált kezelő sem válaszolt az eseményre oly módon, amely igazolja, hogy az eseményt kezeltként jelöli meg. Az aktuális figyelő kezelőinek három lehetséges művelete van:

  • Egyáltalán ne tegyen lépéseket. Az esemény kezeletlen marad, és továbbítódik a következő hallgatónak a fában.

  • Futtassa a kódot az eseményre válaszul, de nem olyan mértékben, hogy indokolná az esemény kezeltként való megjelölését. Az esemény kezeletlen marad, és továbbítódik a következő hallgatónak a fában.

  • Futtassa a kódot az eseményre válaszul, olyan mértékben, amely indokolja az esemény kezeléseként való megjelölést. Az eseményadatokban jelölje meg az eseményt kezeltként. Az esemény továbbra is a következő figyelőhöz irányítja a fát, de a legtöbb figyelő nem hív meg további kezelőket. Kivételt képeznek azok a figyelők, amelyek kifejezetten handledEventsToo kezelőkkel lettek regisztrálva true beállítással.

Az irányított események kezelésével kapcsolatos további információkért lásd: Az irányított események megjelölése kezeltként és osztálykezelés.

Bár azok a fejlesztők, akik csak azon az objektumon kezelik a buborékos útvonal-eseményt, amely kiváltotta azt, előfordulhat, hogy nem foglalkoznak más figyelőkkel, mégis célszerű az eseményt kezeltként jelölni. Ez megakadályozza a nem várt mellékhatásokat, ha az eseményútvonal mentén egy elem rendelkezik ugyanahhoz az irányított eseményhez tartozó kezelővel.

Osztálykezelők

Az irányított eseménykezelők lehetnek példány kezelők vagy osztály kezelők. Az adott osztály osztálykezelői azelőtt lesznek meghívva, hogy bármely példánykezelő válaszol az adott osztály bármely példányán ugyanarra az eseményre. Emiatt a viselkedés miatt, amikor az irányított eseményeket kezeltnek jelölik, gyakran az osztálykezelőkben is így jelölik meg őket. Az osztálykezelőknek két típusa van:

• Statikus osztály eseménykezelői, amelyek a RegisterClassHandler metódus statikus osztálykonstruktoron belüli meghívásával vannak regisztrálva.
• Az osztály eseménykezelőit felülbírálja, amelyeket az alaposztály virtuális esemény metódusainak felülbírálásával regisztrálnak. Az alaposztály virtuális eseménymetódusai elsősorban bemeneti eseményekhez léteznek, és nevük az On<eseménynév> és OnPreview<eseménynév>minták szerint kezdődik.

Egyes WPF-vezérlők bizonyos irányított események kezeléséhez már beépítetten rendelkeznek osztályszintű kezeléssel. Az osztálykezelés úgy tűnhet, hogy az irányított esemény soha nem váltódik ki, de valójában egy osztálykezelő által kezeltként van megjelölve. Ha az eseménykezelőnek válaszolnia kell a kezelt eseményre, regisztrálhatja a kezelőt a következő beállítással handledEventsTootrue: . A saját osztálykezelők implementálásával vagy a nem kívánt osztálykezeléssel kapcsolatos további információkért lásd: Az irányított események megjelölése kezeltként és osztálykezelés.

Csatolt események a WPF-ben

Az XAML nyelv egy speciális eseménytípust is definiál, amely egy csatolt esemény. A csatolt események segítségével definiálhat egy új irányított eseményt egy nem-elemi osztályban, és kiválthatja azt az eseményt a fa bármelyik elemén. Ehhez a csatolt eseményt irányított eseményként kell regisztrálnia, és meg kell adnia konkrét háttérkódot, amely támogatja a csatolt eseményfunkciót. Mivel a csatolt események átirányított eseményként vannak regisztrálva, amikor egy elemen emelik fel őket, az elemfán keresztül propagálódnak.

Az XAML szintaxisban a csatolt eseményeket az esemény neve és a tulajdonos típusa határozza meg, a következő formában <owner type>.<event name>: . Mivel az esemény neve a tulajdonos típusának nevével van minősítve , a szintaxis lehetővé teszi, hogy az esemény bármely olyan elemhez csatolható legyen, amely példányosítható. Ez a szintaxis az eseményútvonal egy tetszőleges eleméhez kapcsolódó rendszeres, irányított események kezelőire is alkalmazható. A kód mögötti kódban lévő csatolt események kezelőihez is csatolhat kezelőket, ha meghívja a AddHandler metódust azon az objektumon, amelyhez a kezelőnek hozzá kell csatolnia.

A WPF bemeneti rendszere széles körben használja a csatolt eseményeket. A csatolt események szinte mindegyike azonban az alap elemek révén egyenértékű, nem csatolt irányított eseményekként van feltüntetve. Ritkán fogja közvetlenül használni vagy kezelni a csatolt eseményeket. Egyszerűbb például az alapul szolgáló csatolt Mouse.MouseDown esemény kezelése a megfelelő UIElement irányított eseményen keresztül egy UIElement.MouseDown-en, mint a csatolt esemény szintaxisának a XAML-ben vagy a kód mögötti használatával.

A WPF csatolt eseményeiről további információt a Csatolt események áttekintése című témakörben talál.

Minősített eseménynevek az XAML-ben

A <owner type>.<event name> szintaxis az esemény nevét a tulajdonos típusának nevével minősíti. Ez a szintaxis lehetővé teszi az események bármely elemhez való csatlakoztatását, nem csak azokat az elemeket, amelyek az eseményt az osztályuk tagjaként implementálják. A szintaxis akkor alkalmazható, ha az XAML-ben kezelőket csatol a csatolt eseményekhez vagy az eseményútvonal tetszőleges elemeihez irányított eseményekhez. Fontolja meg azt a forgatókönyvet, amelyben egy kezelőt egy szülőelemhez szeretne csatolni a gyermekelemeken létrehozott irányított események kezeléséhez. Ha a szülőelem nem rendelkezik tagként az irányított eseménysel, a minősített eseménynév szintaxisát kell használnia. Például:

<StackPanel Name="StackPanel1" Button.Click="Button_Click">
    <Button>Click me</Button>
</StackPanel>

A példában az a szülőelem-figyelő, amelyhez az eseménykezelő hozzá van adva, egy StackPanel. Az Click irányított esemény az ButtonBase osztályon van implementálva és meghívva, és azonban az öröklésen keresztül érhető el az Button osztály számára. Bár az Button osztály "birtokolja" az Click eseményt, az irányított eseményrendszer lehetővé teszi a kezelők számára, hogy minden olyan irányított eseményt csatoljanak bármely UIElement vagy ContentElement példányfigyelőhöz, amely egyébként rendelkezhet a CLR-esemény kezelőivel. A minősített eseményattribútum-nevek alapértelmezett xmlns névtere általában az alapértelmezett WPF-névtér xmlns , de egyéni irányított eseményekhez is megadhat előtaggal ellátott névtereket. További információ: xmlnsXAML-névterek és névtérleképezés a WPF XAML-hez

WPF bemeneti események

Az irányított események egyik gyakori alkalmazása a WPF-platformon a bemeneti eseményekre

A párokban megjelenő WPF bemeneti események úgy vannak megvalósítva, hogy egy bemeneti eszköz egyetlen felhasználói művelete, például az egérgomb lenyomása, beindítja először az előnézeti, majd a buborékoló irányított eseményeket. Először az előzetes esemény aktiválódik, és végigfut az útvonalán. Az előzetes verziójú esemény befejezésekor a buborékos esemény fel lesz emelve, és befejezi az útvonalát. A RaiseEvent végrehajtási osztály metódushívása, amely a buborékos eseményt emeli, újra felhasználja az eseményadatokat az előzetes verziójú eseményből a buborékos eseményhez.

A kezeltként megjelölt előzetes beviteli esemény nem hív meg normál módon regisztrált eseménykezelőket az előnézeti útvonal fennmaradó részére, és a párosított buborékos esemény nem lesz elindítva. Ez a kezelési viselkedés olyan összetett vezérlők tervezői számára hasznos, akik hit-tesztalapú bemeneti eseményeket vagy fókuszalapú bemeneti eseményeket szeretnének jelenteni a vezérlő legfelső szintjén. A vezérlő legfelső szintű elemei osztályba rendezhetik a vezérlő alösszetevőiből származó előnézeti eseményeket, hogy "lecseréljék" őket egy legfelső szintű vezérlőspecifikus eseményre.

A bemeneti eseményfeldolgozás működésének szemléltetéséhez tekintse meg a következő bemeneti esemény példáját. Az alábbi fa ábrán leaf element #2 mind a PreviewMouseDown, mind a MouseDown párosított események forrása.

A 2. levélelemen az egérrel lefelé irányuló művelet utáni eseményfeldolgozás sorrendje a következő:

1. PreviewMouseDown bújtatási esemény a gyökérelemen.
2. PreviewMouseDown alagút esemény a köztes elem #1-en.
3. PreviewMouseDown bújtatási esemény a 2. levélelemen, amely a forráselem.
4. MouseDown bubbling event on leaf element #2, azaz a forráselem.
5. MouseDown buborékoló esemény az 1. számú köztes elemen.
6. MouseDown buborékoló esemény a gyökérelemen.

Az átirányított eseménykezelő delegált mind az eseményt felindító objektumra, mind a kezelő meghívására szolgáló objektumra hivatkozik. Az eseményt eredetileg felhozó objektumot a Source tulajdonság jelenti az eseményadatokban. Azt az objektumot, amelyben a kezelőt meghívták, a feladó paramétere jelenti. Egy adott irányított eseménypéldány esetében az eseményt felhozó objektum nem változik, ahogy az esemény az elemfán halad át, de az sender igen. Az előző diagram 3. és 4. lépésében az Source és sender ugyanaz az objektum.

Ha a bemeneti eseménykezelő végrehajtja az esemény kezeléséhez szükséges alkalmazásspecifikus logikát, akkor a bemeneti eseményt kezelként kell jelölni. A bemeneti esemény megjelölése Handledután a rendszer általában nem hívja meg a kezelőket az eseményútvonal mentén. Azonban a handledEventsToo paraméterkészlettel regisztrált bemeneti eseménykezelők akkor is meghívásra kerülnek, ha az esemény kezelve van megjelölve. További információ: Bemutató események és irányított események kezeléseként történő megjelölése, valamint osztálykezelés.

Az előnézeti és a buborékoló eseménypárok koncepciója, a megosztott eseményadatokkal és az előnézeti esemény, majd a buborékoló esemény szekvenciális indításával, csak néhány WPF bemeneti eseményre vonatkozik, és nem minden irányított eseményre. Ha saját bemeneti eseményt implementál egy speciális forgatókönyv kezelésére, fontolja meg a WPF bemeneti eseménypár megközelítésének követését.

Ha saját összetett vezérlőt implementál, amely reagál a bemeneti eseményekre, fontolja meg az előzetes verziójú események használatát az alkomponenseken létrehozott bemeneti események letiltásához és cseréjéhez egy legfelső szintű eseményre, amely a teljes vezérlőt képviseli. További információért lásd: Az irányított események megjelölése kezeltként és osztálykezelés.

További információ a WPF bemeneti rendszeréről, valamint a bemenetek és események tipikus alkalmazási helyzetekben való használatáról: Input overview

EseményBeállítók és EseményKiváltók

A jelölési stílusokban előre deklarált XAML eseménykezelési szintaxist is megadhat egy EventSetter segítségével. Az XAML feldolgozásakor a rendszer hozzáadja a hivatkozott kezelőt a stíluspéldányhoz. Csak irányított eseményhez deklarálhat EventSetter egy eseményt. Az alábbi példában a hivatkozott ApplyButtonStyle eseménykezelő metódus a kód mögötti kódban van implementálva.

<StackPanel>
    <StackPanel.Resources>
        <Style TargetType="{x:Type Button}">
            <EventSetter Event="Click" Handler="ApplyButtonStyle"/>
        </Style>
    </StackPanel.Resources>
    <Button>Click me</Button>
    <Button Click="Button_Click">Click me</Button>
</StackPanel>

Valószínű, hogy a Style csomópont már tartalmaz más stílusinformációkat, amelyek a megadott típusú vezérlőkre vonatkoznak, és ha ezek EventSetter a stílusok részei, akkor a kód újrahasználata még a korrektúra szintjén is előléptethető. Emellett a EventSetter a kezelők metódusneveit absztrahálja az általános alkalmazástól és az oldaljelöléstől.

Egy másik speciális szintaxis, amely egyesíti a WPF irányított esemény- és animációs funkcióit, egy EventTrigger. Ahogy az is EventSetter, csak egy irányított eseményhez deklarálhat egy EventTrigger eseményt. Az EventTrigger jellemzően stílus részeként kerül deklarálásra, de a EventTrigger deklarálható oldalszintű elemeknél a Triggers gyűjtemény részeként vagy egy ControlTemplate-ben. A EventTrigger lehetővé teszi egy olyan Storyboard megadását, amely akkor fut, amikor egy irányított esemény elér egy elemet az útvonalán, amely EventTrigger deklarál az adott eseményhez. A EventTrigger előnye a pusztán eseménykezelést és egy meglévő forgatókönyv elindítását illetően az, hogy egy EventTrigger jobb irányítást biztosít a forgatókönyv és annak futásidejű viselkedése felett. További információ: Eseményindítók használata a storyboard indítását követően

További információ az irányított eseményekről

A cikkben szereplő fogalmakat és útmutatást kiindulópontként használhatja az egyéni irányított események saját osztályokban való létrehozásakor. Az egyéni eseményeket speciális eseményadatosztályokkal és meghatalmazottakkal is támogathatja. Az irányított eseménytulajdonos bármilyen osztály lehet, de az irányított eseményeket a hasznosság érdekében UIElement vagy ContentElement származtatott osztályoknak kell felemelnie és kezelnie. Az egyéni eseményekről további információt az Egyéni irányított esemény létrehozása című témakörben talál.

Lásd még

• EventManager
• RoutedEvent
• RoutedEventArgs
• Az irányított események kezelteként megjelölése és az osztályon belüli kezelés
• bemenetek áttekintése
• Parancsoló áttekintés
• egyéni függőségi tulajdonságok
• Fastruktúrák a WPF-ben
• Gyenge eseményminták