Űrlapok testreszabása és készítése a Service Manager Authoring Toolokkal – áttekintésOverview of customizing and authoring forms with the Service Manager Authoring Tool

Fontos

A Service Manager ezen verziója elérte a támogatás végét, javasoljuk, hogy frissítsen a Service Manager 2019-re.This version of Service Manager has reached the end of support, we recommend you to upgrade to Service Manager 2019.

Az űrlap olyan ablak, amelyen keresztül a felhasználók használni tudják az adatbázisból származó objektumokat.A form is a window that makes it possible for users to interact with objects from the database. Az űrlapok objektumok tulajdonságainak megtekintésére és szerkesztésére szolgálnak.Users can use a form to view and edit the properties of objects. Minden egyes űrlap meghatározott célosztályhoz kötődik, és csak az adott célosztály példányainak adatait jeleníti meg. Each form is tied to a specific class, and it displays information only for instances of the targeted class. Az űrlapok mezőkből épülnek fel.A form contains fields. Az egyes mezők általában az űrlap megcélzott osztályának egy adott tulajdonságához vannak kötve.Typically, each field is bound to a specific property of the form's targeted class. Az incidensűrlap például az incidensobjektumhoz kötődik.The incident form, for example, is tied to the incident object. Éppen ezért az adatbázisban szereplő incidensobjektumokkal kapcsolatos adatokat jeleníti meg.Therefore, the incident form displays information about incident objects in the database.

A Service Manager űrlap a Windows megjelenítési alaprendszer WPF- ( ) űrlap implementációját tartalmazza egy Microsoft .net   Framework szerelvényben, és egy Service Manager felügyeleti csomagban lévő űrlap-definícióban.A Service Manager form consists of the Windows Presentation Foundation (WPF) form implementation in a Microsoft .NET Framework assembly and a form definition in a Service Manager management pack. Az űrlap-definíció meghatározza az űrlap által képviselt osztályt, valamint az űrlap más egyéb tulajdonságait.The form definition specifies the class that the form represents, along with the other properties of the form.

Az űrlapokkal kapcsolatos alapfogalmakKey concepts about forms

Az űrlapok testreszabása előtt ismerkedjen meg az alábbi, az űrlapokkal kapcsolatos alapfogalmakkal.Before customizing forms, you should be familiar with the following form concepts.

Űrlapok használataHow forms are used

Ha az űrlap-definíciókat tartalmazó felügyeleti csomagot Service Managerba importálják, az űrlap-definíciók az adatbázisban tárolódnak.When the management pack that contains the form definitions is imported into Service Manager, the form definitions are stored in the database. Később, amikor a felhasználó egy objektum megjelenítését igénylő Service Manager konzolos feladatot indít el, Service Manager meg kell találnia egy űrlapot a kért objektum megjelenítéséhez.Later, when the user initiates a Service Manager console task that requires the display of an object, Service Manager must find a form to display the requested object. Service Manager hozzáfér az adatbázishoz, és megkeresi az adott objektumhoz definiált űrlapot.Service Manager accesses the database and searches for a form that has been defined for that object. Ha nincs űrlap definiálva az objektumhoz, Service Manager megkeres egy űrlapot, amely meg van adva az objektum szülőobjektum objektumához.If no form is defined for the object, Service Manager searches for a form that is defined for the object's parent object. Service Manager folytatja a keresést a teljes objektum öröklési hierarchiájában, amíg meg nem találja a megadott űrlapot.Service Manager continues to search the entire object's inheritance hierarchy until it finds a defined form.

Általános űrlapokGeneric forms

Ha Service Manager nem talál semmilyen űrlapot az objektumhoz vagy valamelyik szülő objektumához, Service Manager dinamikusan létrehoz egy alapértelmezett általános űrlapot az adott objektumhoz.If Service Manager cannot find any form for the object or for any of its parent objects, Service Manager dynamically builds a default generic form for that object. Az általános űrlap olyan rendszer - által generált űrlap, amely elegendő az egyszerű űrlapos használatra.The generic form is a system-generated form that is sufficient for simple form use. Az általános űrlap gyors és egyszerű módszer az objektumokhoz tartozó űrlapok előállítására úgy, hogy nincs szükség űrlap-definícióra.The generic form represents a quick and easy way to create a form for objects without any form definitions.

Az általános űrlapon alapesetben egyszerű, nem módosítható elrendezéssel jelenik meg az összes tulajdonság.By default, the generic form displays all the properties of the form in a simple layout that you cannot change. Az általános űrlapon az öröklési hierarchiában található összes szülőobjektum tulajdonságai megjelennek, és ez a típusú működés nem módosítható.The generic form displays the properties of all the parent objects in the inheritance hierarchy of the form, and you cannot change that behavior. Az általános űrlapot korlátozott mértékben lehet testreszabni.Customizations to the generic form are limited. Megadható például, hogy mely tulajdonságok jelenjenek meg az általános űrlapon; ugyanakkor az általános űrlap nem használható testreszabások alapjaként.For example, you can specify the properties that you want the generic form to display; however, the generic form cannot be used as a basis for customization. Ha később egyéni űrlapot határoz meg az adott objektumhoz, az egyéni űrlap felülírja az objektum általános űrlapját.If you later define a custom form for that object, your custom form overwrites the object's generic form.

A tulajdonságok általános űrlapon való elrejtésével és az általános űrlapok testreszabásával kapcsolatos további információkért tekintse meg az űrlap-infrastruktúra és az általános űrlap blogbejegyzésének áttekintését.For information about hiding properties in a generic form and other ways that you can customize a generic form, see the blog post Overview of the Forms Infrastructure and the Generic Form.

Kombinált osztályok az űrlapokonCombination classes in forms

Egyes esetekben több osztályból származó információkat kell megjeleníteni egy űrlapon.Sometimes, you need a form to display information that is derived from more than one class. Ehhez létre kell hoznia egy kombinált osztályt , majd hozzá kell kötnie egy mezőt az űrlapon a kombinált osztályhoz.To do this, you create a combination class and then bind a field on the form to the combination class. A kombinált osztályokkal kapcsolatos további információkért lásd: a System Center közös sémájának módosításai.For more information about combination classes, see Changes to the System Center Common Schema.

Az űrlap funkcionális szempontjaiFunctional aspects of a form

Az űrlapok működési jellemzőit az alábbiakban foglaltuk össze:A form has the following functional aspects:

  1. InicializálásInitialization

  2. Méret és helySize and location

  3. FrissítésRefresh

  4. Változások elküldéseSubmit changes

Az alábbi szakaszok ismertetik ezeket az jellemzőket.These aspects are described in the following sections.

InicializálásInitialization

Az inicializálás során a rendszer elemzi az űrlap Extensible Application Markup Language ( XAML, ) és az űrlap összes vezérlőjét létrehozza és betölti.During initialization, a form's Extensible Application Markup Language (XAML) is parsed and all controls on the form are instantiated and loaded. Az űrlap betöltött eseménye jelzi, hogy az űrlap és a benne foglalt elemek betöltése megtörtént-e.The form's Loaded event indicates when the form and all contained elements have been loaded. Az - betöltési műveletek aszinkronak.Data-loading operations are asynchronous. Ezért előfordulhat, hogy a célként megadott példány nem érhető el a betöltött esemény bekövetkezésekor.Therefore, the target instance may not be available when the Loaded event is raised. Ehelyett az DataContextChanged eseményt kell használni az értesítéshez, ha a cél példány az űrlaphoz van beállítva.Instead, the DataContextChanged event must be used for notification when the target instance is set for the form. A DataContext elemet tulajdonság PropertyChanged eseménye a DataContextChanged esemény helyett használható.The PropertyChanged event for the DataContext property can be used in place of the DataContextChanged event.

Javasoljuk, hogy használja a betöltött eseményt a vezérléshez - kapcsolódó egyéni inicializáláshoz, majd használja a DataContextChanged vagy a PropertyChanged eseményt a DataContext elemet tulajdonságban a cél példányhoz - kapcsolódó egyéni inicializáláshoz.We recommend that you use the Loaded event for control-related custom initialization and then use the DataContextChanged or PropertyChanged events on the DataContext property for target instance-related custom initialization.

Méret és helySize and location

Ha egy űrlap megjelenik egy előugró - ablakban, a kezdeti méret az űrlap szélessége, magassága, MinWidth értékénélés MinHeight tulajdonságai alapján lesz meghatározva.When a form is displayed in a pop-up window, its initial size is determined based on the form's Width, Height, MinWidth, and MinHeight properties. Ha ezek a tulajdonságok nincsenek beállítva az űrlaphoz, az űrlap kezdeti méretét a tartalom alapján számítja ki a rendszer.If these properties are not set for the form, the form's initial size is calculated based on its content.

Javasoljuk, hogy a tulajdonságok értékét az alábbiak szerint állítsa be:We recommend that you set these properties as follows:

  • Az űrlap szélesség és magasság tulajdonságának beállításával explicit módon megadhatja az ideális méretet.Set the Width and Height properties of the form to explicitly specify the ideal size. Érdemes lehet ezeket a tulajdonságokat az automatikus értékre beállítani.Consider setting these properties to the Auto value. Ezzel beállítja az űrlap szélességét és magasságát a tartalom méretétől függően.This sets the width and height of the form based on the size of the content.

  • Az űrlap MinWidth értékénél és MinHeight tulajdonságainak beállításával megadhatja az űrlaphoz elfogadható legkisebb ablakot.Set the MinWidth and MinHeight properties of the form to specify the smallest window acceptable for the form. Ha a felhasználó a megadottnál kisebbre kicsinyíti az ablakot, az éppen nem látható tartalom elérésére használható gördítősávok jelennek meg.If a user resizes the window to a smaller size than specified, scrollbars appear for scrolling to the hidden form content.

Ha az űrlap a Service Manager Forms gazdagépen belül található, az utolsó - felhasznált méret és hely megmarad az űrlap későbbi, ugyanazon futtatási munkameneten belüli megjelenítéséhez.When the form is hosted inside the Service Manager forms host, the last-used size and location is preserved for subsequent display of that form by the same user within the same run session.

FrissítésRefresh

Az űrlap cél példánya az űrlapon található frissítési parancs végrehajtása miatt változhat.The target instance of a form can change as a result of executing a Refresh command on the form. A parancs kezelője új adatokat kérdez le az adatbázisból.The handler for this command fetches new data from the database. Amikor az adatküldés megérkezik, az űrlap DataContext elemet tulajdonságának értéke az új cél példányra van állítva, a DataContextChanged eseményt pedig megemeli.When the data arrives, the form's DataContext property value is set to the new target instance and the DataContextChanged event is raised.

Az űrlap első betöltésekor kiváltott DataContextChanged -esemény és a frissítési parancs kezelésére szolgáló esemény közötti különbségtétel ellenőrzéséhez a OldValue tulajdonságot kell megadnia az esemény által átadott argumentumok esetében.To differentiate between the DataContextChanged event that was raised when the form was first loaded and the event that was raised to handle a Refresh command, check the OldValue property of the event arguments that are passed in with the event. Az űrlap inicializálásakor ez a tulajdonság nullértékű.This property is null if the form has just been initialized.

Változások elküldéseSubmit changes

A Service Manager űrlap-gazdagép felugró - ablaka az űrlapon végrehajtott módosítások elküldésére és a felugró ablak bezárására szolgáló gombokat tartalmaz - .The form host pop-up window in Service Manager provides buttons for submitting changes that are made in the form and for closing the pop-up window.

Amikor a felhasználó rákattint egy űrlap Apply (alkalmaz ) gombjára, a rendszer elküldi az űrlap céljának tároló példányát.When a user clicks the Apply button for a form, the form's target instance is submitted for storage. Ez a művelet szinkron jellegű, vagyis a felhasználó nem módosíthatja az űrlap tartalmát, amíg az elküldési művelet be nem fejeződött.This operation is synchronous; therefore, the user cannot edit the form until the submission operation is complete. Ha hiba történik az űrlap elküldésekor, hibaüzenet jelenik meg.If failure occurs during the form submission, an error message appears. Az űrlap nyitva marad, és további módosítások is végezhetők rajta.The form remains open for further changes. Javasoljuk, hogy a felhasználók minél gyakrabban mentsék a változtatásokat, így elkerülhetik az ütközéseket, ha más is szerkeszti ugyanannak az űrlapnak egy másik példányát.We recommend that users apply their changes frequently to avoid collisions if another instance of the form is being edited at the same time.

Ha a felhasználó az OK gombra kattint, a viselkedés hasonló az alkalmazáshoz, kivéve, ha az űrlap beküldési művelete sikeres, az űrlap és a gazdagép ablaka le van zárva.If the user clicks the OK button, the behavior is similar to Apply, except that, if the form submission operation is successful, the form and its host window are closed.

Ha a felhasználó a Mégse gombra kattint, megjelenik egy párbeszédpanel, amely megkéri a felhasználót, hogy erősítse meg a műveletet.If the user clicks the Cancel button, a dialog box appears that asks the user to confirm the operation. A felhasználó az Igen gombra kattintva elveszítheti a módosításokat, vagy a nem gombra kattintva visszatérhet az űrlapra.The user can click Yes and lose changes, or click No and return to the form.

Általános irányelvek és ajánlott eljárások az űrlapokhozGeneral guidelines and best practices for forms

A Service Manager funkcióit űrlapok hozzáadásával vagy módosításával bővítheti.You can extend features of Service Manager by adding or modifying forms. Ez a témakör néhány ajánlott eljárást ismertet a Service Manager űrlapok létrehozásához és használatához, a különböző eszközök és parancsfájlok űrlapos definíciók használatával.This topic describes some best practice recommendations for creating and using Service Manager forms, using various tools and scripting form definitions directly.

Ez a témakör elsősorban azokat a partnereket és ügyfeleket célozza meg, akik a Windows megjelenítési alaprendszer ( WPF ) és a Microsoft Visual   Studio Team System vagy a Microsoft Expression Blend használatával felépítik saját egyéni űrlapjaikat.This topic is primarily targeted at partners and customers who are experienced in building their own custom forms by using Windows Presentation Foundation (WPF) and Microsoft Visual Studio Team System or Microsoft Expression Blend.

Az új űrlapok létrehozásával kapcsolatos általános irányelvek az alábbiak.The general guidelines for authoring a new form are as follows.

  • Használjon szabványos vezérlőket.Use standard controls.
  • Kövesse az általános űrlaptervezési irányelveket.Follow general form design guidelines.
  • Kerülje a kód - hátterét.Avoid code-behind.
  • Használjon kivételkezelést.Include exception handling.
  • Vegye figyelembe az űrlapok testreszabási és frissítési lehetőségeit.Consider forms customization and upgrades.
  • Nevezze el az összes testreszabható vezérlőt.Name all customizable controls.
  • Kapcsolja az űrlapot adatforrásokhoz.Bind the form to data sources.
  • Használja Service Manager űrlap-infrastruktúra érvényesítési szabályait, az érték-átalakítókat és a hiba-sablonokat.Use Service Manager forms infrastructure validation rules, value convertors, and error templates.
  • Használja az űrlap-infrastruktúra parancsait és eseményeit.Use forms infrastructure commands and events.

Az irányelvekkel kapcsolatos további információkért lásd a következő részeket.For information about these guidelines, see the following sections.

Szabványos vezérlők használataUse standard controls

Az űrlapokon használt vezérlők a következő típusúak lehetnek:Controls that are used on a form can be:

  • Szabványos vezérlők.Standard controls. Ilyenek a .NET könyvtár vezérlői, például a kombinált lista és a listamező.This includes .NET library controls, such as combo box and list box.
  • Egyéni vezérlők.Custom controls. Ilyenek azok a további vezérlők, amelyeket az űrlap készítője vagy harmadik fél hoz létre.This includes additional controls that are created by the form author or by a third party.

Tipp

Ha szabványos vezérlőket használ és lehetőség szerint kerüli az egyéni vezérlők létrehozását, az űrlapokkal kapcsolatos felhasználói élmény egységesebb lesz.When you use standard controls wherever possible and avoid creating custom controls, you promote consistency with regard to the user experience of forms. Ha mindenképpen szükség van egyéni vezérlő létrehozására, annak vizuális megjelenését és viselkedését, valamint a logikai viselkedést különítse el úgy, hogy vezérlősablonok használatával definiálja a vezérlő megjelenését.If you must create a custom control, separate the visual appearance and behavior and the logical behavior by using control templates to define the appearance of the control. Ideális esetben minden Windows-témához külön vezérlősablon tartozik.Preferably, there should be a separate control template for each Windows Theme.

Az általános űrlap kialakítására vonatkozó irányelvek követéseFollow general form design guidelines

Űrlap tervezésekor a nyilvános kialakítási irányelvek segítségével biztosíthatja, hogy az űrlap felhasználóbarát legyen, és hogy megfeleljen a közös felhasználói - interakciós paradigmának.When you design a form, use public design guidelines to ensure that the form is user friendly and that it adheres to common user-interaction paradigms.

További információ az általános Windows-kialakításról: Windows felhasználói élmény – interakciós irányelvek.For more information about general Windows design, see Windows User Experience Interaction Guidelines.

Továbbá:In addition:

  • Az információkat ossza szét több lapra, hogy az űrlap egyszerűbb és könnyebben olvasható legyen.Divide information across multiple tabs to make the form simpler and easier to read. A leggyakrabban használt információkat az első lapra helyezze, a kevésbé fontosakat pedig a további lapokra.Include the most commonly used information on the first tab and information of lesser importance on subsequent tabs.
  • Használjon elrendezési paneleket az űrlap vezérlőinek elrendezéséhez.Use layout panels to lay out controls on the form. Ezzel biztosíthatja, hogy az űrlap átméretezéskor és honosítás esetén is megfelelően viselkedjen.This ensures that the form behaves correctly when it is resized and localized.
  • Kerülje a vezérlők megjelenítési tulajdonságainak külön-külön történő beállítását, ehelyett használjon stílusokat.Avoid setting individual control visual properties, and use styles instead. Így a stílus módosításával több űrlapon egyszerre módosíthatja a vezérlők küllemét, ami egységes megjelenést tesz lehetővé az egymáshoz kapcsolódó űrlapokon.This makes it possible for you to change the appearance of all controls across a series of forms by modifying the style, and it promotes a consistent appearance across related forms.

Kerülje a kód mögéAvoid code-behind

A - mögöttes kód egy kifejezés, amely leírja, hogy mely kód - definiált objektumokhoz csatlakozik, amikor egy XAML-oldal a korrektúrák lefordításakor szerepel.Code-behind is a term that describes the code that is joined with markup-defined objects when an XAML page is markup compiled. A lehető legnagyobb mértékben korlátozza a kód használatát az - űrlapon.Limit the use of code-behind in a form as much as possible. Érdemes az űrlap kódját magába a vezérlőbe ágyazni, mert így később könnyebben módosítható.It is preferable that you embed the code for a form in the control itself, because later it is easier to change that code. Ehelyett használja a Service Manager űrlapalapú infrastruktúra által támogatott deklaratív képességeket az érték-átalakítások és az érvényesítési szabályok definiálásához az űrlapon.Instead, use the declarative capabilities that are supported by the Service Manager forms infrastructure to define value conversions and validation rules in the form.

Általános útmutatóként korlátozni kell a kód használatát olyan helyzetekben, - amikor nem lehetséges a szükséges funkciók megadására a XAML deklaratív képességeinek használatával, a WPF és a Forms Infrastructure könyvtárában definiált osztályokkal.As a general guideline, you should limit the use of code-behind to situations in which it is not possible to provide the required functionality by using the declarative capabilities of XAML, with classes defined in the WPF and the forms infrastructure library. Ezt követően érdemes lehet áthelyezni a kód mögött megvalósított funkciókat - egy segítő könyvtárba, majd hivatkozni a XAML.Even then, consider moving the functionality that is implemented in code-behind into a helper library, and then reference it from the XAML.

Kivételek kezelési felszámításaInclude exception handling

Győződjön meg arról, hogy az űrlapon található kód kivételeket tartalmaz, hogy az űrlap az authoring Tool és a Service Manager-konzolon a futtatási fázisban is betölthető legyen.Ensure that the code in the form contains exception handling so that the form can be loaded both during the design phase in the Authoring Tool and in the Service Manager console at run time.

Az űrlapok testreszabásának és frissítésének megfontolásaConsider forms customization and upgrades

Amikor új űrlapot tervez, gondoljon az űrlap jövőbeli testreszabási és frissítési lehetőségeire is.When you are designing a new form, you should consider future customizations and upgrades to that form. Ahhoz, hogy az űrlap testreszabható és frissíthető legyen, miközben megőrzi a korábbi testreszabásokat is, kövesse az ebben a részben korábban leírt irányelveket és tippeket, valamint a következő irányelveket:To ensure that it is possible to customize and to upgrade a form while preserving customizations, follow the guidelines and tips that are provided previously in this section, along with the following guidelines:

  • Az űrlap tervezésekor már jó előre vegye figyelembe a jövőbeli testreszabásokat és frissítéseket.Consider future customizations and upgrades early while you are designing the form. Az űrlapok a későbbi verziókban valószínűleg fejlettebbé válnak, ezért fontos megtervezni, hogyan frissíthetik majd a felhasználók az űrlapot az új verziókra úgy, hogy közben az eredeti űrlapon végzett testreszabásokat se veszítsék el.Forms are likely to evolve in future versions, and it is important to consider how users will be able to upgrade to new versions of your form while preserving their customizations to the original form. Képzelje el például, hogy frissített űrlapot tesz elérhetővé azután, hogy a felhasználók már rengeteg energiát fordítottak az eredeti űrlap testreszabására.For example, you might provide an updated form after users have already invested heavily in customizing your original form. A felhasználók ilyenkor azt várják el, hogy a testreszabások a verziófrissítés során megőrződjenek.Users expect their customizations to survive the version upgrade.

  • Adjon egyedi nevet az űrlap minden vezérlőjének, hogy a testreszabások a vezérlőkre is alkalmazhatók legyenek.Provide a unique name for each control on the form to make it possible for customizations to be applied to controls. Az űrlapok testreszabásai műveletekként tárolódnak, amelyek egy adott vezérlőt vagy vezérlőcsoportot céloznak meg.Form customizations are stored as a set of actions that are targeted at a specific control or a set of controls. Az érintett vezérlőre történő hivatkozás a név alapján történik, ezért fontos, hogy a vezérlőnevek az űrlap különböző verzióiban ne változzanak.The target control is referenced by name, which is why it is important to preserve control names across versions of the form. Ha egy vezérlő nem rendelkezik névvel, az Űrlaptestreszabás-szerkesztő létrehoz hozzá egy nevet, de az így létrehozott név nem lesz azonos az űrlap különböző verzióiban.If a control does not have a name, the Form Customization Editor generates a name, but the generated name is not preserved across different versions of the form.

  • Gondoskodjon arról, hogy a vezérlőnevek azonosak maradjanak az űrlap különböző verzióiban.Ensure that control names remain immutable across different versions of the form. Így az adott vezérlőn egy korábbi verzióban végzett testreszabás az űrlap új verziójában is alkalmazható lesz ugyanarra a vezérlőre.This ensures that customizations for a given control in a previous version can be applied to the same control in a new version of the form.

  • Ha lehetséges, az űrlap frissítésekor kerülje a vezérlők más helyre történő áthelyezését ugyanazon a lapon belül.If possible, avoid moving controls to a different location on the same tab when you upgrade a form. A testreszabás során a felhasználók gyakran helyezik át az űrlap vezérlőit más helyre.A common user customization is moving controls on the form to a different location. Ha az űrlap új verziójában módosítja egy vezérlő helyét, fennáll a kockázata annak, hogy az új helyre került vezérlő átfedésben lesz egy olyan vezérlővel, amelyet a felhasználó helyezett át.If you change the location of a control in a new version of the form, there is a risk that the new control location could overlap with a control that the user has relocated.

  • Ha lehetséges, a meglévő űrlap frissítésének tervezésekor kerülje a vezérlők más lapra történő áthelyezését.If possible, avoid moving controls between tabs when you are designing an update to an existing form. A vezérlők azonosítása a nevük, valamint az őket tartalmazó lap alapján történik.Controls are identified both by name and by the tab on which they are located. Ha az űrlap új verziójában egy vezérlőt másik lapra helyez át, azzal érvénytelenné válhatnak a felhasználó által az adott vezérlőn végzett testreszabások, mert a vezérlőt nem lehet azonosítani.Moving a control from one tab to another in a new version of the form can break customizations that the user makes to that control, because the customizations will fail to identify the target control.

  • Ha az űrlap frissítése új vezérlőket tartalmaz, vegye fontolóra az új vezérlők új lapra való hozzáadását. Ez a legbiztonságosabb módja annak, hogy ne zavarja a felhasználók testreszabását a meglévő lapokon és vezérlőkön.When the update to a form includes new controls, consider adding the new controls to a new tab. That is the safest way to avoid interfering with any user customizations to the existing tabs and controls.

  • Ügyeljen a vezérlők kötésére.Be aware of how controls are bound. -Az írásvédett vezérlők csak egyetlen módon használhatnak - kötéseket.Read-only controls should use only one-way bindings.

Nevezze el az összes testreszabható vezérlőtName all customizable controls

Ügyeljen arra, hogy a vezérlőnevek írják le, milyen adatokhoz van kötve a vezérlő, illetve mi a funkciója.Ensure that the control names describe what data the control is bound to, or describe what the control does.

Űrlap kötése adatforrásokhozBind the form to data sources

Az űrlap fő célja, hogy megjelenítse a Service Manager adatbázis egyetlen objektumát.The main purpose of a form is to visualize a single object from the Service Manager database. Az objektum neve cél példány, amelyet a DataContext ( FrameworkElement osztálytól örökölt űrlap DataContext elemet tulajdonsága mindig meghatároz ) .This object is called a target instance, which is always specified by the DataContext property of a form (which is inherited from the FrameworkElement class).

Fontos

Ne módosítsa az űrlap DataContext elemet tulajdonságát.Do not modify the form's DataContext property. Az űrlap futtatókörnyezete ezt a tulajdonságot használja az űrlap célpéldányának azonosításához.The forms hosting environment uses this property to identify the form target instance.

A Service Manager adatmodellben a célként megadott példányok BindableDataItem objektumként jelennek meg.In the Service Manager data model, a target instance is represented as a BindableDataItem object. Ez az osztály összesíti a mögöttes szoftverfejlesztői készlet ( SDK- ) objektumát, és egy indexelő segítségével teszi elérhetővé a tulajdonságait, amely paraméterként a tulajdonság nevét veszi át.This class aggregates the underlying software development kit (SDK) object, and it exposes its properties through an indexer, which takes a property name as a parameter.

A BindableDataItem osztály a ICustomTypeDescriptor-t is implementálja, ami lehetővé teszi a BindableDataItem osztály használatát a WPF-kötés adatforrásaként.The BindableDataItem class also implements ICustomTypeDescriptor, which makes it possible to use the BindableDataItem class as a data source for WPF binding. A következő példa egy Target instance tulajdonság kötését szemlélteti egy szövegmező vezérlőelem text (szöveg ) tulajdonságához:The following is an example of binding a target instance property to the Text property of a TextBox control:


<TextBox Name="textBoxDescription" Text="{Binding Path=Summary}"/>

Nem szükséges megadnia a kötés forrását , mert a célként megadott példányok az űrlap DataContext elemet vannak beállítva, amely az űrlap összes vezérlője számára alapértelmezett forrásként szolgál.It is not necessary to specify the Source of the binding because the target instances are set as the DataContext of the form, which serves as the default Source for all controls on the form.

Az űrlap elemei a célpéldányon kívül más adatforrásokhoz is köthetők, és az űrlap-infrastruktúra könyvtára számos olyan vezérlőt tartalmaz, amely implicit módon végrehajtja a kötést.Controls on the form can be bound to data sources other than the target instance, and the forms infrastructure library contains a number of controls that perform the binding implicitly. A példányválasztó vezérlő például az adatforráshoz van kötve, amely a választható példányok gyűjteményét biztosítja.For example, the instance picker control is bound to the data source, which provides the collection of instances to choose. További adatforrások is meghatározhatók deklaratív módon a ObjectDataProvider és a XmlDataProvider osztály használatával.It is also possible to define additional data sources declaratively using the ObjectDataProvider and XmlDataProvider classes.

Az űrlap-infrastruktúra a célként megadott példányt csak olvasási / írási adatforrásként tekinti meg az űrlapon.The forms infrastructure considers the target instance as the only read/write data source on the form. Ezért a Submit parancs megvalósítása csak a célként megadott példányon végrehajtott módosításokat fogja tárolni.Therefore, the implementation of the Submit command will only store the changes that are made to the target instance. Az űrlap egyéb adatforrásait a rendszer írásvédettként kezeli.Other data sources for the form are treated as read only.

A Service Manager űrlapalapú infrastruktúra-ellenőrzési szabályok, az érték-átalakítók és a hibák sablonjának használataUse Service Manager forms infrastructure validation Rules, value convertors, and error templates

Az érvénytelen adatbevitel azonosításához javasolt az űrlap-infrastruktúra ellenőrzési szabályait használni.We recommend that you use forms infrastructure validation rules in forms to designate data input that is not valid. A WPF kötési infrastruktúra támogatja az adatforráshoz kötött vezérlési tulajdonságok érvényesítését egy - vagy két - módon kötésekkel.The WPF binding infrastructure supports validation for control properties that are bound to a data source with either one-way or two-way bindings. A kötési objektumnak van egy ValidationRules -gyűjteménye, amely tetszőleges számú ValidationRule objektumot tartalmazhat.The binding object has a ValidationRules collection that can contain any number of ValidationRule objects. Amikor az adatok a vezérlőből az adatforrásba kerülnek, a ValidationRule -objektumok meghívásával ellenőrzik az értéket.Whenever data is pushed from the control to the data source, the ValidationRule objects are called to validate the value.

Az űrlap-infrastruktúra kódtára számos ellenőrzési szabályt tartalmaz, amelyek a leggyakrabban előforduló eseteket kezelik.The forms infrastructure library contains a number of validation rules that handle the most common cases. Az űrlap-infrastruktúra az ellenőrzési szabályok használatával határozza meg, hogy az űrlap tartalma benyújtható-e tárolásra.The forms infrastructure takes advantage of the validation rules to determine whether the form contents can be submitted for storing. Előfordulhat például, hogy egy űrlap Küldés gombja le van tiltva, ha van egy olyan vezérlő, amely érvényesítési hibát tartalmaz az űrlapon.For example, a form's Submit button can be disabled if there is a control that has a validation error on the form.

Javasoljuk, hogy használja az űrlap-infrastruktúra kódtárához tartozó egyéni hibasablont.We recommend that you use the custom error template that is provided with the forms infrastructure library. Ha egy vezérlő ellenőrzési hibát tartalmaz, alapértelmezés szerint piros szegéllyel jelenik meg.If a control has a validation error, it appears by default with a red border around it. A WPF lehetővé teszi, hogy egyéni hibaüzenetet határozzon meg az Validation. ErrorTemplate tulajdonságon keresztül, amely bármilyen vezérlőelemre beállítható.The WPF makes it possible to define a custom error indicator through the Validation.ErrorTemplate property, which can be set on any control. A Service Manager Forms Infrastructure Library tartalmaz egy egyéni hibát tartalmazó sablont, amely a WPF vörös szegély helyett egy hibaüzenetet jelenít meg.The Service Manager forms infrastructure library contains a custom error template, which displays an error icon instead of the WPF red border. Emellett ha az egérrel a hibaikonra mutatnak, elemleírás jelenik meg a hibaüzenettel.In addition, when a mouse points to the error icon, a tooltip pops up with an error message. A hibaüzenetnek meg kell határoznia, miért nem felelt meg a vezérlőben megadott adat az ellenőrzésnek.The error message should indicate the reason why the data in the control failed validation.

A következő példa azt mutatja be, hogyan hivatkozható a hibasablon az XAML-ben:The following example shows how to reference the error template in XAML:


<TextBox Text="{Binding SomeProperty}"
         scwpf:Validation.ValueRequired="True"
         Validation.ErrorTemplate="{DynamicResource {ComponentResourceKey {x:Type scwpf:Validation}, InvalidDataErrorTemplate}}"/>

Ha - a beépített érvényesítési szabályok nem tartalmazzák a szükséges érvényesítési logikát, javasoljuk, hogy egyéni ellenőrzési szabályokat hozzon létre a logikának megfelelően.If built-in validation rules do not provide the required validation logic, we recommend that you build custom validation rules to represent that logic. Ez lehetővé teszi a normál és egyéni ellenőrzési logika párhuzamos működését a közös ellenőrzési mechanizmusban.This will make it possible for standard and custom validation logic to coexist within the common validation handling mechanism.

Ha az érvényesítési szabályok mechanizmusa nem megfelelő egy adott forgatókönyvhöz, inkább a FormEvents. PreviewSubmitEvent kell kezelnie, és onnan kell futtatnia az érvényesítést.If the validation rules mechanism is not adequate for a particular scenario, you should instead handle FormEvents.PreviewSubmitEvent and run the validation from there.

A következő példakód az egyéni ellenőrzés futtatását mutatja be:The following code example provides an example of the pattern that you can use to run custom validation:


void MyForm_Loaded(object sender, RoutedEventArgs e)
{
    // hook to handle form events
    this.AddHandler(
        FormEvents.PreviewSubmitEvent,
        new EventHandler<PreviewFormCommandEventArgs>(this.OnPreviewSubmit));
}
private void OnPreviewSubmit(object sender, PreviewFormCommandEventArgs e)
{
    string errorMessage;
    bool result = this.DoVerify(out errorMessage);
    if (!result)
    {
        // cancel Submit operation
        e.Cancel = true;
        // display error message
        MessageBox.Show(errorMessage);
    }
}
internal bool DoVerify(out string errorMessage)
{
    // Do custom verification and return true to indicate that
    // validation check has passed; otherwise return false and
    // populate errorMessage argument
}

Az űrlap-infrastruktúra parancsainak és eseményeinek használataUse form infrastructure commands and events

Az űrlap-infrastruktúra számos, az űrlapon futtatható parancsot tesz elérhetővé.The form infrastructure exposes a number of commands that can be run on a form. Ezek a parancsok a következők:These commands include:

  • FormsCommand. Submit, amely menti az űrlap céljának példányát.FormsCommand.Submit, which saves the target instance of the form.

  • FormsCommand. SubmitAndClose, amely menti az űrlap céljának példányát, és bezárja az űrlapot.FormsCommand.SubmitAndClose, which saves the target instance of the form and closes the form.

  • FormsCommand. refresh (frissítés), amely megismétli az űrlap céljának lekérdezését.FormsCommand.Refresh, which repeats the query for the target instance of the form.

  • FormCommands. cancel, amely elveti az összes módosítást, és bezárja az űrlapot.FormCommands.Cancel, which discards all changes and closes the form.

A parancsok mindegyike eseményekbe van ágyazva, amelyek a parancs futása előtt és után aktiválódnak.Each of these commands is bracketed by events, which are raised before and after the command runs.

A parancs előtt a következő események aktiválódnak:Before the command, the following events are raised:

  • A FormEvents. PreviewSubmit esemény a FormCommand. Submit parancs előtt következik be, a FormEvents. Submiting esemény pedig az FormCommand. Submit parancs után következik be.The FormEvents.PreviewSubmit event is raised before the FormCommand.Submit command, and the FormEvents.Submitted event is raised after the FormCommand.Submit command.

  • A FormEvents. PreviewRefresh esemény a FormCommands. refresh parancs előtt következik be, a FormCommand. refreshing parancs pedig az FormCommand. Submit parancs után következik be.The FormEvents.PreviewRefresh event is raised before the FormCommands.Refresh command, and the FormCommand.Refreshed command is raised after the FormCommand.Submit command.

  • A FormEvents. PreviewCancel esemény a FormCommands. cancel parancs előtt következik be, a FormCommand. canceled esemény pedig az FormCommand. cancel parancs után következik be.The FormEvents.PreviewCancel event is raised before the FormCommands.Cancel command, and the FormCommand.Canceled event is raised after the FormCommand.Cancel command.

Az előnézeti események egy PreviewFormCommandEventArgs objektumon haladnak át.The preview events pass along a PreviewFormCommandEventArgs object. Ez az objektum egy változtatható megszakítási tulajdonságot tartalmaz, amely megakadályozza, hogy a megfelelő parancs fusson, ha a tulajdonság értéke true (igaz).This object contains a mutable Cancel property that will prevent the corresponding command from running when the property is set to true.

A - parancs utáni események egy FormCommandExecutedEventArgs objektumot adnak át.The post-command events pass a FormCommandExecutedEventArgs object. Ez az objektum egy Result tulajdonságot tartalmaz, amely azt jelzi, hogy a parancs futtatása sikerült-e, megszakították vagy hibát okozott.This object contains a Result property that indicates whether the running of the command succeeded, was canceled, or caused an error. Hiba esetén a FormCommandExecutedEventArgs objektum Error tulajdonsága arra a kivételre hivatkozik, amely a hibával kapcsolatos információkat tartalmaz.In case of an error, the Error property of the FormCommandExecutedEventArgs object references the exception that provides information about the error.

Az űrlapparancsok programozott és deklaratív módon is engedélyezhetők, letilthatók és futtathatók.It is possible to enable, disable, and run form commands both programmatically and declaratively.

Ha programozott módon szeretné engedélyezni az űrlap-parancsokat, hozzon létre egy CommandBinding az űrlap és a kapcsolódó parancs között.To enable form commands programmatically, establish a CommandBinding between the form and the related command.

A következő példában egy parancs kötése jön az űrlap és a frissítési parancs között, és két kezelő van definiálva ehhez a parancshoz.In the following example, a command binding is established between the form and a Refresh command, and two handlers are defined for this command. Az első kezelő visszaadja, hogy a frissítési parancs futtatható-e, és a második kezelő ténylegesen tartalmazza-e a refresh parancs megvalósítását:The first handler returns whether or not the Refresh command can run, and the second handler actually contains the implementation of the Refresh command:


    public class MyForm : UserControl
    {
        public MyForm()
        {
            // do standard initialization
            // establish CommandBinding for Refresh command
            this.CommandBindings.Add(
                new CommandBinding(FormCommands.Refresh, this.ExecuteRefresh, this.CanExecuteRefresh));
        }
        private void CanExecuteRefresh(
              object sender,
              CanExecuteRoutedEventArgs e)
        {
            // put your logic that determines whether Refresh
// can be executed here
            bool canExecute = true;
            BindableDataItem dataItem = this.DataContext as BindableDataItem;
            if (dataItem)
            {
                canExecute = dataItem["Status"] != "New";
            }
            e.CanExecute = canExecute;
        }
        private void ExecuteRefresh(
            object sender,
            ExecutedRoutedEventArgs e)
        {
            // here is placeholder for the code that has do be
// executed upon running Refresh command
        }
    }

Az űrlapparancsok kezelőit deklaratív módon is definiálhatja.You can also define handlers for form commands declaratively. Ezt egy RoutedCommandTriggerhasználó szabály -objektum alkalmazásával teheti meg.You can do this by employing a Rule object that uses a RoutedCommandTrigger. A következő példakód a kezelők deklaratív definiálását mutatja be:The following code example shows how to define handlers declaratively:


    <scwpf:BusinessLogic.Rules>
        <scwpf:RuleCollection>
            <scwpf:Rule>
                <scwpf:Rule.Triggers>
                    <scwpf:RoutedCommandTrigger
RoutedCommand="{x:Static scwpf:FormCommands.Refresh}"/>
                </scwpf:Rule.Triggers>
                <scwpf:Rule.Conditions>
                    <scwpf:PropertyMatchCondition
                        Binding="{Binding Status}"
                        Value="New"
                        Operation="NotEquals" />
                </scwpf:Rule.Conditions>
                <!-- Use RuleAction objects to define the logic that executed
                upon running Refresh command; this can be left empty -->
            </scwpf:Rule>
        </scwpf:RuleCollection>
    </scwpf:BusinessLogic.Rules>

További lépésekNext steps