CN101310271B - Interface for productivity suite applications and the host's user interface - Google Patents
Interface for productivity suite applications and the host's user interfaceDownload PDFInfo
- Publication number
- CN101310271B CN101310271BCN2006800427227ACN200680042722ACN101310271BCN 101310271 BCN101310271 BCN 101310271BCN 2006800427227 ACN2006800427227 ACN 2006800427227ACN 200680042722 ACN200680042722 ACN 200680042722ACN 101310271 BCN101310271 BCN 101310271B
- Authority
- CN
- China
- Prior art keywords
- control
- string
- metadata
- item
- data
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Fee Related
Links
Images
Landscapes
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
Description
Translated fromChinese发明背景Background of the invention
有多种生产性套件可供用户使用，包括用于对事件进行日程安排、储存联系人信息、支持电子邮件、储存任务信息等的应用程序。一个示例是可从华盛顿州雷蒙德市的微软公司获得的Microsoft OutlookMicrosoft Outlook
某些生产性套件的用户还使用为特定的商业用途开发的商业软件应用程序或系统(此处也称为业务线(Line of Business)，或LOB系统)。一个示例是可从多个公司获得的客户关系管理(CRM)系统。由LOB系统管理的许多信息可包括联系人管理、事件和任务的日程安排等等。Users of some productivity suites also use commercial software applications or systems (also referred to herein as Line of Business, or LOB systems) developed for specific business purposes. One example is customer relationship management (CRM) systems available from a number of companies. Much of the information managed by the LOB system can include contact management, scheduling of events and tasks, and the like.
在许多情况下，生产性套件不能以自动的方式与LOB系统交换或同步信息。例如，如果用户在用户的生产性套件中添加一业务任务，则该任务信息将不会自动被迁移到LOB系统。相反，该信息由用户在每一不同的系统中发现。通常，用户必须在LOB系统中再次输入该任务信息。某些用户可能希望允许将LOB信息储存在电子邮件系统中并与后端系统中的LOB信息同步。In many cases, the productivity suite cannot exchange or synchronize information with the LOB system in an automated fashion. For example, if a user adds a business task in the user's productivity suite, the task information will not be automatically migrated to the LOB system. Instead, the information is found by the user in each of the different systems. Typically, the user must re-enter this task information in the LOB system. Some users may wish to allow LOB information to be stored in the email system and synchronized with the LOB information in the backend system.
发明概述Summary of the invention
提供以下的概述以便用简化的形式介绍一些概念，并且本概述并不旨在确定所要求保护的主题的关键特征或必要特征。本概述也不旨在用于帮助确定所要求保护的主题的范围。The following summary is provided to introduce some concepts in a simplified form, and it is not intended to identify key features or essential features of the claimed subject matter. Nor is this summary intended to be used as an aid in determining the scope of the claimed subject matter.
根据所公开的实施例的各方面，一种系统和方法被安排成允许用动态生成的用户界面来访问一生产性套件应用程序的各项目。该用户界面由一呈现引擎处理，使得它可被主宿在该生产性套件应用程序的窗口或任务窗格中。用于该生产性套件各项目的数据可由被绑定到该UI的一数据源来提供，使得该UI的特性字段用该生产性套件各项目的改变来更新。来自该UI的特性数据也可被绑定到该数据源，使得该特性数据的改变传播到该数据源来更新该生产性套件各项目。该生产性套件应用程序可以是诸如Outlook
在另一实施例中，对由该生产性套件应用程序主宿的UI中的特性的改变可传播到一同步数据存储(SDS)。与该SDS相关联的生产性套件项目可与一业务线应用程序同步，使得该生产性套件应用程序中的数据项目与该LOB应用程序中的实体之间的改变通过使用XML数据表示和所储存的绑定信息来同步。In another embodiment, changes to properties in the UI hosted by the productivity suite application can be propagated to a Synchronous Data Store (SDS). Productivity suite items associated with the SDS can be synchronized with a line-of-business application such that changes between data items in the productivity suite application and entities in the LOB application are represented using XML data and stored The binding information to synchronize.
在一个具体实现中，用于同步的信息以XML数据表示来储存。该XML数据表示可作为关于该生产性套件应用程序中的数据项目的特性来储存。该XML数据表示可被传送到该LOB应用程序，后者然后可处理其自己的用于LOB实体的冲突解决和数据存储。对该LOB应用程序中的实体的改变然后可作为XML来提供，该XML随后可被格式化成被传送到该生产性套件应用程序的控制消息。该XML数据表示提供了简单地由每一相应应用程序管理的统一界面。In a specific implementation, the information used for synchronization is stored in XML data representation. The XML data representation can be stored as a property about a data item in the productivity suite application. The XML data representation can be passed to the LOB application, which can then handle its own conflict resolution and data storage for the LOB entities. Changes to entities in the LOB application can then be provided as XML, which can then be formatted into control messages that are passed to the productivity suite application. This XML data representation provides a uniform interface that is easily managed by each respective application.
在另一具体实现中，以XML数据表示储存的信息可作为生产性套件项目(例如，Microsoft Outlook
在另一方面，在每一用户的基础上执行信息加密。这一方面可有利地帮助确保包含在被发送到电子邮件收件人的任何PIM项目中的信息不能被该收件人阅读，并且因此不能被由于疏忽而共享。在一相关方面，加密帮助防止信息导致收件人一方的非预期行为。例如，在某些常规系统中，包含在约会中的信息可在发送关于该约会的邀请时被容易地共享。由此，用户可甚至在不知道的情况下共享信息。信息加密防止这一疏忽的信息共享的发生。然而，在用户具有多个设备的情况下，所描述的加密不会防止信息跨用户的多个设备而被共享。In another aspect, information encryption is performed on a per user basis. This aspect can advantageously help ensure that information contained in any PIM item sent to an email recipient cannot be read by that recipient, and therefore cannot be inadvertently shared. In a related aspect, encryption helps prevent information from causing unintended behavior on the part of the recipient. For example, in some conventional systems, information contained in an appointment can be easily shared when an invitation for the appointment is sent. Thus, users can share information without even knowing it. Information encryption prevents this inadvertent information sharing from occurring. However, where the user has multiple devices, the described encryption does not prevent information from being shared across the user's multiple devices.
在另一方面，信息被储存在个人特性中，从而减小了盖写的机会。在某些常规系统中，信息可在请求者不知道的情况下与约会请求中的被邀请者隐式地交换。当请求者和被邀请者通过其中的任一个显式或隐式地发送信息来共享信息时，存在信息将被储存在同一特性中的可能性。由于最后储存的信息将被保留，因此来自用户之一的信息可能会被盖写。在本发明的一方面，分配一特定的特性名来储存附加信息，使得冲突可被避免。On the other hand, information is stored in personal characteristics, thereby reducing the chance of overwriting. In some conventional systems, information may be exchanged implicitly with invitees in an appointment request without the requester's knowledge. When the requester and invitee share information by either sending it explicitly or implicitly, there is a possibility that the information will be stored in the same property. Information from one of the users may be overwritten since the last stored information will be retained. In one aspect of the invention, a specific property name is assigned to store additional information so that conflicts can be avoided.
在另一方面，信息可被升级和降级，使得该信息的元素或属性(即，采用XML)可被复制到包含的PIM项目中的特性。例如，在一个实现中，可使用标准Microsoft Outlook
在另一方面，在生产性套件和LOB应用程序之间手动地同步对话框。对话框可用诸如可扩展应用标记语言(XAML)等任何适当的语言来开发。对话框之间的同步可有利地允许显示完全相同的项目的多个对话框被同时打开。当用户在一个对话框中输入信息时，该信息可在显示它的所有其它地方自动改变。例如，在Microsoft Outlook
在又一方面，客户机机器上的生产性套件应用程序被配置成经由web服务器调用发送请求来更新、删除或创建LOB应用程序中的新实体。LOB应用程序从客户机机器中提取该请求，其中该请求可用XML数据表示来提供。服务器机器经由嵌入在电子邮件中的控制消息来发送请求，以更新、删除或创建生产性套件应用程序中的项目，其中该项目与一LOB实体相关联。该控制消息向用户隐藏，并且由客户机机器提取以供评估、冲突解决、特性升级以及LOB实体和生产性套件应用程序项目之间的绑定。In yet another aspect, the productivity suite application on the client machine is configured to send requests via web server calls to update, delete or create new entities in the LOB application. The LOB application fetches the request from the client machine, where the request can be provided in an XML data representation. The server machine sends a request via a control message embedded in an email to update, delete or create an item in the productivity suite application, where the item is associated with a LOB entity. This control message is hidden from the user and extracted by the client machine for evaluation, conflict resolution, feature upgrades, and binding between LOB entities and Productivity Suite application items.
在再一方面，LOB应用程序可在电子邮件通信中传送LOB标识符，其中该LOB标识符与生产性套件项目和LOB实体之间的先前的绑定相关联。该LOB标识符可被嵌入在电子邮件通信中与电子邮件消息相关联的首部中。该电子邮件通信不需要包含(嵌入或以其它方式)LOB实体本身，因为LOB标识符引用该LOB实体。一旦接收到该电子邮件消息，用于该生产性套件的电子邮件处理程序可标识同步阴影(shadow)或同步数据存储中由该LOB标识符所引用的特定的生产性套件项目。在一个示例中，用户可通过选择该电子邮件消息中与该LOB标识符相关联的链接(例如，任意数量的形式的URL链接，诸如HTTP、HTTPS、FTP、FTPS、OBA等)以及其它嵌入的信息(例如，XML数据表示或其它数据表示)来访问该生产性套件项目。在另一示例中，可激活一动作窗格或任务窗格来访问该特定的生产性套件项目。由于LOB标识符可被嵌入在链接中，因此与该生产性套件项目相关联的任何期望的动作可通过适当地配置该处理程序(例如，URL处理程序)来采取。In yet another aspect, the LOB application can communicate the LOB identifier in the email communication, where the LOB identifier is associated with a previous binding between the productivity suite item and the LOB entity. The LOB identifier can be embedded in a header associated with the email message in the email communication. The email communication need not contain (embed or otherwise) the LOB entity itself, since the LOB identifier references the LOB entity. Upon receipt of the email message, the email handler for the productivity suite may identify the particular productivity suite item referenced by the LOB identifier in the sync shadow or sync data store. In one example, the user can select the link associated with the LOB identifier in the email message (for example, any number of forms of URL links, such as HTTP, HTTPS, FTP, FTPS, OBA, etc.) and other embedded information (eg, XML data representation or other data representation) to access the productivity suite item. In another example, an action pane or task pane can be activated to access that particular productivity suite item. Since the LOB identifier can be embedded in the link, any desired action associated with the productivity suite item can be taken by configuring the handler (eg, URL handler) appropriately.
在另一方面，用户界面(UI)表单可以经由所描述的绑定关联而与该生产性套件项目或项目特性相关联。在一个特定方面，该生产性套件应用程序可通过利用结构化元数据来动态地呈现一UI表单。该结构化元数据允许开发者容易地定制UI表单，并且在某些情形中，动态元数据驱动的UI表单无需使用绑定特征(例如，UI表单无需与生产性套件项目的特性相关联)。In another aspect, a user interface (UI) form can be associated with the productivity suite item or item property via the described binding association. In a particular aspect, the productivity suite application can dynamically render a UI form by utilizing structured metadata. This structured metadata allows developers to easily customize UI forms, and in some cases, dynamic metadata-driven UI forms need not use binding features (eg, UI forms need not be associated with properties of productivity suite items).
在还有一方面，开发者可通过对许多不同的应用程序重复使用先前创建的元数据定义来创建合成应用程序。即，该方面允许用户基于多个厂商的应用程序定义来创建合成应用程序。In yet another aspect, developers can create composite applications by reusing previously created metadata definitions for many different applications. That is, this aspect allows users to create composite applications based on application definitions from multiple vendors.
各实施例可被实现为计算机进程、计算机系统(包括移动计算设备和手持式计算设备)或诸如计算机程序产品等制品。该计算机程序产品可以是可由计算机系统读取并包括了用于执行一计算机进程的计算机可执行指令的计算机可读介质。该计算机程序产品也可以是可由计算系统读取并编码了用于执行一计算机进程的指令的计算机程序的载波上的传播信号。Embodiments may be implemented as a computer process, a computer system (including mobile computing devices and handheld computing devices), or an article of manufacture such as a computer program product. The computer program product may be a computer-readable medium readable by a computer system and comprising computer-executable instructions for executing a computer process. The computer program product may also be a propagated signal on a carrier readable by a computing system and encoding a computer program of instructions for executing a computer process.
附图简述Brief description of the drawings
参考以下附图描述了非限制和非穷尽的实施例，在全部附图中，相同的参考标号表示相同的部分，除非另外指明。Non-limiting and non-exhaustive embodiments are described with reference to the following drawings, wherein like reference numerals refer to like parts throughout unless otherwise indicated.
图1是表示根据一个实施例可用于实现此处所描述的技术的示例通用计算机环境的框图。Figure 1 is a block diagram representing an example general-purpose computer environment that may be used to implement the techniques described herein, according to one embodiment.
图2示出了其中客户机设备被安排成与LOB系统同步的示例系统。Figure 2 illustrates an example system in which client devices are arranged to synchronize with a LOB system.
图3示出了当由LOB系统创建一新绑定项目时如何设置绑定项目和LOB实体之间的相关。Fig. 3 shows how to set up the association between the binding item and the LOB entity when a new binding item is created by the LOB system.
图4示出了当在生产性套件中创建一新绑定项目时如何设置绑定项目和LOB实体之间的相关。Figure 4 shows how to set up the relationship between the binding item and the LOB entity when creating a new binding item in the productivity suite.
图5示出了当在生产性套件中更新或删除一绑定项目时如何改变绑定项目和LOB实体之间的相关。Figure 5 shows how the relationship between a binding item and a LOB entity is changed when a binding item is updated or deleted in a productivity suite.
图6示出了当由LOB系统更新或删除一绑定项目时如何改变绑定项目和LOB实体之间的相关。Figure 6 shows how the association between a binding item and a LOB entity is changed when a binding item is updated or deleted by the LOB system.
图7示出了在推操作期间在客户机和服务器之间的示例通信流程。Figure 7 shows an example communication flow between a client and a server during a push operation.
图8和9示出了可在另一示例系统中使用的拉操作。8 and 9 illustrate pull operations that may be used in another example system.
图10示出了用于在客户机机器上使用的生产性套件的同步子系统的示例设计。Figure 10 shows an example design of a synchronization subsystem for a productivity suite used on a client machine.
图11示出了客户机和服务器之间的另一示例通信流程。Fig. 11 shows another example communication flow between a client and a server.
图12示出了一示例同步子系统。Figure 12 shows an example synchronization subsystem.
图13是用于一示例同步方法的流程图。13 is a flowchart for an example synchronization method.
图14A-14D示出了从元数据生成的示例UI表单。14A-14D illustrate example UI forms generated from metadata.
图15-16示出了用于可在元数据中定义的控件的各种控件类型和类。Figures 15-16 illustrate the various control types and classes for controls that can be defined in metadata.
图17是用于一示例呈现引擎的流程图。Figure 17 is a flow diagram for an example rendering engine.
图18示出了可用于指定对一控制特性的数据绑定的各种特性。Figure 18 shows various properties that can be used to specify data binding to a control property.
附录I示出了用于生产性套件应用程序(例如，Microsoft Outlook
附录II示出了用于与生产性套件应用程序(例如，Microsoft Outlook)中的项目接口的示例模式。Appendix II shows the Example schema for the project interface in ).
附录III示出了用于与生产性套件应用程序(例如，Microsoft Outlook
附录IV示出了利用用于在生产性套件应用程序(例如，MicrosoftOutlook
详细描述A detailed description
以下参考附图更完整地描述了各实施例，附图形成各实施例的一部分，并示出了用于实施各实施例的具体示例实施例。然而，其它实施例可以用许多不同形式来实现，并且不应被解释为限于此处所述的实施例；相反，提供这些实施例以使本公开内容全面且完整。各实施例可被实施为方法、系统或设备。因此，各实施例可以采用硬件实现、完全软件实现或组合了软件和硬件方面的实现的形式。因此，以下详细描述不在限制的意义上考虑。Embodiments are described more fully below with reference to the accompanying drawings, which form a part hereof, and show specific example embodiments for implementing the embodiments. However, other embodiments may be embodied in many different forms and should not be construed as limited to the embodiments set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete. Various embodiments may be implemented as methods, systems or devices. Accordingly, various embodiments may take the form of a hardware implementation, an entirely software implementation or an implementation combining software and hardware aspects. Accordingly, the following detailed description is not to be considered in a limiting sense.
简言之，用户界面可由用于生产性套件应用程序的元数据以包围窗口、任务窗格或某一其它适当的表示来定义。数据可按单向格式绑定到数据源，使得来自数据源的改变传播到UI表单中的特性域。数据也可以按双向格式绑定到数据源，使得来自UI的特性域的改变被传播回数据源。数据源可以是诸如用于生产性套件应用程序和业务线(LOB)应用程序(例如，CRM应用程序)之间的同步的本地高速缓存。一呈现引擎被安排成处理该UI和数据绑定，使得自定义事件处理程序以隐藏代码(code behind)程序集格式来定义。生产性套件项目可通过一系列项目接口从该隐藏代码程序集来访问。In short, a user interface may be defined by metadata for a productivity suite application in an enclosing window, task pane, or some other suitable representation. Data can be bound to a data source in a one-way format such that changes from the data source are propagated to property fields in the UI form. Data can also be bound to a data source in a bidirectional format, so that changes to property fields from the UI are propagated back to the data source. The data source may be such as a local cache for synchronization between productivity suite applications and line-of-business (LOB) applications (eg, CRM applications). A rendering engine is arranged to handle the UI and data binding such that custom event handlers are defined in code behind assembly format. Productivity suite projects are accessible from this code-behind assembly through a series of project interfaces.
各实施例的逻辑操作被实现为(1)在计算系统上运行的计算机实现的步骤的序列，和/或(2)计算系统内的互连机器模块。实现是取决于实现该实施例的计算系统的性能要求的选择问题。因此，构成此处所描述的实施例的逻辑操作被替换地称为操作、步骤或模块。The logical operations of the various embodiments are implemented (1) as a sequence of computer-implemented steps running on a computing system, and/or (2) as interconnected machine modules within a computing system. Implementation is a matter of choice depending on the performance requirements of the computing system implementing the embodiments. Accordingly, the logical operations making up the embodiments described herein are referred to alternatively as operations, steps or modules.
各种模块、技术和方法此处可以在诸如程序模块等由一个或多个计算机或其它设备执行的计算机可执行指令的一般上下文中描述。一般而言，程序模块包括用于执行特定任务或实现特定抽象数据类型的例程、程序、对象、组件、数据结构等。通常，程序模块的功能可在各实施例中按需组合或分布。Various modules, techniques and methods may be described herein in the general context of computer-executable instructions, such as program modules, being executed by one or more computers or other devices. Generally, program modules include routines, programs, objects, components, data structures, etc. for performing particular tasks or implementing particular abstract data types. Generally, the functions of the program modules may be combined or distributed as desired in various embodiments.
这些模块和技术的一个实现可被储存在某一形式的计算机可读介质上或可通过其传送。计算机可读介质可以是可由计算机访问的任何可用的介质。作为示例而非局限，计算机可读介质可包括“计算机存储介质”和“通信介质”。An implementation of these modules and techniques may be stored on or transmitted across some form of computer readable media. Computer readable media can be any available media that can be accessed by a computer. By way of example, and not limitation, computer readable media may include "computer storage media" and "communication media."
“计算机存储介质”包括以用于储存诸如计算机可读指令、数据结构、程序模块或其它数据等信息的任一方法或技术实现的易失性和非易失性，可移动和不可移动介质。计算机存储介质包括但不限于，RAM、ROM、EEPROM、闪存或其它存储器技术、CD-ROM、数字多功能盘(DVD)或其它光盘存储、磁盒、磁带、磁盘存储或其它磁存储设备、或可以用来储存所期望的信息并可由计算机访问的任一其它介质。"Computer storage media" includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media including, but not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical disk storage, magnetic cartridges, magnetic tape, magnetic disk storage or other magnetic storage devices, or Any other medium that can be used to store desired information and that can be accessed by a computer.
“通信介质”通常以诸如载波或其它传输机制等已调制数据信号来体现计算机可读指令、数据结构、程序模块或其它数据，通信介质也包括任一信息传送介质。术语“已调制数据信号”指以对信号中的信息进行编码的方式设置或改变其一个或多个特征的信号。作为示例而非局限，通信介质包括有线介质，如有线网络或直接连线连接，以及无线介质，如声学、RF、红外和其它无线介质。上述任一的组合也应当包括在计算机可读介质的范围之内。"Communication media" typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of the any of the above should also be included within the scope of computer-readable media.
贯穿本说明书对“一个实施例”、“一实施例”或“一示例实施例”的表述意味着所描述的具体特征、结构或特性被包括在至少一个实施例中。由此，对这些短语的使用可以表示多于仅仅一个实施例。此外，所描述的特征、结构或特性在一个或多个实施例中可以用任何适当的方式来组合。Reference throughout this specification to "one embodiment," "an embodiment," or "an example embodiment" means that the particular feature, structure, or characteristic being described is included in at least one embodiment. Thus, use of these phrases may mean more than just one embodiment. Furthermore, the described features, structures, or characteristics may be combined in any suitable manner in one or more embodiments.
然而，本领域的技术人员可以认识到，各实施例可以在没有这些具体细节中的一个或多个的情况下，或者用其它方法、资源、材料等来实施。在其它情况下，未详细示出或描述公知的结构、资源或操作仅仅是为了避免使各实施例的各方面变得晦涩。One skilled in the art will recognize, however, that the various embodiments may be practiced without one or more of these specific details, or with other methods, sources, materials, and the like. In other instances, well-known structures, resources, or operations have not been shown or described in detail merely to avoid obscuring aspects of the various embodiments.
示例计算环境Example Computing Environment
图1示出了通用计算环境100，它可用于实现此处所描述的技术。计算机环境100仅为计算环境的一个示例，并非对计算机和网络体系结构的使用范围或功能提出任何局限。也不应将计算机环境100解释为对示例计算机环境100中示出的任一组件或其组合具有任何依赖或需求。FIG. 1 illustrates a
计算机环境100包括计算机102形式的通用计算设备。计算机102的组件可包括但不限于，一个或多个处理器或处理单元104、系统存储器106以及将包括处理器104的各类系统组件耦合至系统存储器106的系统总线108。
系统总线108表示若干种总线结构类型的一种或多种，包括存储器总线或存储器控制器、外围总线、加速图形端口、以及使用各类总线体系结构的处理器或局部总线。作为示例，这类体系结构可包括工业标准体系结构(ISA)总线、微通道体系结构(MCA)总线、增强型ISA(EISA)总线、视频电子技术标准协会(VESA)局部总线、外围部件互连(PCI)总线(也称为小背板(Mezzanine)总线)、PCI Express总线、通用串行总线(USB)、安全数字(SD)总线或IEEE 1394(即火线)总线。
计算机102可包括各种计算机可读介质。这类计算机可读介质可以是可由计算机102访问的任一可用介质，包括易失性和非易失性介质、可移动和不可移动介质。
系统存储器106包括诸如随机存取存储器(RAM)110等易失性存储器，和/或诸如只读存储器(ROM)112或闪存RAM等非易失性存储器形式的计算机可读介质。基本输入/输出系统(BIOS)114包括如在启动时帮助在计算机102内的元件之间传输信息的基本例程，它被储存在ROM 112或闪存RAM中。RAM 110通常包含处理单元104立即可访问和/或当前正在操作的数据和/或程序模块。
计算机102也可包括其它可移动/不可移动、易失性/非易失性计算机存储介质。作为示例，图1示出了对不可移动、非易失性磁介质(未示出)进行读写的硬盘驱动器116，对可移动、非易失性磁盘120(如，“软盘”)进行读写的磁盘驱动器118，以及对可移动、非易失性光盘124，如CD-ROM、DVD-ROM或其它光介质进行读写的光盘驱动器122。硬盘驱动器116、磁盘驱动器118和光盘驱动器122的每一个通过一个或多个数据介质接口125连接到系统总线108。或者，硬盘驱动器116、磁盘驱动器118和光盘驱动器122可通过一个或多个接口(未示出)连接到系统总线108。
盘驱动器及其相关联的计算机可读介质为计算机102提供了计算机可读指令、数据结构、程序模块和其它数据的非易失性存储。尽管该示例示出了硬盘116、可移动磁盘120和可移动光盘124，然而可以理解，可储存可由计算机访问的数据的其它类型的计算机可读介质，如磁带盒或其它磁存储设备、闪存卡、CD-ROM、数字多功能盘(DVD)或其它光存储、随机存取存储器(RAM)、只读存储器(ROM)、电可擦除可编程只读存储器(EEPROM)等，也可用于实现示例性计算系统和环境。Disk drives and their associated computer-readable media provide nonvolatile storage of computer-readable instructions, data structures, program modules and other data for the
多个程序模块可储存在硬盘116、磁盘120、光盘124、ROM 112和/或RAM 110中，作为示例，包括操作系统126、一个或多个应用程序128、其它程序模块130以及程序数据132。这些操作系统126、一个或多个应用程序128、其它程序模块130和程序数据132(或其某一组合)中的每一个可实现支持分布式文件系统的所有或部分常驻组件。A number of program modules may be stored on
用户可以通过诸如键盘134和定点设备136(如，“鼠标”)等输入设备向计算机102输入命令和信息。其它输入设备138(未具体示出)可包括话筒、操纵杆、游戏手柄、圆盘式卫星天线、扫描仪和/或其类似物。这些和其它输入设备通常通过耦合至系统总线108的输入/输出接口140连接到处理单元104，但也可以通过其它接口和总线结构连接，如并行端口、游戏端口或通用串行总线(USB)。A user may enter commands and information into the
监视器142或其它类型的显示设备也通过接口，如视频适配器144连接到系统总线108。除监视器142之外，其它输出外围设备可包括诸如扬声器(未示出)和打印机146等组件，它们可通过I/O接口140连接到计算机102。A
计算机102可以使用到一个或多个远程计算机，如远程计算设备148的逻辑连接在网络化环境中操作。作为示例，远程计算设备148可以是PC、便携式计算机、服务器、路由器、网络计算机、对等设备或其它常见的网络节点等等。远程计算设备148被示为可包括此处相对于计算机102所描述的许多或所有元件和特征的便携式计算机。或者，计算机102也可在非联网的环境中操作。
计算机102和远程计算机148之间的逻辑连接被描述为局域网(LAN)150和通用广域网(WAN)152。这类网络环境常见于办公室、企业范围计算机网络、内联网以及因特网。The logical connections between
当在LAN网络环境中实现时，计算机102通过网络接口或适配器154连接至局域网150。当在WAN网络环境中使用时，计算机102通常包括调制解调器156或用于通过广域网152建立通信的其它装置。调制解调器156可以对计算机102是内置或外置的，它通过I/O接口140或其它适当的机制连接至系统总线108。可以理解，示出的网络连接是示例性的，也可以使用在计算机102和148建立至少一个通信链路的其它手段。When implemented in a LAN networking environment,
在诸如用计算环境100示出的网络化环境中，相对于计算机102描述的程序模块或其部分可储存在远程存储器存储设备中。作为示例，远程应用程序158驻留在远程计算机148的存储器设备中。出于说明的目的，应用程序和诸如操作系统等其它可执行程序组件在此处被示出为离散的框，尽管可以认识到，这些程序和组件在不同的时刻驻留在计算设备102的不同存储组件中，并由计算机的至少一个数据处理器执行。In a networked environment such as that illustrated with
以下是在MIcrosoft Outlook
示例配置sample configuration
图2示出了其中客户机设备被安排成与LOB系统同步的示例系统。如图所示，诸如Microsoft Outlook等生产性套件(220)在客户机设备上可用。Microsoft Outlook
单个用户必须能够在多台机器上安装客户端软件。然而，仅主机器能够与LOB系统同步。其它机器被认为是次要机器。LOB系统与主机器同步地返回一业务响应。该LOB系统与一格式化器接口以向主机器提供面向LOB系统的“命令”，诸如创建、更新或删除命令。在任何时刻，可以仅有一台主机器。包括其自己的生产性套件副本(270)的次要机器(例如，客户机260)仍包含主机器上可用的信息的副本，包括绑定项目(例如，生产性项目280，包括特性281-283)的业务和同步状态。所描述的系统可被安排成在服务器上维护一同步高速缓存，以将来自服务器的业务状态响应分发到次要客户机。A single user must be able to install client software on multiple machines. However, only the host machine can synchronize with the LOB system. Other machines are considered secondary machines. The LOB system returns a service response synchronously with the host machine. The LOB system interfaces with a formatter to provide LOB system oriented "commands", such as create, update or delete commands, to the host machine. At any one time, there can be only one master machine. A secondary machine (e.g., client machine 260) that includes its own copy of the productive suite (270) still contains a copy of the information available on the primary machine, including bound projects (e.g., productive project 280, including features 281-283 ) business and synchronization status. The described system may be arranged to maintain a synchronization cache on the server to distribute business status responses from the server to secondary clients.
生产性套件项目(例如，项目230)应持有供系统识别和呈现绑定项目的足够信息。绑定数据(包括升级的特性)应与生产性套件项目一起储存且与其相关联。储存在生产性套件项目中的系统信息应是静态的。换言之，它不应在其一旦被设置时改变，以避免引入“人为”同步冲突。系统应储存与生产性套件项目外部的同步有关的同步数据和系统特性。可使用隐藏在特性中的令牌来指定哪一机器是主机器。在某些情况下，可传递令牌，使得主机器可在诸如灾难恢复等情况下改变。A productive suite item (eg, item 230) should hold sufficient information for the system to identify and present the bound item. Binding data (including upgraded properties) should be stored with and associated with the Productivity Suite item. System information stored in Productivity Suite items should be static. In other words, it should not be changed once it is set, to avoid introducing "artificial" synchronization conflicts. The system shall store synchronization data and system properties related to synchronization external to productive suite items. A token hidden within an attribute can be used to specify which machine is the master. In some cases, tokens can be passed so that the master machine can be changed in situations such as disaster recovery.
图3示出了当由LOB系统创建一新的绑定项目时如何设置绑定项目(330)和LOB实体(370)之间的相关。首先，如由步骤1(391)所指示地在LOB系统(360)中创建LOB实体(370)，其中LOB实体(370)包括一标识符(CorrelationId(相关ID)372)。LOB系统(360)向服务器(340)传送一创建由CorrelationId 372标识为绑定项目的LOB实体的请求(392)，如步骤2所指示的。服务器(340)接收该请求(392)，并向该请求(392)应用一格式化器(250)，使得一命令(394)被传送给主客户机(310)以创建绑定。用于客户机(310)上的生产性套件(例如，Microsoft Outlook
图4示出了当在生产性套件中创建一新的绑定项目时如何设置绑定项目和LOB实体之间的相关。首先，如由步骤1(491)所指示地在生产性套件中创建项目(430)。接着，生产性套件(例如，Outlook
图5示出了当在生产性套件中更新或删除一绑定项目时如何改变绑定项目和LOB实体之间的相关。首先，如由步骤1(591)所指示地在生产性套件中改变项目(530)。接着，生产性套件(例如，Outlook
图6示出了当由LOB系统更新或删除一绑定项目时绑定项目与LOB实体之间的相关如何改变。首先，如由步骤1(691)所指示地在LOB系统(660)中修改或删除LOB实体(670)。LOB系统(660)向服务器(640)传送请求(692)以更新或删除由送至服务器的请求(692)中的CorrelationId(672)和BoundItemId中的至少一个所标识的LOB实体。服务器(640)接收该请求(692)，并向该请求(692)应用格式化器(650)，使得如由步骤4所指示地传送了改变或删除绑定项目的命令或控制消息(694)。主客户机(610)上用于生产性套件(例如，Outlook
上述同步子系统被部署到可以是公司网络内部或外部的客户机机器。预想了到公司网络的虚拟专用网，即VPN连接，经由诸如Microsoft Exchange Server等服务器应用程序的HTTP型远程同步连接也是可以的。LOB同步可以作为客户机设备上的后台线程运行，只要生产性套件正在运行。在生产性套件中所作出的改变经由任何适当的RPC机制(例如，公司网络、VPN、HTTP等)被提交给LOB系统，而对LOB系统的改变期望仅在公司网络上作出。文件同步可以在公司网络内诸如经由Microsoft Active Directory(现用目录)以任何适当的方式来处理，其中Microsoft Active Directory被安排成展示用于此目的的.NETAPI。The synchronization subsystem described above is deployed to client machines which may be inside or outside the corporate network. A virtual private network, i.e. VPN connection, to the corporate network is envisioned, an HTTP-type farsync connection via a server application such as Microsoft Exchange Server is also possible. LOB synchronization can run as a background thread on the client device as long as the productivity suite is running. Changes made in the productive suite are submitted to the LOB system via any suitable RPC mechanism (eg, corporate network, VPN, HTTP, etc.), while changes to the LOB system are expected to be made only on the corporate network. File synchronization can be handled in any suitable way within the corporate network, such as via Microsoft Active Directory (Active Directory), which is arranged to expose a .NET API for this purpose.
示例同步接口定义Example synchronous interface definition
对于每一绑定项目类型，同步系统将取决于所发生的改变(创建/更新/删除)来执行不同的动作。除此之外，可作为处理查询控制消息的结果来调用“Query(查询)”动作。使用Microfo Outlook的模式的示例同步接口定义在附录I中进一步示出。以下描述指定了需要被传入这些动作中的每一个以及从中返回的信息。For each bound item type, the synchronization system will perform different actions depending on the changes (create/update/delete) that occurred. In addition, the "Query" action may be invoked as a result of processing a query control message. Using Microfo Outlook An example synchronous interface definition for the schema is further shown in Appendix I. The following descriptions specify the information that needs to be passed into and returned from each of these actions.
Create(创建)是由系统在处理客户机侧绑定项目创建时调用的。对于Create的参数包括BoundItemId、BoundItemType(绑定项目类型)、RequestId(请求ID)、BoundData(绑定数据)以及CultureName(文化名称)。BoundItemId是用于绑定项目的客户机生成的唯一标识符串。BoundItemType是对应于绑定项目类型的完全限定名的串，包括解决方案和版本。RequestId是用于更新消息的唯一标识符，以允许LOB系统标识重复。BoundData是由用于LOB系统的模式定义的XML文档，使得用于绑定项目的BoundData被正确提供。CultureName是应当用于从Create调用中得出的业务状态、描述和任何其它消息的文化的名称。对于Create的返回值包括CorrelationId、RequestId、BusinessStatus(业务状态)以及Description(描述)。CorrelationId是LOB生成的作为用于项目类型的唯一标识符的串(例如，ContactId(联系人ID)唯一地标识了联系人)。RequestId是用于更新消息的唯一标识符，以允许主客户机标识重复。BusinessStatus是对应于作为Create的结果必须被分配给绑定项目的新业务状态的简短名称的串。它是LOB系统提供的任意值，同步不对该值的内容作出任何假设。理念是该值能用于过滤处于相同状态的项目。Description是一可任选串，它是关于BusinessStatus的解释。它将是绑定项目信息的一部分，使得它在需要时可以是UI上所展示的描述。Create is called by the system when it handles client-side binding item creation. The parameters for Create include BoundItemId, BoundItemType (bound item type), RequestId (request ID), BoundData (bound data) and CultureName (cultural name). BoundItemId is a client-generated unique identifier string for the bound item. BoundItemType is a string corresponding to the fully qualified name of the bound item type, including solution and version. RequestId is a unique identifier used for update messages to allow the LOB system to identify duplicates. BoundData is an XML document defined by a schema for the LOB system so that BoundData for bound items is provided correctly. CultureName is the name of the culture that should be used for business status, description and any other messages derived from the Create call. The return value of Create includes CorrelationId, RequestId, BusinessStatus (business status) and Description (description). CorrelationId is a string generated by the LOB as a unique identifier for the item type (eg, ContactId uniquely identifies a Contact). RequestId is a unique identifier used for update messages to allow the primary client to identify duplicates. BusinessStatus is a string corresponding to the short name of the new business status that must be assigned to the bound item as a result of Create. It is an arbitrary value provided by the LOB system, and synchronization makes no assumptions about the content of that value. The idea is that this value can be used to filter items in the same state. Description is an optional string, which is an explanation of BusinessStatus. It will be part of the binding item information so that it can be the description displayed on the UI if needed.
Update由系统在处理客户机侧绑定项目更新时调用。对于Update的参数包括BoundItemId、BoundItemType、RequestId、CorrelationId、OldBoundData(旧绑定数据)、NewBoundData(新绑定数据)以及CultureName。对于Update的返回值包括CorrelationId、RequesId、BusinessStatus和Description。RequestId是用于更新消息的唯一标识符，以允许LOB系统标识重复。如果发送了重复的更新消息，则必须发送相同的RequestId。OldBoundData是对应于来自最后一次同步状态的绑定项目的所有BoundData的XML文档。Update is called by the system when processing client-side binding item updates. The parameters for Update include BoundItemId, BoundItemType, RequestId, CorrelationId, OldBoundData (old bound data), NewBoundData (new bound data), and CultureName. The return value for Update includes CorrelationId, RequestId, BusinessStatus and Description. RequestId is a unique identifier used for update messages to allow the LOB system to identify duplicates. If duplicate update messages are sent, the same RequestId must be sent. OldBoundData is an XML document corresponding to all BoundData of the bound item from the last synchronized state.
Delete(删除)是由系统在处理客户机侧绑定项目删除时调用的。对于Delete的参数包括CorrelationId、BoundItemId、BoundItemType、RequestId、BoundData和CultureName。对于Delete的返回值包括CorrelationId、RequestId、BusinessStatus和Description。Delete is called by the system when it handles client-side binding item deletion. The parameters for Delete include CorrelationId, BoundItemId, BoundItemType, RequestId, BoundData, and CultureName. The return value for Delete includes CorrelationId, RequestId, BusinessStatus and Description.
QueryResult(查询结果)是由系统在处理查询控制消息时调用的。对于QueryResult的参数是消息的RequestId和BoundItemType、CorrelationId以及可任选的对于所有现有的指定类型的绑定项目的BoundData。对QueryResult没有返回值。QueryResult (query result) is called by the system when processing query control messages. The parameters for QueryResult are the RequestId and BoundItemType of the message, the CorrelationId, and optionally the BoundData for all existing bound items of the specified type. There is no return value for QueryResult.
示例控制消息定义Example Control Message Definition
本节指定了每一控制消息类型中所期望的信息。控制消息包括：创建控制消息、更新控制消息、删除控制消息和查询控制消息。This clause specifies the information expected in each control message type. Control messages include: create control messages, update control messages, delete control messages and query control messages.
创建控制消息包括用于以下各项的字段：BoundItemId、CorrelationId、BoundItemType和BoundData。更新控制消息包括用于以下各项的字段：CorrelationId、BoundItemType和BoundData。删除控制消息包括用于以下各项的字段：CorrelationId和BoundItemType。查询控制消息包括用于BoundItemType的字段。The Create Control message includes fields for: BoundItemId, CorrelationId, BoundItemType, and BoundData. The update control message includes fields for: CorrelationId, BoundItemType, and BoundData. The Delete Control message includes fields for: CorrelationId and BoundItemType. The Query Control message includes a field for BoundItemType.
BoundItemId是要分配给新的绑定项目的唯一标识符。BoundItemId是如将在以下更详细描述的由格式化器生成的。BoundItemType是对应于绑定项目类型的完全限定名的串，包括解决方案和版本。BoundItemType可由系统用于定位相应的绑定项目定义，它描述了要被绑定到生产性套件的特性以及生产性套件项目如何与LOB实体同步。如上所述，CorrelationId是由LOB系统分配给绑定项目的唯一标识符，而BoundData是包含用于绑定项目的所有绑定数据的XML文档。BoundItemId is a unique identifier to be assigned to a new bound item. The BoundItemId is generated by the formatter as will be described in more detail below. BoundItemType is a string corresponding to the fully qualified name of the bound item type, including solution and version. The BoundItemType can be used by the system to locate the corresponding bound item definition, which describes the properties to be bound to the productive suite and how the productive suite item is synchronized with the LOB entity. As mentioned above, CorrelationId is a unique identifier assigned to a bound item by the LOB system, and BoundData is an XML document containing all bound data for a bound item.
示例同步系统Example sync system
该系统可被安排成使得它不依赖于来自生产性套件(例如，MicrosoftOutlook)的事件来调用和检测同步。为了检测改变(创建/更新/删除)，该系统使用一种在生产性套件、同步数据存储(SDS)和直接从LOB系统获得的信息之间的三向同步方法。数据可以从系统中的多个入口点改变。信息可在包括从web访问、移动设备以及从其它客户机机器的许多不同地点改变。改变最终将被同步到主客户机机器(例如，经由Outlook/Exchange同步)。The system can be arranged so that it does not depend on ) events to invoke and detect synchronization. To detect changes (create/update/delete), the system uses a three-way synchronization method between the production suite, the Synchronized Data Store (SDS) and information obtained directly from the LOB system. Data can be changed from multiple entry points in the system. Information can be changed in many different places including from web access, mobile devices, and from other client machines. Changes will eventually be synchronized to the main client machine (e.g. via Outlook /Exchange sync).
LOB系统可基于唯一RequestId来检测并处理重复请求。与LOB系统的出站(客户机到服务器)通信可通过web服务来作出，而入站(服务器到客户机)消息将经由服务器应用程序(例如，MicrosoftExchange)流入客户机。The LOB system can detect and handle duplicate requests based on the unique RequestId. Outbound (client to server) communications with the LOB system can be made through web services, while inbound (server to client) messages will flow to the client via a server application (eg, Microsoft Exchange).
冲突检测也由系统在LOB系统和生产性套件改变同一绑定项目时处理。如果系统检测到用户和LOB系统更新了同一绑定项目，则将标识一冲突并且冲突分解将适当地处理该冲突。Conflict detection is also handled by the system when the LOB system and productivity suite change the same binding item. If the system detects that the user and the LOB system have updated the same binding item, a conflict will be identified and conflict resolution will handle the conflict appropriately.
LOB系统支持在接收到同步web服务调用时提供立即的业务响应。LOB系统无需接收关于Create、Update、Delete或Query命令的成功处理的确认或出错通知。The LOB system supports providing immediate business responses upon receipt of synchronous web service calls. The LOB system need not receive acknowledgment or error notification regarding the successful processing of Create, Update, Delete or Query commands.
本节描述了LOB系统和客户机之间的高级通信流程。以下各图提供了所支持的可能的通信流程的概观。This section describes the high-level communication flow between the LOB system and the client. The following figures provide an overview of the possible communication flows supported.
图7示出了在退(push)操作期间在客户机和服务器之间的示例通信流程。推操作如将描述的可由客户机(710)或服务器(750)发起。Figure 7 shows an example communication flow between a client and a server during a push operation. Push operations can be initiated by the client (710) or server (750) as will be described.
步骤1示出客户机(710)发起流程，其中改变检测过程由客户机上的系统执行。在步骤1处，系统中的同步逻辑(730)标识新的、经更新的和被删除的绑定项目，并创建(791)需要被提交给LOB系统的虚拟改变请求列表。该虚拟列表可在诸如虚拟出站队列(VQQ 712)等队列中提供。该列表在步骤2处当存在到LOB系统(例如，服务器750)的连接(例如，web服务调用792)时被处理。如果在步骤2处没有标识出与LOB系统的连接，则在下一次运行改变检测过程时重试该列表。
当创建虚拟请求列表时，该系统还考虑到新的传入控制消息(来自LOB的创建、更新、删除通知，来自控制消息列表714)以检测并适当地解决或引发冲突。冲突由同步逻辑(730)在生产性套件和LOB系统中修改了同一项目或在一方试图更新一项目而另一方正试图删除该项目时检测到。对于不导致冲突的每一检测到的改变(创建、更新、删除)，系统通过调用诸如在同步接口定义中描述的web服务(792)来向LOB系统(例如，服务器750)提交请求。When creating the virtual request list, the system also takes into account new incoming control messages (create, update, delete notifications from LOBs, from control message list 714) to detect and resolve or cause conflicts appropriately. Conflicts are detected by synchronization logic (730) when the same item has been modified in both the productivity suite and the LOB system, or when one party is trying to update an item while the other is trying to delete it. For each detected change (create, update, delete) that does not result in a conflict, the system submits a request to the LOB system (eg, server 750) by invoking a web service (792) such as described in the synchronization interface definition.
LOB系统(例如，具有LOB应用程序760的服务器750)还可在LOB系统上发生相关动作时触发客户机(710)上创建、更新、删除或查询动作的执行。在步骤3处，LOB系统调用由格式化器(770)展示的web服务(793)。在创建请求的情况下，格式化器(770)返回将由系统用于标识新的绑定项目的唯一ID。关于作为web服务调用的一部分发送的信息的细节，参见此处所讨论的同步接口定义一节。The LOB system (eg, server 750 with LOB application 760) can also trigger the execution of create, update, delete, or query actions on the client (710) when relevant actions occur on the LOB system. At
在步骤4处，格式化器(770)生成控制消息(794)，并将其发送给与生产性套件相关联的指定邮箱(例如，Outlook
在步骤5处，经由为生产性套件应用程序(720)格式化的电子邮件类型的机制将控制消息(795)传送到客户机(710)。客户机(710)在步骤6(796)处通过执行按需创建、更新和删除绑定项目的同步过程来处理该控制消息(795)。当处理控制消息时，该系统还考虑到需要被传递给LOB系统来适当地检测并标记冲突的本地改变(绑定项目的创建、更新、删除)。At
图8和9示出了可在另一示例系统中使用的拉(pull)操作，其中拉可以由同步web服务或LOB系统所模拟的轻推(nudge)来发起。Figures 8 and 9 illustrate a pull operation that may be used in another example system, where a pull may be initiated by a synchronous web service or a nudge emulated by a LOB system.
同步逻辑synchronization logic
绑定项目可被改变是因为用户直接或通过同步(例如，web访问接口)间接地改变它们。需要比较项目并确定客户机和LOB系统之间的差别来决定是否应将一侧上的改变传播到另一侧的过程。Bound items can be changed because the user changes them directly or indirectly through synchronization (eg, a web access interface). The process of comparing items and identifying differences between the client and the LOB system to decide whether changes on one side should be propagated to the other is required.
改变可以用四种方式之一来发生。第一，用户可在生产性套件中改变绑定项目。系统检测并自动向LOB系统提交改变请求。第二，改变可通过另一客户机来作出，并且这通过同步同时影响生产性套件客户机和LOB系统两者。对生产性套件和LOB系统的改变可以按任何顺序以任何延迟发生。第三，改变可通过智能电话(Smartphone)、web访问或任何其它手段作出，并且经由服务器同步到生产性套件。这些改变需要通过一同步过程来找到。第四，改变可以在LOB系统本身中作出。每一类改变必须都被同步过程考虑在内。Change can occur in one of four ways. First, users can change binding items in the productivity suite. The system detects and automatically submits change requests to the LOB system. Second, changes can be made by another client, and this affects both the productive suite client and the LOB system simultaneously through synchronization. Changes to the productive suite and LOB system can occur in any order and with any delay. Third, changes can be made via Smartphone, web access or any other means and synced to the productivity suite via the server. These changes need to be found through a synchronization process. Fourth, changes can be made in the LOB system itself. Each type of change must be taken into account by the synchronization process.
本地同步数据存储(SDS)储存原始版本。SDS与生产性套件和LOB系统同步并随后用于跟踪两者之间的增量。增量然后被添加到包含对LOB系统的所有服务请求的虚拟请求队列。更新过程确定何时需要将改变传播到LOB系统。同步逻辑形成请求，并在有连接时将其提交给LOB系统。当更新生产性套件时，同步逻辑使用LOB系统的信息来更新生产性套件信息(例如，Outlook)，然后更新SDS。A local Synchronous Data Store (SDS) stores the original version. The SDS is synchronized with the production suite and LOB system and then used to track the deltas between the two. The deltas are then added to a virtual request queue containing all service requests to the LOB system. The update process determines when changes need to be propagated to the LOB system. Synchronous logic forms the request and submits it to the LOB system when there is a connection. When updating a productivity suite, the synchronization logic uses the information from the LOB system to update the productivity suite information (for example, Outlook ), and update the SDS.
大多数绑定数据在两个地方存在：作为生产性套件中的项目以及在LOB系统中。假定每一副本包含在另一副本上不存在的额外数据。同步系统负责同步：一共享的特性子集被储存在绑定项目的BoundData特性中，且作为同步的结果，可创建或毁去绑定项目的存在，例如项目。同步系统假定单个真实性定义：LOB系统总是正确的。同时，同步系统对LOB实体没有任何直接访问，并且因此在SDS中保存有关它假设储存在LOB系统中的单独副本。Most binding data exists in two places: as items in the production suite and in the LOB system. Each replica is assumed to contain extra data that does not exist on the other replica. The synchronization system is responsible for synchronization: a shared subset of properties is stored in the BoundData property of a bound item, and as a result of synchronization, the existence of bound items, eg items, can be created or destroyed. Synchronous systems assume a single definition of truth: LOB systems are always true. At the same time, the synchronization system does not have any direct access to the LOB entity, and therefore keeps a separate copy in the SDS of what it is supposed to store in the LOB system.
同步过程可被划分成若干个不同的阶段。在清扫(sweep)阶段，将邮箱中的所有绑定项目与SDS进行比较。邮箱和SDS之间的引用完整性的任何失配被检测到并被立即修补。检测经修改的项目并标记它以供进一步处理。然后检测被删除的项目并将其传递给同步器，使得适当的删除请求可被发送给LOB系统。在某些实现中，上述同步过程的各阶段可被合并成单个集成过程，其中各种功能(例如，绑定、清扫、解决等)可被组合成一简化算法。该简化算法可实现改进的执行速度或实现某些其它改进的效率(例如，减少存储器/盘使用、消除冗余等)。The synchronization process can be divided into several different phases. During the sweep phase, all bound items in the mailbox are compared to the SDS. Any mismatch in referential integrity between the mailbox and the SDS is detected and immediately patched. Detects a modified item and flags it for further processing. Deleted items are then detected and passed to the synchronizer so that appropriate delete requests can be sent to the LOB system. In some implementations, the stages of the synchronization process described above can be combined into a single integrated process, where various functions (eg, binding, sweeping, resolution, etc.) can be combined into a simplified algorithm. This simplified algorithm may achieve improved execution speed or achieve some other improved efficiency (eg, reduced memory/disk usage, elimination of redundancy, etc.).
所标识的任何控制消息在第二阶段中处理。接着，对被标记为已修改的所有项目进行特性升级。将所得的经更新的XML数据表示与SDS副本进行比较并通知同步器。同步器在后台线程中运行，并且在此实施例中使用SDS副本。同步器负责提交Create、Update和Delete请求以及处理查询。Any control messages identified are processed in the second phase. Next, feature upgrades are performed on all items marked as modified. The resulting updated XML data representation is compared to the SDS copy and notified to the synchronizer. The synchronizer runs in a background thread and in this embodiment uses SDS replicas. Synchronizers are responsible for submitting Create, Update, and Delete requests and processing queries.
SDS副本包含上述相同的特性。在正常情况下，对于生产性套件项目和在SDS副本中EntryID(入口ID)、BoundItemId、BoundItemType和CorrelationId是相同的。生产性套件项目和SDS副本之间的任何差别被解释为更新LOB实体的请求。如果不是，则引用完整性被打破，并且必须进一步调查生产性套件项目。任何差别的主要原因是：项目是由用户创建的，对该项目还没有SDS副本，但是BoundData特性是可读的，并且该项目被用户复制、移动或删除，EntryID和BoundItemID之间的映射被打破；可能有全部都与单个SDS副本相关的零个、一个或多个项目，并且BoundData特性是可读的，用户已接收到了经更新的会议请求或任务请求；它具有被破坏的相应约会或任务(绑定项目)。项目的EntryID已被保留，但是BoundData特性不再是可读的。从另一用户接收到了外绑定项目的副本。BoundData特性不可读，并且对该项目在SDS中没有相应的副本。一副本或一绑定项目已被发送给另一用户并接着被发回，这是先前的可能性的变型，并且它不能被识别为特殊情况。可能已发生了数据破坏。SDS copies contain the same features described above. Under normal circumstances, the EntryID, BoundItemId, BoundItemType and CorrelationId are the same for the productive suite item and in the SDS copy. Any discrepancy between the productive suite item and the SDS copy is interpreted as a request to update the LOB entity. If not, referential integrity is broken and further investigation into the productive suite project is necessary. The main reason for any difference is: the item is created by the user, there is no SDS copy of the item yet, but the BoundData property is readable, and the item is copied, moved or deleted by the user, the mapping between EntryID and BoundItemID is broken ; There may be zero, one or more items all related to a single SDS copy, and the BoundData property is readable, the user has received an updated meeting request or task request; it has a corresponding appointment or task that is destroyed (bind item). The EntryID of the item has been preserved, but the BoundData property is no longer readable. A copy of an externally bound item was received from another user. The BoundData property is not readable and there is no corresponding copy in the SDS for this item. A copy or a binding item has been sent to another user and then sent back, which is a variant of the previous possibility, and it cannot be recognized as a special case. Data corruption may have occurred.
存在这样一个内置假设：BoundItemID是唯一的(主键)，并且BoundItemType+CorrelationId的组合也是唯一的(次键)。这些限制必须在SDS数据库中强制实施。当然，邮箱中EntryID也是唯一的。其中BoundData特性不可读或其中储存在内部重复特性不匹配生产性套件项目(例如，Outlook
通信流程communication process
图10示出了客户机上的生产性套件和LOB系统之间的另一示例通信流程。LOB系统(1070)可经由控制消息(创建、更新和删除)发起对绑定项目的更新。格式化器(1080)服务如LOB系统(1070)所请求的那样创建控制消息。该控制消息经由邮箱(1010)中的电子邮件消息被传送给生产性套件。服务器侧规则将该控制消息移入一指定的(隐藏)文件夹(例如，控制消息文件夹1020)，从该文件夹中，这些控制消息由控制消息处理器(1030)选取。创建、更新和删除请求被立即处理；而查询请求被排队到SDS(1050)中，并且由同步器(1060)处理。绑定器/清扫器/解决器(1040)服务(或取决于实现，多个服务)被安排成：将邮箱(1010)中的所有绑定项目与SDS(1050)进行比较，并标识绑定项目中的失配/改变。Figure 10 shows another example communication flow between the productivity suite on the client and the LOB system. The LOB system (1070) can initiate updates to bound items via control messages (create, update and delete). The formatter (1080) service creates control messages as requested by the LOB system (1070). The control message is transmitted to the productivity suite via an email message in the mailbox (1010). The server-side rules move the control messages into a designated (hidden) folder (eg, control message folder 1020), from which they are picked by the control message handler (1030). Create, update and delete requests are processed immediately; while query requests are queued into the SDS (1050) and processed by the synchronizer (1060). The binder/sweeper/resolver (1040) service (or depending on implementation, multiple services) is arranged to: compare all bound items in the mailbox (1010) with the SDS (1050) and identify the binding Mismatches/changes in projects.
尽管不是非常常见的，但是仍有重要的情形涉及LOB系统对一给定用户重新创建所有绑定项目。这可用于用初始绑定项目以及当某些项目已丢失或变为破坏时的灾难发现的一部分来填充邮箱。这一情形的一种变型可用于将现有的绑定项目升级到一新的绑定定义(模式)。它还可请求关于绑定项目的当前状态的信息(查询)。另一常见的使用是向用户的邮箱(1010)发送定期邮件消息；在这一情况下不涉及同步系统。Although not very common, there are still important situations that involve the LOB system recreating all bound items for a given user. This can be used to populate the mailbox with initially bound items as well as part of disaster discovery when some items have been lost or become corrupted. A variation of this scenario can be used to upgrade existing binding entries to a new binding definition (schema). It can also request information (queries) about the current state of the bound items. Another common use is to send periodic mail messages to a user's mailbox (1010); no synchronization system is involved in this case.
发送者的身份用于将有效的控制消息与非授权(或欺骗的)控制消息相区分。控制消息中的信息可被加密以保护其私密性。The identity of the sender is used to distinguish valid control messages from unauthorized (or spoofed) control messages. Information in control messages may be encrypted to protect its privacy.
主机器负责处理控制消息、升级特性、解决冲突以及向LOB提交更新。它保持SDS和邮箱同步。次要机器可用于经由UI来更新绑定项目。它还使用同步构建其自己的SDS数据库，但是具有某一重要的差别。次要机器不处理控制消息，并且在同步期间不完成特性升级，次要机器也不向LOB系统提交改变。当构建SDS时，次要机器假设邮箱中的数据是正确的。由于引用完整性问题而导致的任何更新SDS的失败被无声地忽略，因为假设主机器最终将解决冲突并且解决将被传播到次要机器。这一规则的重要结果是次要机器上的SDS不包含任何未决改变的完整状态，因此它不能被升级到主机器。The master machine is responsible for processing control messages, upgrading features, resolving conflicts, and submitting updates to the LOB. It keeps SDS and mailbox in sync. The secondary machine can be used to update binding items via the UI. It also uses synchronization to build its own SDS database, but with one important difference. Secondary machines do not process control messages, and feature upgrades are not done during synchronization, nor are secondary machines committing changes to the LOB system. When constructing the SDS, the secondary machine assumes that the data in the mailbox is correct. Any failure to update the SDS due to referential integrity issues is silently ignored, as it is assumed that the primary machine will eventually resolve the conflict and the resolution will be propagated to the secondary machines. An important consequence of this rule is that the SDS on the secondary machine does not contain the complete state of any pending changes, so it cannot be promoted to the primary machine.
服务器可被安排成出于将来自服务器的业务状态响应分发到各个次要客户机机器的目的而维护一同步高速缓存(例如，类似于SDS，但是不包括绑定数据信息)。服务器可周期性地将改变推到次要客户机，使得次要客户机具有相关SDS数据的最新副本。The server may be arranged to maintain a synchronization cache (eg, similar to SDS, but without binding data information) for the purpose of distributing business status responses from the server to various secondary client machines. The server can periodically push changes to the secondary client so that the secondary client has an up-to-date copy of the relevant SDS data.
同步子系统synchronization subsystem
同步子系统在图11中示出，并且包括以下主要组件：控制器(1102)、绑定项目管理器(1106)、绑定项目包装器(1112)、清扫器、解决器(1109)、控制消息处理器(1110)、数据提供者(1107)、以及同步器(1105)。The synchronization subsystem is shown in Figure 11 and includes the following main components: Controller (1102), Binding Item Manager (1106), Binding Item Wrapper (1112), Cleaner, Resolver (1109), Control Message Handler (1110), Data Provider (1107), and Synchronizer (1105).
控制器(1102)是用于控制同步过程的公共组件。The controller (1102) is a common component for controlling the synchronization process.
绑定项目管理器(1106)是用于创建和/或直接访问绑定项目的公共组件。绑定项目包装器是将生产性套件项目封装为绑定项目，或解除项目的绑定的公共包装器。在某些实现中，绑定项目管理器(1106)的功能可作为控制器(1102)的一部分或另一组件的一部分被包括。The Binding Item Manager (1106) is a common component for creating and/or directly accessing binding items. A bound item wrapper is a common wrapper that wraps a productivity suite item as a bound item, or unbinds an item. In some implementations, the functionality of the binding project manager (1106) may be included as part of the controller (1102) or as part of another component.
清扫器(1112)是用于找出需要调查(由于自从发生最后一次同步以来已经改变)的绑定项目的内部组件。在某些实现中，清扫器(1112)的功能可作为控制器(1102)的一部分或另一组件的一部分被包括。The Sweeper (1112) is an internal component used to find binding items that need to be investigated because they have changed since the last synchronization occurred. In some implementations, the functionality of the sweeper (1112) may be included as part of the controller (1102) or as part of another component.
解决器(1109)是用于调查绑定项目，并且或者本地解决改变(经由特性升级)和/或标记改变以进行完整同步的内部组件。在某些实现中，解决器(1109)的功能可作为控制器(1102)的一部分或另一组件的一部分被包括。The resolver (1109) is an internal component used to investigate binding projects, and either resolve changes locally (via feature upgrades) and/or mark changes for full synchronization. In some implementations, the functionality of the resolver (1109) may be included as part of the controller (1102) or as part of another component.
控制消息处理器(1110)是用于处理来自被监视的指定文件夹(1111)的针对格式化器发送的消息的控制消息的内部组件。处理控制消息以在创建/更新/删除动词的情况下更新生产性套件项目，或提交查询命令供同步器组件处理。在某些实现中，控制消息处理器(1110)的功能可作为控制器(1102)的一部分或另一组件的一部分被包括。The Control Message Handler (1110) is an internal component for processing control messages from the monitored specified folder (1111) for messages sent by the formatter. Handles control messages to update productive suite items in case of create/update/delete verbs, or submit query commands for processing by the synchronizer component. In some implementations, the functionality of the control message handler (1110) may be included as part of the controller (1102) or as part of another component.
数据提供者(1107)是提供对SDS数据表(1108)的访问的内部组件。在某些实现中，数据提供者(1107)的功能可作为控制器(1102)的一部分或另一组件的一部分被包括。Data Providers (1107) are internal components that provide access to SDS Data Tables (1108). In some implementations, the functionality of the data provider (1107) may be included as part of the controller (1102) or as part of another component.
同步器(1105)是负责以下事项的内部组件：当在客户机上创建、更新或删除绑定项目时通知LOB系统，在成功通知之后更新同步数据存储(SDS1108)，处理查询控制消息，以及报告同步过程的状态。在某些实现中，同步器(1105)的功能可作为控制器(1102)的一部分或另一组件的一部分被包括。The Synchronizer (1105) is the internal component responsible for notifying the LOB system when a bound item is created, updated, or deleted on the client, updating the Synchronization Data Store (SDS 1108) after a successful notification, processing query control messages, and reporting synchronization the state of the process. In some implementations, the functionality of the synchronizer (1105) may be included as part of the controller (1102) or as part of another component.
改变同步由图12示出如下。对绑定项目的改变可以在主机器(启用OBA的机器)上或诸如从web服务(例如，Outlook
管理绑定项目：启用的客户机Manage Bound Items: Enabled Clients
用户可在允许诸如通过内插附件或插件组件等来进行同步的客户机中创建、更新和删除绑定项目。系统检测改变，并自动将改变请求提交给LOB系统。该请求被处理，并且LOB系统发回一应用层成功或失败响应。该响应由客户机接收，并且更新绑定项目的应用程序业务状态。在新绑定项目(例如，在Outlook
管理绑定项目：web访问Manage Binding Items: Web Access
用户通过web访问访问其邮箱。绑定项目作为标准项目展示给用户。用户可正常改变标准信息，但是不能改变扩展信息。用户可更新或删除现有绑定项目，但是不能创建新的绑定项目，除了复制现有的绑定项目(间接创建)的情况之外。当用户返回到其主机器时，通过web访问作出的改变由服务器应用程序(例如，通过Microsoft Exchange)同步。系统检测该改变，并自动将适当的改变请求提交给LOB系统。Users access their mailboxes through web access. Bound items are presented to the user as standard items. Users can change standard information normally, but cannot change extended information. A user can update or delete an existing binding item, but cannot create a new binding item, except in the case of copying an existing binding item (indirect creation). Changes made through web access are synchronized by the server application (eg, through Microsoft Exchange) when the user returns to their host machine. The system detects this change and automatically submits the appropriate change request to the LOB system.
管理绑定项目：非启用的客户机Manage Bound Items: Non-Enabled Clients
用户可使用未被启用的生产性套件客户机来访问其邮箱。绑定项目作为标准项目出现。用户可正常改变标准信息，但是不能改变扩展信息。用户可更新或删除现有绑定项目，但是不能创建新项目。用户然后与服务器应用程序(例如，Microsoft Exchange)同步。当用户返回到其主客户机机器时，在非启用的客户机中作出的改变从服务器应用程序同步。系统检测该改变，并自动将适当的改变请求提交给LOB系统。Users can access their mailboxes using a Productivity Suite client that is not enabled. Bound items appear as standard items. Users can change standard information normally, but cannot change extended information. Users can update or delete existing bound projects, but cannot create new ones. The user is then synchronized with a server application (eg, Microsoft Exchange). When the user returns to his primary client machine, changes made in the non-enabled client are synchronized from the server application. The system detects this change and automatically submits the appropriate change request to the LOB system.
管理绑定项目：移动设备Manage Bound Projects: Mobile Devices
用户通过移动设备访问其邮箱。没有为移动设备提供特殊的支持，它们仅仅与web访问一样处理。绑定项目作为标准项目被展示给用户。用户可正常改变标准信息，但是不能改变扩展信息。用户可更新或删除现有绑定项目，但是不能创建新的绑定项目。当用户返回到其主客户机机器时，在移动设备中作出的改变由服务器应用程序(例如，Microsoft Exchange)同步。系统检测该改变，并自动将适当的改变请求提交给LOB系统。Users access their mailboxes from their mobile devices. No special support is provided for mobile devices, they are just treated the same as web access. Bound items are presented to the user as standard items. Users can change standard information normally, but cannot change extended information. Users can update or delete existing binding items, but cannot create new binding items. When the user returns to his main client machine, the changes made in the mobile device are synchronized by the server application (eg, Microsoft Exchange). The system detects this change and automatically submits the appropriate change request to the LOB system.
管理绑定项目：多个启用的客户机Manage Bound Projects: Multiple Enabled Clients
用户具有一个“主”客户机机器，和任意数量的“次要”客户机机器，其中每一机器具有一已安装的允许生产性套件应用程序和LOB系统之间的同步的客户端应用程序。用户可创建、更新或删除任何机器中的绑定项目。在一个机器上作出的改变将经由服务器应用程序(例如，Microsoft Exchange)同步到其它机器，但是在一个实施例中，仅主机器能够与LOB系统同步。“主”机器在安装时指定；其它机器将被认为是“次要”机器。对用户能够具有的次要机器的数量没有具体限制。当到LOB系统的连接在主机器上可用时，系统将自动提交所需的改变请求给LOB系统。A user has one "primary" client machine, and any number of "secondary" client machines, each of which has an installed client application that allows synchronization between the productivity suite application and the LOB system. Users can create, update or delete binding items in any machine. Changes made on one machine will be synchronized to other machines via a server application (eg, Microsoft Exchange), but in one embodiment, only the master machine can synchronize with the LOB system. The "primary" machine is specified at installation; the other machines will be considered "secondary" machines. There is no specific limit to the number of secondary machines a user can have. When a connection to the LOB system is available on the host machine, the system will automatically submit the required change requests to the LOB system.
所描述的系统可被安排成使得出于将来自服务器的业务状态响应分发到各个次要客户机机器的目的而在服务器上维护一同步高速缓存。对于此示例，服务器的同步高速缓存在每一主客户机清扫之前或之后更新。服务器的同步高速缓存可包括来自SDS的所有数据，除了绑定数据之外。根据清扫内部时间表，服务器的同步高速缓存可从服务器下载到每一次要客户机自己的SDS。The described system may be arranged such that a synchronized cache is maintained on the server for the purpose of distributing business status responses from the server to various secondary client machines. For this example, the server's sync cache is updated before or after each master client sweep. The server's sync cache may include all data from the SDS, except bound data. The server's sync cache can be downloaded from the server to each secondary client's own SDS according to a cleanup internal schedule.
管理绑定项目：改变的传播Managing Bound Projects: Propagation of Changes
当对相关业务实体的改变是在LOB系统中作出的时候，将经由格式化器通知服务器应用程序。改变通知被传送到可能需要将该改变应用于绑定项目的启用的客户机。由于改变通知被推出，因此客户机无需查验更新，并且可直接响应而不等待调度的同步时间。When changes to related business entities are made in the LOB system, the server application will be notified via the formatter. Change notifications are communicated to enabled clients that may need to apply the change to the bound item. Since change notifications are pushed out, clients do not need to check for updates and can respond directly without waiting for a scheduled sync time.
同步方法synchronization method
图13是用于示例同步方法的流程图。系统清扫器过程可周期性地定位并“标记”需要被同步的绑定项目，其中这些项目被置于一逻辑列表中以供同步(同步列表)。对于同步列表中的每一项目，生成创建、更新或删除请求(CUD请求)并将其储存在出站队列(例如，来自图7的VQQ 712)中。然后发起一web服务调用，使得可建立到LOB系统的连接。该web服务调用可以成功、失败或生成一连接异常。13 is a flowchart for an example synchronization method. The System Sweeper process may periodically locate and "mark" binding items that need to be synchronized, where these items are placed in a logical list for synchronization (the synchronization list). For each item in the synchronization list, a create, update or delete request (CUD request) is generated and stored in an outbound queue (e.g.,
当响应于该web服务调用从LOB获得响应时，建立了成功的连接。对于到web服务的成功连接，系统用来自响应的信息更新SDS中的绑定项目副本。对同步列表中的每一项目类似地处理其它CUD请求。A successful connection is established when a response is obtained from the LOB in response to the web service call. For a successful connection to the web service, the system updates the copy of the binding item in the SDS with the information from the response. Other CUD requests are handled similarly for each item in the synchronization list.
当响应于web服务调用从LOB系统提供除连接异常以外的其它异常时，得到失败的连接。对于到web服务的失败的连接，CUD请求被保持在出站队列中，并被标记以进行重试。当标识了第一个失败的连接时可初始化对CUD请求的重试计数。重试将继续，直到或者建立了成功的连接，或者在一预定时间间隔上允许的最大尝试次数达到一极限。当达到所允许的最大尝试次数而没有成功时，该CUD请求被移至一失败请求队列。不处理其它CUD请求，除非实现成功连接。A failed connection is obtained when an exception other than a connection exception is provided from the LOB system in response to a web service call. For failed connections to the web service, the CUD request is held in an outbound queue and marked for retry. A retry count for CUD requests may be initialized when the first failed connection is identified. Retries will continue until either a successful connection is established, or the maximum number of attempts allowed over a predetermined time interval reaches a limit. When the maximum allowed number of attempts is reached without success, the CUD request is moved to a failed request queue. No other CUD requests are processed unless a successful connection is achieved.
连接异常可在客户机具有有效的认证cookie并且对目标服务器的查验失败时发生。当从web服务调用得到连接异常时，系统跳至同步列表上的下一项目。A connection exception can occur when the client has a valid authentication cookie and the ping of the target server fails. When getting a connection exception from a web service call, the system skips to the next item on the synchronization list.
用于同步的一个示例过程流由图13示出，如以下将描述的。处理在框1301除开始，并且流至判定框1305。An example process flow for synchronization is shown in Figure 13, as will be described below. Processing begins at
在判定框1305处，生产性套件同步系统评估同步列表以标识需要在生产性套件应用程序和LOB应用程序之间同步的任何绑定项目。当同步列表上没有绑定项目时，该处理流至框1310，在那里系统在再次评估同步列表之前等待一预定时间(例如，X分钟)。当在同步列表中找到绑定项目时，系统在框1315处确定是否达到了最大失败请求数。当达到了最大请求数时，处理再次流至框1310。或者，处理在框1320处继续，在那里创建一CUD请求。At
继续到框1325，将该CUD请求置于诸如来自图7的VQQ 712等出站请求队列中。在框1330处，生产性套件应用程序同步系统通过诸如web服务调用等服务调用将出站请求队列中的每一请求提交给LOB系统。继续到判定框1335，评估该CUD调用请求以确定该请求是否被成功提交给LOB系统。当CUD调用请求成功时，处理从判定框1335继续到框1340(在那里更新同步数据存储，即SDS)。当CUD调用请求失败时，处理从判定框1335流至框1345。在某些情况下，生成连接异常，并且处理从判定框1335流至判定框1305。Proceeding to block 1325, the CUD request is placed in an outbound request queue such as
在框1345处，用于生产性套件应用程序的同步系统对CUD调用请求尝试重试。在判定框1350处，系统确定是否从动调用请求接收到响应。当该响应成功时，处理从判定框1350流至框1340，在那里更新SDS。当响应失败时，处理从判定框1350流至判定框1360。如果没有接收到响应，则处理从判定框1350流至框1355，在那里系统在框1345处尝试另一重试之前等待一超时到期。At
在判定框1360处，系统确定是否达到了对CUD调用请求的最大重试数。当达到最大重试数时，处理继续到框1365，在那里CUD请求被移至一失败队列。当未超过最大重试数时，系统在框1370处递增内部重试计数器，并且前进到框1355以等待另一重试。At
引用同步的项目Items that reference sync
如上所述，绑定是在LOB实体和PS(生产性套件)项目之间创建的。尽管同步系统没有对LOB实体的任何直接访问，但是SDS保持它假设被储存在LOB系统中的单独副本。当创建LOB实体和PS项目之间的绑定时，可将同步的PS项目的副本置于SDS中，使得PS项目可以用与该LOB实体相关联的CorrelationId来索引。换言之，与LOB实体相关联的PS项目可以参考CorrelationIs从SDS中检索。由于PS项目可参考CorrelationId来检索，因此可实现可以利用PS项目的多个感兴趣的应用程序、插件或其它软件方法(例如，后端工作流系统)。As mentioned above, bindings are created between LOB entities and PS (Productivity Suite) items. Although the synchronization system does not have any direct access to the LOB entities, the SDS maintains a separate copy of what it is supposed to be stored in the LOB system. When creating a binding between a LOB entity and a PS item, a copy of the synchronized PS item can be placed in the SDS so that the PS item can be indexed with the CorrelationId associated with the LOB entity. In other words, PS items associated with LOB entities can be retrieved from SDS with reference to CorrelationIs. Since PS Items can be retrieved by reference to the CorrelationId, multiple interesting applications, plug-ins, or other software methods (eg, back-end workflow systems) that can utilize PS Items can be implemented.
在一个示例中，LOB应用程序可将LOB标识符(例如，CorrelationId)经由电子邮件通信传送到生产性套件应用程序。电子邮件通信包括引用LOB项目的嵌入信息。例如，CorrelationId可被嵌入在与电子邮件消息相关联的首部中。电子邮件通信无需包含(嵌入或以其它方式)LOB项目本身，因为CorrelationId引用该LOB实体。一旦接收到电子邮件消息，用于生产性套件的电子邮件处理程序可在同步阴影或同步数据存储中标识引用该LOB标识符的特定生产性套件项目。In one example, the LOB application may communicate the LOB identifier (eg, CorrelationId) to the productivity suite application via email communication. Email communications include embedded information referencing LOB items. For example, CorrelationId can be embedded in headers associated with email messages. Email communications need not contain (embed or otherwise) the LOB item itself, since the CorrelationId references that LOB entity. Upon receipt of the email message, the email handler for the productivity suite can identify the particular productivity suite item referencing that LOB identifier in the sync shadow or sync data store.
在另一示例中，用户可用引用与SDS中的PS项目相关联的LOB标识符的链接(例如，任何数量的形式的URL链接，诸如HTTP、HTTPS、FTP、FTPS、OBA等)来引用生产性套件项目。In another example, a user may reference a production link (e.g., any number of forms of URL links such as HTTP, HTTPS, FTP, FTPS, OBA, etc.) that references the LOB identifier associated with the PS item in the SDS. kit item.
在又一示例中，当LOB系统向生产性套件系统发送电子邮件消息时，可激活动作窗格、任务窗格或其它软件方法。一旦被激活，该软件方法可通过引用CorrelationId来从SDS中检索生产性套件项目，然后对该生产性套件项目执行动作。In yet another example, an action pane, task pane, or other software method may be activated when the LOB system sends an email message to the productivity suite system. Once activated, the software method can retrieve the Productivity Suite Item from the SDS by referencing the CorrelationId, and then perform actions on the Productivity Suite Item.
可由软件方法在生产性套件项目上执行的动作可导致生产性套件项目的创建、更新或删除，这然后可以如上所述地与LOB系统同步。LOB系统可通过引用软件方法以及电子邮件通信中的LOB标识符来有效地将任务传达给生产性套件用户。Actions that may be performed by the software method on productive suite items may result in the creation, update or deletion of productive suite items, which may then be synchronized with the LOB system as described above. The LOB system can efficiently communicate tasks to productive suite users by referencing software methods as well as LOB identifiers in email communications.
在一个示例性软件方法中，即来自LOB系统的电子邮件通信可向用户传达完成与同用LOB标识符标识的LOB实体同步的特定生产性套件项目相关联的审阅或批准的请求。该电子邮件通信可以在LOB系统中的最后期限到来时或在由LOB系统的特定用户提供时由LOB系统自动传送。该电子邮件可由LOB系统通过向格式化器传送信息(例如，经由XML数据表示、经由文本、经由嵌入的数据等)来创建，格式化器然后与电子邮件和目录服务器(见例如图7)协作来创建电子邮件消息。电子邮件可强调该需求以最终化与生产性套件项目相关联的动作、提供进一步的解释等，其中电子邮件可引用后端工作流系统中的任务。由于生产性套件应用程序可将嵌入在电子邮件通信中的链接解释为任务，因此实际任务信息可被自动呈现。用户然后可选择并跟随该链接以打开生产性套件应用程序中的任务项目，其中相关联的同步的后端信息可用XML数据表示来储存。由于LOB标识符可被嵌入在链接中，因此任何所需的与生产性套件项目相关联的动作可通过适当地配置处理程序(例如，URL处理程序)来采取。In one exemplary software method, an email communication from the LOB system may convey to the user a request to complete a review or approval associated with a particular productivity suite item synchronized with the LOB entity identified by the LOB identifier. This e-mail communication can be delivered automatically by the LOB system when a deadline in the LOB system is reached or when provided by a particular user of the LOB system. The email may be created by the LOB system by passing information (e.g., via XML data representation, via text, via embedded data, etc.) to the formatter, which then cooperates with the email and directory server (see, e.g., FIG. 7 ) to create an email message. An email may emphasize the need to finalize actions associated with the productive suite item, provide further explanation, etc., where the email may refer to a task in the backend workflow system. Since the productivity suite application can interpret links embedded in email communications as tasks, actual task information can be automatically presented. The user can then select and follow the link to open the task item in the productivity suite application, where the associated synchronized backend information can be stored in an XML data representation. Since the LOB identifier can be embedded in the link, any desired action associated with the productive suite item can be taken by configuring the handler (eg, URL handler) appropriately.
生产性套件项目接口定义Productivity suite project interface definition
可利用各种接口来促进定制用户界面(UI)表单和与生产性套件项目的其它交互。各种接口可从应用程序代码访问，并且在生产性套件项目和应用程序代码之间提供。存在另外的一组可在运行时引擎和应用程序代码之间使用的接口。如所描述的，可利用元数据来定义UI表单。尽管以下提供的许多示例是参考Microsoft Outlook
一般而言，可为诸如Microsoft Outlook
在一个实施例中，IWindow接口描述了通常是检查器窗口的包装的Outlook
IntPtr Handle {get；}IntPtr Handle { get; }
这获得用于包装的窗口的句柄。This gets the handle of the window used for wrapping.
object Native {get；}object Native { get; }
这返回用于底层生产性套件项目的对象。This returns the object used for the underlying productivity suite item.
IBoundItem Item{get；}IBoundItem Item { get; }
这返回在包装的窗口中显示的绑定项目。This returns the bound item displayed in the wrapped window.
IBoundItem AssociatedItem {get；}IBoundItem AssociatedItem { get; }
这返回与包装的窗口相关联的绑定项目。This returns the binding item associated with the wrapped window.
void ShowPane(XmlNode context；}void ShowPane(XmlNode context; }
该方法允许应用程序开发者在应用程序窗格中显示一区域(例如，信息桥框架(Information Bridge Framework)，即IBF区域)。This method allows an application developer to display a region (eg, an Information Bridge Framework (IBF region)) in an application pane.
Outlook内插附件处理以适当大小和位置显示浮动窗格的复杂性。上下文是选择描述窗格内容的元数据所需的信息。Outlook Inline attachments handle the complexities of displaying floating panes at the proper size and position. Context is the information needed to select metadata describing the content of the pane.
void ShowDialog(XmlNode context；}void ShowDialog(XmlNode context; }
该方法允许应用程序开发者在应用程序窗格的一区域内显示对话框。上下文是选择描述该窗格中的对话框的元数据所需的信息。This method allows application developers to display dialog boxes within an area of the application pane. The context is the information needed to select the metadata that describes the dialog in that pane.
void RegisterPage(IXamlPage xamlPage}void RegisterPage(IXamlPage xamlPage}
这由窗口管理器服务在创建一新的XAML呈现器引擎时调用。This is called by the window manager service when creating a new XAML renderer engine.
XamlPage是对新创建的XAML页面的接口。XamlPage is the interface to newly created XAML pages.
在一个实施例中，IWindowCodeBehind接口定义了可由应用程序开发者以其自己的自定义代码处理的事件。IWindowCodeBehind接口定义包括：In one embodiment, the IWindowCodeBehind interface defines events that can be handled by application developers in their own custom code. The IWindowCodeBehind interface definition includes:
void OnInit(IWindow window，IServiceProvider serviceProvider)该方法在检查器窗口(被指定为初始化的IWindow)被打开并且在元数据中指定了相关联的隐藏代码程序集时调用。该方法被传递以实现开发者可用于访问该窗口和相关联的生产性套件项目两者的IWindow接口的对象。void OnInit(IWindow window, IServiceProvider serviceProvider) This method is called when an inspector window (the IWindow designated as initialized) is opened and the associated code-behind assembly is specified in the metadata. This method is passed an object implementing the IWindow interface that the developer can use to access both the window and the associated productivity suite item.
void OnSelectControl(string name，string param)void OnSelectControl(string name, string param)
该方法在选择一自定义解决方案控件或按钮时调用。解决方案控件的名称在作为名称自变量传递的SolutionControls XML中定义，从而允许应用程序开发者适当地分派动作。并且，在元数据中定义的参数被传递到该方法并在SolutionControls XML中定义。This method is called when a custom solution control or button is selected. The name of the solution control is defined in the SolutionControls XML passed as the name argument, allowing application developers to dispatch actions appropriately. Also, the parameters defined in the metadata are passed to the method and defined in the SolutionControls XML.
void OnSelecTab(int index，string name，string caption)void OnSelectTab(int index, string name, string caption)
该方法在用户点击检查器窗口中一不同选项卡时调用。index参数是所选择的选项卡的基于零的次序。参数name是在XAML页面中指定的选项卡的名称。caption参数是在XAML页面中指定为文本的选项卡的文字说明。This method is called when the user clicks on a different tab in the inspector window. The index parameter is the zero-based order of the selected tabs. The parameter name is the name of the tab specified in the XAML page. The caption parameter is the textual description of the tab specified as text in the XAML page.
void OnNewPage(IXamlPage xamlPage)void OnNewPage(IXamlPage xamlPage)
该方法在为窗口创建一新的XAML引擎包装器时调用。XamlPage是所创建的XAML页面。This method is called when a new XAML engine wrapper is created for the window. XamlPage is the created XAML page.
在一个实施例中，IBoundItem接口包装生产性套件项目并根据BoundItemDefinition提供对映射的特性的访问。IBoundItem接口定义包括；In one embodiment, the IBoundItem interface wraps a productivity suite item and provides access to mapped properties according to a BoundItemDefinition. IBoundItem interface definition includes;
string BoundItemId {get；}string BoundItemId { get; }
这获得绑定项目的ID，如果项目未绑定则为空。This gets the ID of the bound item, or null if the item is not bound.
string CorrelationId {get；}string CorrelationId { get; }
这获得如由LOB系统定义的绑定项目的ID，如果未定义项目则为空。This gets the ID of the bound item as defined by the LOB system, or null if no item is defined.
string BoundItemType {get；}string BoundItemType { get; }
这获得与包装的项目相关联的类型，等价于BoundItemDefinition的名称，并且如果项目未绑定则为空。This gets the type associated with the wrapped item, equivalent to the name of the BoundItemDefinition, or null if the item is unbound.
BoundItemDefinition BoundItemDefinition {get；}BoundItemDefinition BoundItemDefinition { get; }
这获得绑定的定义。This gets the definition of the binding.
SynchronizationStatus SynchronizationStatus {get；}SynchronizationStatus SynchronizationStatus { get; }
这获得绑定项目的同步状态。This gets the sync state of the bound item.
string BusinessStatus {get；}string BusinessStatus { get; }
这获得绑定项目的业务状态。This gets the business status of the bound item.
string BusinessDescription {get；}string BusinessDescription { get; }
这获得绑定项目的业务描述。This gets the business description of the bound item.
object OutlookItem {get；}object OutlookItem { get; }
这获得用于被包装的项目的对象。This gets the object for the wrapped item.
string EntryId {get；}string EntryId { get; }
这获得被包装的项目的入口ID。This gets the entry ID of the item being wrapped.
string MessageClass {get；}string MessageClass { get; }
这获得被包装的项目的消息类。This gets the message class of the wrapped item.
Date Time LastModified {get；}Date Time LastModified { get; }
这获得被包装的项目的最后修改时戳。This gets the last modification timestamp of the wrapped item.
string XmlData {get；set；}string XmlData { get; set; }
这返回被包装的项目的映射的特性作为一XML串。This returns the mapped properties of the wrapped item as an XML string.
string BoundData {get；}string BoundData { get; }
这返回被包装的项目的映射的特性作为一加密的XML串。This returns the mapped properties of the wrapped item as an encrypted XML string.
XmlDocument GetXmlDocument ()XmlDocument GetXmlDocument()
这构建并返回映射的特性作为XML文档。XML被保持与同生产性套件中的包装的项目相关联的字段同步。This builds and returns the mapped properties as an XML document. The XML is kept in sync with the fields associated with the packaged items in the productivity suite.
object GetProperty(string name)；object GetProperty(string name);
这按照名称返回映射的特性的值。This returns the value of the mapped property by name.
void SetProperty(string name，object value)；void SetProperty(string name, object value);
该方法按照名称改变映射的特性的值。This method changes the value of a mapped property by name.
event PropertyChangedEventHandler PropertyChanged；event PropertyChangedEventHandler PropertyChanged;
该事件在特性的值改变时引发。This event is raised when the property's value changes.
event EventHandler<PropertyErrorEventArgs>PropertyError；event EventHandler<PropertyErrorEventArgs>PropertyError;
该事件在向特性分配值时发生出错时引发。This event is raised when an error occurs while assigning a value to the property.
void Validate()；void Validate();
该方法对照来自BoundItemDefinition的XML模式来确认包含映射的特性的XML。This method validates the XML containing the mapped properties against the XML Schema from the BoundItemDefinition.
void Save()；void Save();
该方法确认映射的特性并保存生产性套件项目This method confirms the properties of the map and saves the productive suite item
void PromoteProperties()；void PromoteProperties();
该方法同步XML文档和生产性套件中诸如UserProperties等各种字段之间的映射的特性的值。生产性套件中遗漏的字段在必要时被重新创建。生产性套件项目由此方法保存，称为显示保存。This method synchronizes the values of properties mapped between the XML document and various fields in the productivity suite, such as UserProperties. Missing fields in the productivity suite were recreated where necessary. Productivity Suite projects are saved by this method, known as display saving.
void RemoveProperties()；void RemoveProperties();
该方法根据BoundItemDefinition移除所有自定义生产性套件字段(UserProperties)。This method removes all custom productivity suite fields (UserProperties) according to BoundItemDefinition.
void BindItem(string definition)；void BindItem(string definition);
该方法将生产性套件项目转换成绑定项目。This method converts a productive suite project into a binding project.
void BindItem(BoundItemDefinition)；void BindItem(BoundItemDefinition);
该方法根据BoundItemDefinition将生产性套件项目转换成绑定项目。This method converts a productive suite item into a bound item according to the BoundItemDefinition.
void UnBindItem()；void UnBindItem();
该方法解除生产性套件的绑定。This method unbinds the productivity suite.
IBoundItemManager服务是用于操纵绑定项目的各种方法的公共接口。The IBoundItemManager service is the public interface for various methods for manipulating bound items.
IBoundItemManager公共接口包括以下定义：The IBoundItemManager public interface includes the following definitions:
IBoundItem CreateBoundItem(string BoundItem Type)；IBoundItem CreateBoundItem(string BoundItem Type);
IBoundItem CreateBoundItem(BoundItemDefinition definition)；IBoundItem CreateBoundItem(BoundItemDefinition definition);
IBoundItem GetBoundItem(object item)；IBoundItem GetBoundItem(object item);
IBoundItem GetBoundItem(string BoundItemId)；IBoundItem GetBoundItem(string BoundItemId);
IBoundItem GetBoundItem(string BoundItemType，string CorrelationId)；IBoundItem GetBoundItem(string BoundItemType, string CorrelationId);
IBoundItem GetBoundItem(BoundItemDefinition definition，string CorrelationId)；IBoundItem GetBoundItem(BoundItemDefinition definition, string CorrelationId);
元数据驱动的用户界面(UI)表单Metadata-driven user interface (UI) forms
如上所述，可使用元数据来创建并定制可用于诸如Microsoft Outlook
有其中可使用元数据来定义用于生产性套件应用程序的UI表单的多种情形。在某些情形中，可指定表单上的可定制区域，而其它区域不能被定制。在一种情形中，用户界面控件和数据由元数据来定义。在另一情形中，可使用元数据向表单添加字段/值对，使得表单可被定制。在又一情形中，可使用元数据从现有表单中移除字段/值对。在再一情形中，可将一个表单上的字段值对转换到另一表单以适应最终用户偏好。There are a number of situations where metadata can be used to define UI forms for a productivity suite application. In some cases, you can specify customizable areas on the form, while other areas cannot be customized. In one case, user interface controls and data are defined by metadata. In another scenario, metadata can be used to add field/value pairs to the form so that the form can be customized. In yet another situation, metadata can be used to remove field/value pairs from existing forms. In yet another case, field value pairs on one form may be converted to another form to accommodate end user preferences.
UI表单开发者可通过用元数据定义UI表单来指定用于表单/对话框的UI。开发者对定义UI表单有显著的灵活性，使得控件可被添加/移除、控件特性可被设置和/或改变、以及表单上的各种控件的布局可被指定，所有这些都通过使用元数据来进行。UI form developers can specify UI for forms/dialogs by defining UI forms with metadata. Developers have significant flexibility in defining UI forms such that controls can be added/removed, control properties can be set and/or changed, and the layout of various controls on the form can be specified, all through the use of meta data to proceed.
一个示例UI表单在图14A中示出。描述用户界面的元数据(1401)由开发者生成以定义表单中的各种区域。例如，UI表单1410由元数据1401定义为包括标签1411、图形图像1412、以及用于下拉菜单1420、选择按钮1430和文本输入框1440的控件。每一下拉菜单控件被示为包括用于选择下来菜单选择域中的一个值的按钮(1421)。文本输入框控件(1440)包括用于滚动在文本框中输入的文本(1442)的向上和向下滚动按钮(1441)。An example UI form is shown in Figure 14A. Metadata (1401) describing the user interface is generated by the developer to define the various fields in the form. For example, a
如图14B所示，UI表单1410可在该UI表单的某些区域中定制，使得可如由UI表单1410B所示地添加其它字段/值对。UI表单1410B包括一新的部分(1450)，它包括用于“Company Policy”字段的标签(1411)，而该标签包括用于下拉菜单(1420)的具有相应按钮(1421)的控件。As shown in Figure 14B,
如图14B所示，UI表单1410可在该UI表单的某些区域中定制，使得可如由UI表单1410B所示地添加其它字段/值对。UI表单1410B包括一新的部分(1450)，它包括用于“Company Policy”(公司政策)字段的标签(1411)，而该标签包括用于下拉菜单(1420)的具有相应按钮(1421)的控件。As shown in Figure 14B,
如图14C所示，UI表单1410可以在该UI表单的特定区域中定制，使得可如由UI表单1410C所示地移除其它字段/值对。UI表单1410包括具有文本输入框(1440)的区域(1460)，该文本输入框然后可从表单1410C中移除。As shown in Figure 14C,
如图14D所示，UI表单1410可在该UI表单的某些区域中定义，使得各种字段/值对可被转换成其它字段/值对以适合用户偏好、场所等。在此示例中，UI表单1410中名为“Activity”(活动)的标签(1411)被转换成一新标签(1411D)，它在UI表单1410上被重命名为“Task Type”(任务类型)。As shown in Figure 14D, a
开发者可使用元数据来对反映对表单环境(例如，WinForms)支持的典型事件的每一控件指定用于一给定事件列表的事件处理程序。开发者可在元数据中指定每一事件处理程序的名称，并且还可提供用于该事件处理程序的计算机可读/可执行代码以在隐藏代码程序集中使用。程序集的名称和位置也可作为元数据的一部分来捕捉。Developers can use metadata to specify event handlers for a given list of events for each control reflecting typical events supported by a forms environment (eg, WinForms). The developer can specify the name of each event handler in the metadata, and can also provide the computer readable/executable code for that event handler for use in the code-behind assembly. The name and location of the assembly can also be captured as part of the metadata.
绑定表达式可在元数据中指定，以允许将数据从数据源绑定到表单上的控件的各种特性/域。还可使用元数据来指定从控件特性到数据源的绑定。Binding expressions can be specified in metadata to allow binding data from a data source to various properties/fields of controls on the form. Metadata can also be used to specify bindings from control properties to data sources.
所描述的元数据驱动的表单UI设计包括可用于设计UI表单的一组基本的、最常用的控件。然而，可以对UI表单自定义地构建更多复杂的控件。一UI呈现引擎被安排成支持在生产性套件应用程序中呈现基本和自定义控件。在一个示例中，可在Microsoft Outlook
用于定义UI表单的示例元数据模式Example metadata schema for defining UI forms
附录IV示出了根据本发明的至少一方面的用于定义UI表单的示例元数据模式。附录III中的示例模式由图15和16进一步示出，它们示出了用于可在元数据中定义的控件的各种控件类型和类。Appendix IV illustrates example metadata schemas for defining UI forms in accordance with at least one aspect of the present invention. The example schema in Appendix III is further illustrated by Figures 15 and 16, which show the various control types and classes for controls that can be defined in metadata.
如图15所示，所有控件具有包括一系列基本特性和基本事件的基本控件类型(1501)。基本特性的示例包括控件的布局和尺寸(例如，Width(宽度)、Height(高度)、Top(顶部)、Left(左边)等)。基本事件的示例包括Click(点击)、GotFocus(获得焦点)、LostFocus(失去焦点)等。控件可以是任何类型，诸如文本框(TextBox)(1502)、复选框(CheckBox)(1503)或可从其它类型中派生的某些其它通用类型(1504)。As shown in Figure 15, all controls have a basic control type (1501) that includes a series of basic properties and basic events. Examples of basic properties include the layout and size of the control (eg, Width, Height, Top, Left, etc.). Examples of basic events include Click (click), GotFocus (get focus), LostFocus (lose focus), and the like. Controls can be of any type, such as TextBox (1502), CheckBox (CheckBox) (1503), or some other generic type (1504) that can be derived from other types.
文本框控件(1502)包括一组特定特性，诸如文本对齐、文本框长度、文本框使用的最小行数、文本换行特性等等。复选框控件(1503)包括复选框专用特性，诸如文本对齐、框被复选或取消复选的状态、以及与复选框有关的任何特定事件，如复选框的状态从被复选到取消复选的改变或相反的改变。The text box control (1502) includes a specific set of properties, such as text alignment, text box length, minimum number of lines used by the text box, text wrapping properties, and the like. The checkbox control (1503) includes checkbox-specific properties, such as text alignment, the state of the box being checked or unchecked, and any specific events related to the checkbox, such as the state of the checkbox changing from being checked to to unchecked change or vice versa.
每一控件还从父控件(ParentControl)(1505)继承特性，其中父控件可以是页面类型控件(Page)(1506)或面板类型控件(Panel)(1507)。页面类型控件(1506)具有各种特定的特性，诸如页面名称、指定的数据源、程序集(例如，隐藏代码等)、类型名称、以及诸如加载等任何其它事件等等。面板类型控件(1507)没有任何特定属性，而是具有用于控件的容器。Each control also inherits properties from a parent control (ParentControl) (1505), where the parent control may be a Page type control (Page) (1506) or a Panel type control (Panel) (1507). The page type control (1506) has various specific properties, such as page name, specified data source, assembly (eg, code behind, etc.), type name, and any other events such as load, etc. A panel type control (1507) does not have any specific properties, but has a container for the control.
如由图16所示，列表控件不同于其它控件之处在于列表控件具有指定用于列表的附加项目的子节点。每一列表控件如上所述还具有包括一系列基本特性和基本事件的基本控件类型(1601)。As shown by FIG. 16, the list control differs from other controls in that the list control has child nodes designated for additional items of the list. Each list control also has a basic control type (1601) that includes a series of basic properties and basic events as described above.
列表控件类型(ListControl)(1602)包括一组特定特性，诸如显示成员路径、所选值路径、所选值、项目源、以及所选索引。列表控件类型具有将列表样式指定为组合框类型(ComboBox)(1603)、列表框类型(ListBox)(1604)以及单选按钮列表类型(RadioButtonList)(1605)中的任一种的进一步的类型。The list control type (ListControl) (1602) includes a specific set of properties, such as display member path, selected value path, selected value, item source, and selected index. The list control type has a further type specifying a list style as any one of a combo box type (ComboBox) (1603), a list box type (ListBox) (1604), and a radio button list type (RadioButtonList) (1605).
组合框类型(1603)具有指定下拉样式框的特定特性。列表框类型(1604)具有用于列表的选择模式的特定特性。单选按钮列表类型(1605)具有用于指定的单选按钮的特定特性。The combo box type (1603) has specific properties that specify a drop-down style box. The list box type (1604) has specific properties for the selection mode of the list. The Radio Button List Type (1605) has specific properties for specified radio buttons.
UI表单的格式可由元数据以使得表单中使用的布局和控件极其灵活的方式来完整地定义。例如，可如上所述地添加、移除或转换各种控件和字段/值对。可由元数据的隐藏代码程序集部分中的代码来定义事件处理程序，使得来自事件处理程序的默认行为可被覆盖。由于程序集的名称和位置可在元数据中捕捉，因此对控件的事件的处理是非常灵活的。因此，UI表单上的控件的数据源和特性字段之间的绑定可按需从数据源到表单或从控件特性到数据源来指定。所有这些特征都由接收元数据并呈现UI的呈现引擎支持。The format of a UI form can be completely defined by metadata in a way that makes the layout and controls used in the form extremely flexible. For example, various controls and field/value pairs can be added, removed, or transformed as described above. Event handlers can be defined by code in the code-behind assembly section of the metadata so that the default behavior from the event handler can be overridden. Because the name and location of the assembly can be captured in the metadata, the handling of the control's events is very flexible. Thus, bindings between data sources and property fields of controls on UI forms can be specified from data sources to forms or from control properties to data sources as desired. All of these features are supported by a rendering engine that receives metadata and renders the UI.
示例呈现引擎和绑定特征Example rendering engine and binding traits
用于呈现引擎的一个示例过程在图17中示出。UI表单在框1701处在元数据中指定。框1702表示UI呈现引擎，它从框1703-1711呈现来自UI表单的所有特征。一旦呈现了UI表单，提供输出，使得所生成的对象可在框1712处被主宿在任务面板中、在自定义表单上、或可结合生产性套件应用程序使用的任何其它所需的主宿区域中。An example process for the rendering engine is shown in FIG. 17 . The UI form is specified in metadata at block 1701 . Block 1702 represents the UI rendering engine, which renders all the features from the UI form from blocks 1703-1711. Once the UI form is rendered, output is provided so that the generated object can be hosted at block 1712 in a task panel, on a custom form, or any other desired hosting that can be used in conjunction with a productivity suite application in the area.
在框1703处，UI呈现引擎解析该元数据，并标识其中所包含的各种控件。在包括框1705-1710的框1704处，呈现引擎实例化为UI定义的每一不同控件，并输出描述UI表单的控件。该输出用于在框1711处生成一组对象，其中每一对象可以用对诸如.NET控件对象等宿主可接受的形式来表示。At block 1703, the UI rendering engine parses the metadata and identifies the various controls contained therein. At block 1704, which includes blocks 1705-1710, the rendering engine instantiates each of the different controls defined for the UI and outputs controls that describe the form of the UI. This output is used to generate a set of objects at block 1711, where each object can be represented in a form acceptable to a host, such as a .NET control object.
在框1705处，实例化一控件。在框1706处设置该控件的基本特性，并且在框1707处设置该控件的任何控件专用特性。在框1708处，呈现引擎订阅使控件正确运作所必需的任何控件事件。继续到框1709，呈现引擎向父控件的容器添加该控件，并且随后在框1710处确定诸如对于先前所讨论的列表类型控件是否需要任何子控件。对表单上的所有控件重复由框1705-1710指定的过程(1704)，直到呈现了该表单的所有对象。At block 1705, a control is instantiated. The basic properties of the control are set at block 1706 and any control-specific properties of the control are set at block 1707 . At block 1708, the rendering engine subscribes to any control events necessary for the control to function correctly. Continuing to block 1709, the rendering engine adds the control to the parent control's container, and then determines at block 1710 whether any child controls are required, such as for the list type controls discussed previously. The process specified by blocks 1705-1710 is repeated (1704) for all controls on the form until all objects of the form are rendered.
如先前所描述的，UI表单开发者可对发生在表单上的控件事件编写其自己的事件处理程序。为处理控件上的特定事件，在一个实施例中，解决方案开发者需要：开发一包含事件处理程序代码的隐藏代码程序集、在元数据中指定该隐藏代码程序集、以及指定处理对一控件的特定事件的事件处理程序(方法)名称(应当在该隐藏代码程序集中存在)。一个示例隐藏代码程序集如下在元数据中指定：As previously described, UI form developers can write their own event handlers for control events that occur on the form. To handle a specific event on a control, in one embodiment, the solution developer needs to: develop a code-behind assembly that contains the event handler code, specify the code-behind assembly in metadata, and specify handling for a control The event handler (method) name for the specific event of , which should exist in this code-behind assembly. An example code-behind assembly is specified in metadata as follows:
<jaml:Page Load＝″PageLoad″Name＝″My Custom Page″<jaml:Page Load="PageLoad"Name="My Custom Page"
xmlns:jaml＝″urn-Mendocino/jaml″Top＝″0″Left＝″0″Width＝″320″Height＝″400″xmlns:jaml="urn-Mendocino/jaml"Top="0"Left="0"Width="320"Height="400"
Assembly＝″CodeBehind，Version＝1.0.0.0，Culture＝neutral，PublicKeyToken＝null″Assembly="CodeBehind, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"
TypeName＝″CodeBehind.PageCodeBehind″>TypeName="CodeBehind.PageCodeBehind">
在一个实施例中，该隐藏代码程序集是由UI元数据文件中的“Page”(页面)元素的“Assembly”(程序集)属性来指定的。“Page”元素不是元数据文件中的根元素。“TypeName”(类型名称)属性指定了该程序集中包含事件处理程序方法的类。在一个实施例中，每一“Page”或UI表单仅有一个包含用于该表单上的控件的所有事件处理程序的隐藏代码程序集。In one embodiment, the code-behind assembly is specified by the "Assembly" attribute of the "Page" element in the UI metadata file. The 'Page' element is not the root element in the metadata file. The TypeName attribute specifies the class in this assembly that contains the event handler method. In one embodiment, each "Page" or UI form has only one code-behind assembly that contains all event handlers for the controls on that form.
为在元数据中指定用于一控件上的事件的事件处理程序，在一个实施例中，该事件处理程序方法应当在该隐藏代码程序集中作为对应于该控件上的事件的属性的值存在。例如，捕捉按钮(Button)控件上的“Click”(点击)事件所需的元数据可如下指定：To specify an event handler for an event on a control in metadata, in one embodiment, the event handler method should exist in the code-behind assembly as the value of a property corresponding to the event on the control . For example, the metadata required to capture a "Click" event on a Button control can be specified as follows:
<jaml:Button Left＝″8″Width＝″100″Top＝″132″Background＝″Control″<jaml:Button Left="8"Width="100"Top="132"Background="Control"
Name＝″button1″Text＝″This is a button″Click＝″Button1_Click″/>Name="button1"Text="This is a button"Click="Button1_Click"/>
以上元数据指定了对于按钮控件的“Click”事件由方法“Button1_Click”来处理，该方法应当作为一公用方法在隐藏代码程序集中存在。并且，在一个实施例中，该事件处理程序的签名与在.NET Winforms环境中该特定控件上的事件的签名相同。用于按钮上的点击事件的一个示例事件处理程序签名可表达如下：public void Button1_Click(object sender，System.EventArgs e){}The above metadata specifies that the "Click" event for the button control is handled by the method "Button1_Click", which should exist as a public method in the code-behind assembly. And, in one embodiment, the signature of the event handler is the same as the signature of the event on that particular control in the .NET Winforms environment. An example event handler signature for a click event on a button could be expressed as follows: public void Button1_Click(object sender, System.EventArgs e){}
在一个实施例中，UI呈现引擎在解析UI元数据并实例化隐藏代码类(通过反射(reflection))时加载该隐藏代码程序集。在如上所述解析UI元数据期间实例化一控件时订阅该控件上的所有事件(通过元数据来展示)。由此，当一特定事件由来自代码中的事件处理程序的控件引发时，使用该隐藏代码程序集中存在的事件处理程序。用于处理事件所必需的必要自变量通过反射来传递。In one embodiment, the UI rendering engine loads the code-behind assembly when it parses the UI metadata and instantiates the code-behind class (via reflection). Subscribe to all events on a control (exposed through metadata) when it is instantiated during parsing UI metadata as described above. Thus, when a particular event is raised by a control from an event handler in code, the event handler present in the code-behind assembly is used. The necessary arguments necessary to handle the event are passed through reflection.
如上所述，当数据来自一指定数据源时，数据可被绑定到UI表单上的控件。数据源在元数据中诸如通过以下示例来指定：As described above, data can be bound to controls on UI forms when the data comes from a specified data source. Data sources are specified in metadata such as by example:
Data Source<jaml:DataSource Name＝″myDataSource″Data Source<jaml:DataSource Name="myDataSource"
Assembly＝″DataSourceAssembly，Version＝1.0.0.0，Culture＝neutral，Assembly="DataSourceAssembly, Version=1.0.0.0, Culture=neutral,
PublicKeyToken＝null″PublicKeyToken=null"
TypeName＝″DataSourceNamespace.DataSourceClass″/>TypeName="DataSourceNamespace.DataSourceClass"/>
“DataSourceClass”(数据源类)可以实现“IBindData”(绑定数据)和“INotifyPropertyChanged”(通知特性改变)接口，如下："DataSourceClass" (data source class) can implement "IBindData" (binding data) and "INotifyPropertyChanged" (notification property change) interfaces, as follows:
public interface IBindDatapublic interface IBindData
{{
object GetData(string path)；object GetData(string path);
bool SetData(string path，object val)；bool SetData(string path, object val);
}}
public interface INotifyPropertyChangedpublic interface INotifyPropertyChanged
{{
event PropertyChangedEventHandler PropertyChanged；event PropertyChangedEventHandler PropertyChanged;
}}
public delegate void PropertyChangedEventHandler(object sender，public delegate void PropertyChangedEventHandler(object sender,
PropertyChangedEventArgs e)；PropertyChangedEventArgs e);
public class PropertyChangedEventArgs:System.EventArgspublic class PropertyChangedEventArgs:System.EventArgs
{{
public virtual string PropertyName{get；}public virtual string PropertyName{get;}
}}
“IBindData”接口允许数据在数据源和控件特性之间绑定。在一个实施例中，“INotifyPropertyChanged”接口允许数据源用信号表示在该数据源上发生的任何改变，使得被绑定到该数据源的UI特性可被更新。由此，数据源需要一当数据源中的特性改变时就引发“PropertyChanged”(特性改变)事件。事件处理程序代码一当事件激发就更新UI上的相关特性。The "IBindData" interface allows data binding between data sources and control properties. In one embodiment, the "INotifyPropertyChanged" interface allows a data source to signal any changes that occur on the data source so that UI properties bound to the data source can be updated. Thus, the data source needs to raise a "PropertyChanged" event whenever a property in the data source changes. The event handler code updates the relevant properties on the UI as soon as the event fires.
一旦在元数据中指定了数据源，则在一个实施例中，可将控件的任何特性绑定到来自一数据源的数据。图18示出了可用于指定到一控件特性的数据绑定的各种特性。指定了标识数据源(1802)、用于数据源的路径(1803)、用于绑定的模式(1804)以及用于数据源的触发器(1805)的绑定(1801)。必须指定绑定表达式以便能正确创建控件特性绑定。Once the data source is specified in the metadata, in one embodiment, any property of the control can be bound to data from a data source. Figure 18 shows the various properties that can be used to specify data binding to a control property. A binding (1801) identifying a data source (1802), a path for the data source (1803), a schema for the binding (1804), and a trigger for the data source (1805) is specified. Binding expressions must be specified in order to correctly create control property bindings.
在一个示例中，通过将“绑定表达式”指定为对应于控件特性的属性的值来对控件特性指定绑定。例如，为绑定文本框控件的“Text”(文本)特性，可如下在元数据中表达一绑定表达式：In one example, a binding is specified on a control property by specifying a "binding expression" as the value of a property corresponding to the control property. For example, to bind the "Text" property of a textbox control, a binding expression can be expressed in metadata as follows:
<jaml:TextBox Name＝″textBox1″Top＝″40″Left＝″8″Width＝″200″<jaml:TextBox Name="textBox1"Top="40"Left="8"Width="200"
Text＝″{Binding Source＝DataSourceName，Path＝CustomerName，Text = "{Binding Source = DataSourceName, Path = CustomerName,
Mode＝TwoWay}″Anchor＝″Top，Left，Right″/>Mode=TwoWay}"Anchor="Top, Left, Right"/>
对于此示例，表达式Text＝“{Binding Source＝DataSourceName，Path＝CustomerName，Mode＝TwoWay}”是用于“Text”特性的绑定表达式。“Source”(源)子句表示元数据中定义的数据源。“Path”(路径)子句指定的值在检索绑定特性的值时被传递给数据源的“GetData(string path)”(获取数据)方法。“Mode”子句指示绑定类型为“TwoWay”(双向)，这表明来自UI的特性改变可被传回数据源，反之亦然。在另一实施例中，当绑定被指定为“OneWay”(单向)时，来自数据源的改变只能传播到UI控件。For this example, the expression Text="{Binding Source=DataSourceName, Path=CustomerName, Mode=TwoWay}" is the binding expression for the "Text" attribute. The "Source" clause indicates the data source defined in the metadata. The value specified by the "Path" clause is passed to the data source's "GetData(string path)" method when retrieving the value of the bound property. The "Mode" clause indicates that the binding type is "TwoWay" (two-way), which means that property changes from the UI can be communicated back to the data source and vice versa. In another embodiment, when the binding is specified as "OneWay", changes from the data source can only be propagated to the UI controls.
图18所示的“UpadteSourceTrigger”(更新源触发器)可用于指定用信号通知数据源UI特性已改变的，并且改变的特性值需要被传播到数据源的事件。默认地，该子句的值可被设为“PropertyChanged”(特性已改变)，这意味着当一绑定特性改变时，它将被以信号通知给数据源。在某些实施例中，“PropertyChanged”子句仅在使用双向绑定时才生效。"UpadteSourceTrigger" shown in FIG. 18 can be used to specify an event that signals the data source that a UI property has changed, and that the changed property value needs to be propagated to the data source. By default, the value of this clause may be set to "PropertyChanged", which means that when a bound property changes, it will be signaled to the data source. In some embodiments, the "PropertyChanged" clause only takes effect when using two-way binding.
可对参与数据绑定的所有控件定义IBindable(可绑定)接口。一示例接口被定义为：An IBindable (bindable) interface can be defined on all controls that participate in data binding. An example interface is defined as:
public interface IBindablepublic interface IBindable
{{
object GetBoundValue(string propName)；object GetBoundValue(string propName);
void SetBoundValue(string propName，object val)；void SetBoundValue(string propName, object val);
}}
绑定器可被实现为UI呈现引擎的一部分，或被实现为一独立组件。一示例绑定器可维护在元数据中指定的所有数据源的列表，以及元数据中的所有绑定的列表。最初，当呈现UI表单时，调用用于相关数据源的“GetData(stringpath)”方法(在绑定表达式中指定)，并传入绑定表达式中的“Path”子句的值作为自变量。该方法返回类型为“object”(对象)的值。对其特性被绑定的控件调用“SetBoundValue(string propName，object value)”(设置绑定值)，并传入绑定特性的名称和由数据源返回的“value”(值)。该控件负责理解“value”对象并解释它以适当地更新绑定特性。A binder can be implemented as part of the UI rendering engine, or as a separate component. An example binder may maintain a list of all data sources specified in metadata, and a list of all bindings in metadata. Initially, when the UI form is rendered, the "GetData(stringpath)" method for the associated data source (specified in the binding expression) is called, passing in the value of the "Path" clause in the binding expression as the variable. This method returns a value of type "object" (object). Call "SetBoundValue(string propName, object value)" (set bound value) on the control whose property is bound, passing in the name of the bound property and the "value" returned by the data source. The control is responsible for understanding the "value" object and interpreting it to update the bound property appropriately.
除了UI表单的最初呈现之外，只要数据源改变，数据源就可使用(INotifyPropertyChanged)(通知特性改变)事件来向绑定器通知数据源的改变。绑定器标识哪些控件特性被绑定到改变的数据源并相应地更新这些特性。In addition to the initial rendering of the UI form, whenever the data source changes, the data source can use the (INotifyPropertyChanged) (notify property change) event to notify the binder of the data source change. The binder identifies which control properties are bound to the changed data source and updates those properties accordingly.
如上所述，还可利用自定义控件。自定义控件可如上所述地派生。在一个示例中，应定义以下接口：自定义控件应从类“System.Windows.Forms.UserControl”派生，实现“IBindable”接口使得自定义控件参与数据绑定，实现“ICustomControl”(自定义控件)接口，定义用于该控件的默认构造函数(无自变量)。一个示例自定义控件定义如下：As mentioned above, custom controls can also be utilized. Custom controls can be derived as described above. In one example, the following interfaces should be defined: The custom control should be derived from the class "System.Windows.Forms.UserControl", implement the "IBindable" interface to enable the custom control to participate in data binding, implement the "ICustomControl" (custom control) interface , which defines the default constructor (with no arguments) for the control. An example custom control is defined as follows:
public interface ICustomControlpublic interface ICustomControl
{{
void SetControlProperty(string propName，string propValue)；void SetControlProperty(string propName, string propValue);
event ControlEventFiredHandler ControlEventFired；event ControlEventFiredHandler ControlEventFired;
}}
public delegate void ControlEventFiredHandler(object sender，public delegate void ControlEventFiredHandler(object sender,
ControlEventFiredArgs e)；ControlEventFiredArgs e);
public class ControlEventFiredArgs:System.EventArgspublic class ControlEventFiredArgs:System.EventArgs
{{
public string EventName{get；}public string EventName{get;}
public object Sender{get；}public object Sender{get;}
public object EventArgs{get；}public object EventArgs{get;}
}}
在一个实施例中，每一自定义控件实现“ICustomControl”接口，它具有方法“SetControlProperty()”(设置控件特性)和单个事件“ControlEventFired”(控件事件激发)。In one embodiment, each custom control implements the "ICustomControl" interface, which has a method "SetControlProperty()" (sets control properties) and a single event "ControlEventFired" (control event fires).
“SetControlProperty(string propName，string propValue)”方法可由UI呈现引擎框架用于为控件设置自定义特性。对该自定义控件展示且没有包括在该控件的基本特性(例如，Width、Height、Top、Left等)中的每一自定义特性，UI呈现引擎可调用自定义控件上的“SetControlProperty”方法。要求该自定义控件理解并解释在元数据中指定的“sring”(串)特性值，该特性将被传递给“SetControlProperty”方法。The "SetControlProperty(string propName, string propValue)" method can be used by the UI rendering engine framework to set custom properties for a control. For each custom property exhibited by the custom control and not included in the control's base properties (eg, Width, Height, Top, Left, etc.), the UI rendering engine may call the "SetControlProperty" method on the custom control. The custom control is required to understand and interpret the "sring" (string) property value specified in the metadata that will be passed to the "SetControlProperty" method.
“ControlEventFired”事件可由自定义控件在控件所展示的自定义事件被激发时引发。UI呈现引擎解释在自定义控件上激发了一事件并调用隐藏代码程序集(如果这一代码存在)中用于该事件的事件处理程序。UI呈现引擎在编译时不知道该自定义控件支持什么事件。相反，UI呈现引擎可要求自定义控件在该自定义控件上激发一自定义事件时通知呈现引擎。该自定义控件可创建“ControlEventFiredArgs”(控件事件激发自变量)类的实例，并将其传递给由UI引擎接收的“ControlEventFired”事件。“ControlEventFiredArgs”包含关于所激发的事件的名称的信息、标识发送者、并标识需要被传递给用于该事件的事件处理程序的任何事件自变量。一旦UI呈现引擎有了该信息，该呈现引擎就调用在隐藏代码程序集中指定的用于该事件的事件处理程序。The "ControlEventFired" event can be raised by a custom control when a custom event exhibited by the control is fired. The UI rendering engine interprets an event fired on the custom control and calls the event handler for that event in the code-behind assembly (if such code exists). The UI rendering engine does not know what events the custom control supports at compile time. Instead, the UI rendering engine may ask the custom control to notify the rendering engine when a custom event is fired on the custom control. The custom control can create an instance of the "ControlEventFiredArgs" (control event fired arguments) class and pass it to the "ControlEventFired" event received by the UI engine. "ControlEventFiredArgs" contains information about the name of the fired event, identifies the sender, and identifies any event arguments that need to be passed to the event handler for the event. Once the UI rendering engine has this information, the rendering engine calls the event handler for the event specified in the code-behind assembly.
在一个示例实施例中，自定义控件在运行时驻留在.NET程序集中。该自定义控件程序集可用以下方式在元数据内指定：In one example embodiment, the custom control resides in a .NET assembly at runtime. The custom control assembly can be specified within the metadata in the following ways:
<jaml:Mapping XmlNamespace＝″urn-Mendocino/CustomControls″<jaml:Mapping XmlNamespace="urn-Mendocino/CustomControls"
ClrNamespace＝″CustomControlNamespace″ClrNamespace="CustomControlNamespace"
Assembly＝″CustomControlAssembly，Version＝1.0.0.0，Culture＝neutral，Assembly="CustomControlAssembly, Version=1.0.0.0, Culture=neutral,
PublicKeyToken＝null″/>PublicKeyToken=null"/>
在一个实施例中，“Mapping”(映射)元素是从微软的WindowsPresentation Foundation(Windows演示基础，WPF)中取得的，但是它是一处理伪指令而非XML元素。自定义控件可通过以下元数据在元数据中指定：In one embodiment, the "Mapping" element is taken from Microsoft's Windows Presentation Foundation (WPF), but it is a processing directive rather than an XML element. Custom controls can be specified in metadata via the following metadata:
<custom:CustomControl xmlns:custom＝″urn-Mendocino/CustomControls″<custom:CustomControl xmlns:custom="urn-Mendocino/CustomControls"
Top＝″0″Left＝″0″Height＝″100″Width＝″100″.../>Top="0"Left="0"Height="100"Width="100".../>
在一个实施例中，UI呈现引擎通过反射实例化自定义控件，并首先设置控件的基本特性，如Height、Width、Top、Left等。然后，对于其它特性(自定义特性)，UI引擎可调用该自定义控件上的“SetControlProperty()”方法。In one embodiment, the UI presentation engine instantiates the custom control through reflection, and first sets the basic properties of the control, such as Height, Width, Top, Left, and so on. Then, for other properties (custom properties), the UI engine can call the "SetControlProperty()" method on the custom control.
UI表单开发者可如上所述地访问隐藏代码程序集中的UI控件及其特性。该隐藏代码类需要实现“IPageCodeBehind”(页面代码隐藏)接口。“IPageCodeBehind”接口的一个实施例被描述如下：A UI form developer can access the UI controls and their properties in the code-behind assembly as described above. The code-behind class needs to implement the "IPageCodeBehind" (page code-behind) interface. One embodiment of the "IPageCodeBehind" interface is described as follows:
public interface IPageCodeBehindpublic interface IPageCodeBehind
{{
IPageControlCollection PageControls{get；set；}IPageControlCollection PageControls { get; set; }
}}
“PageControls”特性可由UI呈现引擎在其呈现UI表单并实例化控件时填充。“IPageControlCollection”(页面控件集合)接口的一个实施例在以下定义：The "PageControls" property can be populated by the UI rendering engine when it renders the UI form and instantiates the controls. One embodiment of the "IPageControlCollection" (Page Control Collection) interface is defined below:
public interface IPageControlCollection:ICollection，IEnumerablepublic interface IPageControlCollection: ICollection, IEnumerable
{{
IPageControl this[string name]{get；}IPageControl this[string name]{get;}
}}
在一个实施例中，“IPageControl”接口展示用于表单上的控件的特性。In one embodiment, the "IPageControl" interface exposes properties for controls on forms.
public interface IPageControlpublic interface IPageControl
{//特性...{//characteristic...
string Name{get；set；}string Name { get; set; }
intTop{get；set；}intTop { get; set; }
int Left{get；set；}int Left { get; set; }
Color Background{get；set；}Color Background { get; set; }
bool IsEnabled{get；set；}bool IsEnabled { get; set; }
int Height{get；set；}int Height { get; set; }
int Width{get；set；}int Width { get; set; }
//其它特性//...}//other features//...}
上述实施例允许UI表单开发者用以下方式来访问表单上的控件：The foregoing embodiments allow UI form developers to access controls on the form in the following ways:
MessageBox.Show(this.PageControls[″myButton″].Text)；MessageBox. Show(this. PageControls[″myButton″]. Text);
在一个实施例中，“IPageControl”接口仅展示一控件的基本特性(对每一控件是共同的)。为访问用于一控件的特定特性(例如，对于复选框(CheckBox)控件的IsChecked(是否被复选))，可将“IPageControl”对象强制转换成如“IPageCheckBox”(页面复选框)、“IPageTextBox”(页面文本框)的特定控件接口。这允许访问用于一控件的特定特性。In one embodiment, the "IPageControl" interface exposes only the basic properties of a control (common to every control). To access specific properties for a control (e.g., IsChecked (checked or not) for a CheckBox control), the "IPageControl" object can be cast to something like "IPageCheckBox" (page check box), Specific control interface for "IPageTextBox" (page text box). This allows access to specific properties for a control.
((IPageCheckBox)this.PageControls[″myCheckBox″]).IsChecked((IPageCheckBox)this. PageControls[″myCheckBox″]).IsChecked
在一个实施例中，“IPageCheckBox”接口从“IPageControl”接口派生，如：In one embodiment, the "IPageCheckBox" interface is derived from the "IPageControl" interface, such as:
public interface IPageCheckBox:IPageControlpublic interface IPageCheckBox:IPageControl
{//CheckBox专用特性...{//CheckBox special features...
ContentAlignment TextAlignment{get；set；}ContentAlignment TextAlignment { get; set; }
bool IsChecked{get；set；}bool IsChecked { get; set; }
}}
类似地，展示用于每一控件的特定接口，这允许UI表单开发者访问控件专用特性。Similarly, a specific interface for each control is exposed, which allows UI form developers to access control-specific features.
UI呈现引擎可被安排成从描述UI表单的元数据生成相同的.NET控件，而不管该UI表单是被主宿在任务窗格还是生产性套件表单(例如，Outlook
任务窗格可被安排成支持主宿实现“IRegion”接口的任何.NET控件。UI呈现框架可被安排成包括实现“IRegion”(区域)接口并主宿了由UI呈现引擎从UI元数据生成的.NET控件的空白(空).NET控件。为在任务窗格中示出元数据定义的UI表单，可使用“MSIBF.UI.ShowRegion”自定义操作来显示UI呈现框架的该空白.NET宿主控件部分。传递给该“MSIBF.UI.ShowRegion”操作的输入是定义要被主宿在任务窗格中的UI表单的元数据。MSIBF.UI.ShowRegion操作可实例化空白的宿主.NET控件，并将定义UI表单的元数据作为“Data”(数据)传递给空白宿主.NET控件。宿主控件可被安排成调用UI呈现引擎组件，并传入定义该UI表单的元数据，且返回描述该UI表单的.NET控件，该控件然后被添加到宿主控件，使得UI表单在任务窗格中显示。Task panes can be arranged to support hosting any .NET control that implements the "IRegion" interface. The UI rendering framework may be arranged to include blank (empty) .NET controls implementing the "IRegion" interface and hosting .NET controls generated by the UI rendering engine from UI metadata. To show the metadata-defined UI form in the task pane, the "MSIBF.UI.ShowRegion" custom action can be used to display this blank .NET host control portion of the UI rendering framework. The input passed to the "MSIBF.UI.ShowRegion" operation is metadata defining the UI form to be hosted in the task pane. The MSIBF.UI.ShowRegion operation instantiates a blank host .NET control and passes metadata defining the UI form to the blank host .NET control as "Data". The host control can be arranged to call the UI rendering engine component, passing in metadata defining the UI form, and returning a .NET control describing the UI form, which is then added to the host control such that the UI form is displayed in the task pane displayed in .
在生产性套件中主宿描述诸如Outlook
尽管已经示出并描述了示例实施例和应用，但是可以理解，本发明不限于以上所描述的精确配置和资源。可以对此处所公开的方法和系统的排列、操作和细节作出本领域的技术人员显而易见的各种修改、改变和变型，而不背离本发明的范围。由于可在不背离本发明的精神和范围的前提下作出本发明的许多实施例，因此本发明归所附权利要求书。While example embodiments and applications have been shown and described, it is to be understood that the invention is not limited to the precise configurations and resources described above. Various modifications, changes and variations apparent to those skilled in the art may be made in the arrangement, operation and details of the methods and systems disclosed herein without departing from the scope of the invention. Since many embodiments of the invention can be made without departing from the spirit and scope of the invention, the invention resides in the claims hereinafter appended.
附录IAppendix I
示例同步请求模式Example synchronous request pattern
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema id＝″Microsoft.OBA.SynchronizationCreateRequest″<xs:schema id="Microsoft.OBA.SynchronizationCreateRequest"
targetNamespace＝″Microsoft.OBA.SynchronizationCreateRequest″targetNamespace="Microsoft.OBA.SynchronizationCreateRequest"
xmlns＝″Microsoft.OBA.SynchronizationCreateRequest″xmlns="Microsoft.OBA.SynchronizationCreateRequest"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″SynchronizationCreateRequest″><xs:element name="SynchronizationCreateRequest">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″CultureName″type＝″xs:string″/><xs:element name="CultureName"type="xs:string"/>
<xs:element name＝″BoundData″><xs:element name="BoundData">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:any minOccurs＝″0″namespace＝″##other″<xs:any minOccurs="0" namespace="##other"
processContents＝″skip″/>processContents="skip"/>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute name＝″RequestId″type＝″xs:string″/><xs:attribute name="RequestId"type="xs:string"/>
<xs:attribute name＝″BoundItemType″type＝″xs:string″/><xs:attribute name="BoundItemType"type="xs:string"/>
<xs:attribute name＝″BoundItemId″type＝″xs:string″/><xs:attribute name="BoundItemId"type="xs:string"/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
同步请求的实例示例Instance example of a synchronous request
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<SynchronizationCreateRequest RequestId＝″String″BoundItemType＝″String″<SynchronizationCreateRequest RequestId="String"BoundItemType="String"
BoundItemId＝″String″>BoundItemId="String">
<CultureName>String</CultureName><CultureName>String</CultureName>
<BoundData/><BoundData/>
</SynchronizationCreateRequest></SynchronizationCreateRequest>
示例更新请求模式Example update request schema
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema id＝″Microsoft.OBA.SynchronizationUpdateRequest″<xs:schema id="Microsoft.OBA.SynchronizationUpdateRequest"
targetNamespace＝″Microsoft.OBA.SynchronizationUpdateRequest″targetNamespace="Microsoft.OBA.SynchronizationUpdateRequest"
xmlns＝″Microsoft.OBA.SynchronizationUpdateRequest″xmlns="Microsoft.OBA.SynchronizationUpdateRequest"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″SynchronizationUpdateRequest″><xs:element name="SynchronizationUpdateRequest">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″CultureName″type＝″xs:string″/><xs:element name="CultureName"type="xs:string"/>
<xs:element name＝″NewBoundData″><xs:element name="NewBoundData">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:any minOccurs＝″0″namespace＝″##other″<xs:any minOccurs="0" namespace="##other"
processContents＝″skip″/>processContents="skip"/>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
<xs:element name＝″OldBoundData″><xs:element name="OldBoundData">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:any minOccurs＝″0″namespace＝″##other″<xs:any minOccurs="0" namespace="##other"
processContents＝″skip″/>processContents="skip"/>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute name＝″RequestId″type＝″xs:string″/><xs:attribute name="RequestId"type="xs:string"/>
<xs:attribute name＝″BoundItemType″type＝″xs:string″/><xs:attribute name="BoundItemType"type="xs:string"/>
<xs:attribute name＝″BoundItemId″type＝″xs:string″/><xs:attribute name="BoundItemId"type="xs:string"/>
<xs:attribute name＝″CorrelationI d″type＝″xs:string″/><xs:attribute name="CorrelationI d"type="xs:string"/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
更新请求的实例示例Instance example of update request
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<SynchronizationUpdateRequest RequestId＝″String″BoundItemType＝″String″<SynchronizationUpdateRequest RequestId="String"BoundItemType="String"
BoundItemId＝″String″CorrelationId＝″String″>BoundItemId="String"CorrelationId="String">
<CultureName>String</CultureName><CultureName>String</CultureName>
<NewBoundData/><NewBoundData/>
<OldBoundData/><OldBoundData/>
</SynchronizationUpdateRequest></SynchronizationUpdateRequest>
示例删除请求模式Example delete request schema
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema id＝″Microsoft.OBA.SynchronizationDeleteRequest″<xs:schema id="Microsoft.OBA.SynchronizationDeleteRequest"
targetNamespace＝″Microsoft.OBA.SynchronizationDeleteRequest″targetNamespace="Microsoft.OBA.SynchronizationDeleteRequest"
xmlns＝″Microsoft.OBA.SynchronizationDeleteRequest″xmlns="Microsoft.OBA.SynchronizationDeleteRequest"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″SynchronizationDeleteRequest″><xs:element name="SynchronizationDeleteRequest">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″CultureName″type＝″xs:string″/><xs:element name="CultureName"type="xs:string"/>
<xs:element name＝″BoundData″><xs:element name="BoundData">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:any minOccurs＝″0″namespace＝″##other″<xs:any minOccurs="0" namespace="##other"
processContents＝″skip″/>processContents="skip"/>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute name＝″RequestId″type＝″xs:string″/><xs:attribute name="RequestId"type="xs:string"/>
<xs:attribute name＝″BoundItemType″type＝″xs:string″/><xs:attribute name="BoundItemType"type="xs:string"/>
<xs:attribute name＝″BoundItemId″type＝″xs:string″/><xs:attribute name="BoundItemId"type="xs:string"/>
<xs:attribute name＝″CorrelationId″type＝″xs:string″/><xs:attribute name="CorrelationId"type="xs:string"/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
删除请求的实例示例Example of an instance of a delete request
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<SynchronizationDeleteRequest RequestId＝″String″BoundItemType＝″String″<SynchronizationDeleteRequest RequestId="String"BoundItemType="String"
BoundItemId＝″String″CorrelationId＝″String″>BoundItemId="String"CorrelationId="String">
<CultureName>String</CultureName><CultureName>String</CultureName>
<BoundData/><BoundData/>
</SynchronizationDeleteRequest></SynchronizationDeleteRequest>
示例同步响应模式Example synchronous response pattern
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema id＝″Microsoft.OBA.SynchronizationResponse″<xs:schema id="Microsoft.OBA.SynchronizationResponse"
targetNamespace＝″Microsoft.OBA.SynchronizationResponse″targetNamespace="Microsoft.OBA.SynchronizationResponse"
xmlns＝″Microsoft.OBA.SynchronizationResponse″xmlns="Microsoft.OBA.SynchronizationResponse"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″SynchronizationResponse″><xs:element name="SynchronizationResponse">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″BusinessStatus″type＝″xs:string″/><xs:element name="BusinessStatus"type="xs:string"/>
<xs:element name＝″Description″type＝″xs:string″/><xs:element name="Description" type="xs:string"/>
</xs:sequence></xs:sequence>
<xs:attribute name＝″RequestId″type＝″xs:string″/><xs:attribute name="RequestId"type="xs:string"/>
<xs:attribute name＝″CorrelationId″type＝″xs:string″/><xs:attribute name="CorrelationId"type="xs:string"/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
同步响应的实例示例Instance example of a synchronous response
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<SynchronizationResponse RequestId＝″String″CorrelationId＝″String″><SynchronizationResponse RequestId="String"CorrelationId="String">
<BusinessStatus>String</BusinessStatus><BusinessStatus>String</BusinessStatus>
<Description>String</Description><Description>String</Description>
</SynchronizationResponse></SynchronizationResponse>
示例查询结果模式Example query result schema
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema id＝″Microsoft.OBA.QueryResults″<xs:schema id="Microsoft.OBA.QueryResults"
targetNamespace＝″Microsoft.OBA.QueryResults″targetNamespace="Microsoft.OBA.QueryResults"
xmlns＝″Microsoft.OBA.QueryResults″xmlns="Microsoft.OBA.QueryResults"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″QueryResults″><xs:element name="QueryResults">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″QueryResult″minOccurs＝″0″<xs:element name="QueryResult" minOccurs="0"
maxOccurs＝″unbounded″>maxOccurs="unbounded">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″BoundData″><xs:element name="BoundData">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:any minOccurs＝″0″namespace＝″##other″<xs:any minOccurs=″0″namespace=″##other″
processContents＝″skip″/>processContents="skip"/>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute name＝″BoundItemId″type＝″xs:string″/><xs:attribute name="BoundItemId"type="xs:string"/>
<xs:attribute name＝″CorrelationId″type＝″xs:string″/><xs:attribute name="CorrelationId"type="xs:string"/>
<xs:attribute name＝″BoundItemType″type＝″xs:string″/><xs:attribute name="BoundItemType"type="xs:string"/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute name＝″RequestId″type＝″xs:string″/><xs:attribute name="RequestId"type="xs:string"/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
查询结果的实例示例Instance example of query result
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<QueryResults RequestId＝″String″><QueryResults RequestId="String">
<QueryResult BoundItemId＝″String″CorrelationId＝″String″<QueryResult BoundItemId="String"CorrelationId="String"
BoundItemType＝″String″>BoundItemType="String">
<BoundData/><BoundData/>
</QueryResult></QueryResult>
</QueryResults></QueryResults>
附录IIAppendix II
示例项目模式定义Example project schema definition
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema targetNamespace＝″http://tempuri.org/XML Schema.xsd″<xs:schema targetNamespace="http://tempuri.org/XML Schema.xsd"
elementFormDefault＝″qualified″xmlns＝″http://tempuri.org/XMLSchema.xsd″elementFormDefault="qualified"xmlns="http://tempuri.org/XMLSchema.xsd"
xmlns:mstns＝″http://tempuri.org/XMLSchema.xsd″xmlns:mstns="http://tempuri.org/XMLSchema.xsd"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″item″><xs:element name="item">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″properties″><xs:element name="properties">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″property″><xs:element name="property">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″target″><xs:element name="target">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
</xs:sequence></xs:sequence>
<xs:attribute na＝″name″type＝″xs:string″/><xs:attribute na=″name″type=″xs:string″/>
<xs:attribute name＝″caption″type＝″xs:string″/><xs:attribute name=″caption″type=″xs:string″/>
<xs:attribute name＝″type″type＝″xs:string″/><xs:attribute name=″type″type=″xs:string″/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
<xs:element name＝″mapping″><xs:element name=″mapping″>
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
</xs:sequence></xs:sequence>
<xs:attribute type＝″xs:string″name＝″xpath″/><xs:attribute type=″xs:string″name=″xpath″/>
<xs:attribute type＝″xs:string″name＝″behavior″/><xs:attribute type=″xs:string″name=″behavior”/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
<xs:element name＝″template″><xs:element name="template">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:any/><xs:any/>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute type＝″xs:string″name＝″name″/><xs:attribute type=″xs:string″name=″name″/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
示例example
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<item name＝″urn:timereporting:billabletime″><item name="urn:timereporting:billabletime">
<properties><properties>
<property><property>
<target name＝″BillableTime.ProjectCode″caption＝″Project Code″<target name="BillableTime.ProjectCode"caption="Project Code"
type＝″string″/>type="string"/>
<mapping xpath＝″/billableTime/@projectCode″<mapping xpath=″/billableTime/@projectCode″
behavior＝″promote″/>behavior="promote"/>
</property></property>
<property><property>
<target name＝″Start″caption＝″Start Date″type＝″string″/><target name="Start"caption="Start Date"type="string"/>
<mapping xpath＝″/billableTime/projectInfo/projectStart″<mapping xpath="/billableTime/projectInfo/projectStart"
behavior＝″both″/>behavior="both"/>
</property></property>
</properties></properties>
<template><template>
<billableTime projectCode＝″12345″><billableTime projectCode="12345">
<projectInfo><projectInfo>
<projectStart>2005-01-01</projectStart><projectStart>2005-01-01</projectStart>
<description>Project description goes here</description><description>Project description goes here</description>
</projectInfo></projectInfo>
</billableTime></billableTime>
</template></template>
</item></item>
行为Behavior
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema targetNamespace＝″http://tempuri.org/XMLSchema.xsd″<xs:schema targetNamespace="http://tempuri.org/XMLSchema.xsd"
elementFormDefault＝″qualified″xmlns＝″http://tempuri.org/XMLSchema.xsd″elementFormDefault="qualified"xmlns="http://tempuri.org/XMLSchema.xsd"
xmlns:mstns＝″http://tempuri.org/XMLSchema.xsd″xmlns:mstns="http://tempuri.org/XMLSchema.xsd"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″>xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name＝″behaviors″><xs:element name="behaviors">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″behavior″><xs:element name="behavior">
<xs:complexType><xs:complexType>
<xs:sequence><xs:sequence>
<xs:element name＝″prompt″><xs:element name="prompt">
<xs:complexType><xs:complexType>
<xs:sequence/><xs:sequence/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
<xs:attribute name＝″type″type＝″xs:string″/><xs:attribute name="type" type="xs:string"/>
<xs:attribute name＝″enabled″type＝″xs:boolean″/><xs:attribute name=″enabled″type=″xs:boolean″/>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:sequence></xs:sequence>
</xs:complexType></xs:complexType>
</xs:element></xs:element>
</xs:schema></xs:schema>
示例example
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<behaviors><behaviors>
<behavior type＝″delete″enabled＝″false″><behavior type="delete" enabled="false">
<prompt>Sorry，you cannot delete this item.</prompt><prompt>Sorry, you cannot delete this item.</prompt>
</behavior></behavior>
<behavior type＝″moveToPst″enabled＝″true″><behavior type="moveToPst"enabled="true">
<prompt>Moving this item to a PST is not recommended.</prompt><prompt>Moving this item to a PST is not recommended.</prompt>
</behavior></behavior>
<behavior type＝″save″enabled＝″false″><behavior type="save" enabled="false">
<prompt>Sorry，you cannot save this item.</prompt><prompt>Sorry, you cannot save this item.</prompt>
</behavior></behavior>
<behavior type＝″copy″enabled＝″true″/><behavior type="copy" enabled="true"/>
</behaviors></behaviors>
附录IIIAppendix III
示例IWindow定义Example IWindow definition
using System；using System;
using System.Xml；using System.Xml;
using Microsoft.OBA.MetadataUIForms.Interfaces；using Microsoft.OBA.MetadataUIForms.Interfaces;
namespace Microsoft.OBA.OutlookExt.Interfacesnamespace Microsoft.OBA.OutlookExt.Interfaces
{{
///<summary>///<summary>
///描述包装的Outlook窗口，通常是检查器的行为/// Describes the wrapped Outlook window, usually the behavior of the inspector
///</summary>///</summary>
public interface IWindowpublic interface IWindow
{{
///<summary>///<summary>
///包装窗口的Win32句柄///Win32 handle of wrapper window
///</summary>///</summary>
IntPtr Handle{get；}IntPtr Handle { get; }
///<summary>///<summary>
///获取底层Outlook项目对象///Get the underlying Outlook item object
///</summary>///</summary>
object Native{get；}object Native{get;}
///<summary>///<summary>
///用此包装窗口显示绑定项目///Use this wrapper window to display bound items
///</summary>///</summary>
IBoundItem Item{get；}IBoundItem Item{get;}
///<summary>///<summary>
///绑定项目与此包装窗口相关联///The binding item is associated with this wrapper window
///</summary>///</summary>
IBoundItem AssociatedItem{get；}IBoundItem AssociatedItem{get;}
///<summary>///<summary>
///显示IBF窗格///Display the IBF pane
///</summary>///</summary>
///<param name＝″context″>选择描述窗格内容的元数据的IBF上下文信息///<param name="context">Select the IBF context information describing the metadata of the pane content
</param></param>
void ShowPane(XmlNode context)；void ShowPane(XmlNode context);
///<summary>///<summary>
///显示模态对话框///Show a modal dialog box
///</summary>///</summary>
///<param name＝″context″>选择描述对话框的元数据的IBF上下文信息///<param name="context">Select the IBF context information describing the metadata of the dialog box
</param></param>
///<returns></returns>///<returns></returns>
object ShowDialog(XmlNode context)；object object ShowDialog(XmlNode context);
///<summary>///<summary>
///只要创建新的XAML呈现器引擎就由窗口管理器服务调用/// Called by the window manager service whenever a new XAML renderer engine is created
///</summary>///</summary>
///<param name＝″xamlPage″>到新创建的XAML页面的接口</param>///<param name=″xamlPage″>The interface to the newly created XAML page</param>
void RegisterPage(IXamlPage xamlPage)；void RegisterPage(IXamlPage xamlPage);
///<summary>///<summary>
///获取按照其名称在元数据中指定的工具栏/菜单按钮///Get the toolbar/menu button specified in the metadata by its name
///为获取正确的控件，确保所有解决方案控件具有唯一且非空名称/// To get the correct controls, ensure that all solution controls have unique and non-empty names
///将返回值强制转换成Microsoft.Office.Core.CommandBarControl来使用它///Forcibly convert the return value to Microsoft.Office.Core.CommandBarControl to use it
///如果不能找到控件则返回空///If the control cannot be found, return empty
///</summary>///</summary>
///<param name＝″name″>解决方案控件的名称</param>///<param name="name">The name of the solution control</param>
object GetControl(string name)；object GetControl(string name);
}}
}}
示例IWindowCodeBehind定义Example IWindowCodeBehind definition
using System；using System;
using Microsoft.OBA.MetadataUIForms.Interfaces；using Microsoft.OBA.MetadataUIForms.Interfaces;
namespace Microsoft.OBA.OutlookExt.Interfacesnamespace Microsoft.OBA.OutlookExt.Interfaces
{{
public interface IWindowCodeBehindpublic interface IWindowCodeBehind
{{
///<summary>///<summary>
///当打开检查器窗口并在元数据中指定相关联的隐藏代码程序集时调用该///Called when the inspector window is opened and the associated code-behind assembly is specified in the metadata
方法 method
///</summary>///</summary>
///<param name＝″window″>初始化IWindow</param>///<param name=″window″>Initialize IWindow</param>
void OnInit(IWindow window，IServiceProvider serviceProvider)；void OnInit(IWindow window, IServiceProvider serviceProvider);
///<summary>///<summary>
///当选择一自定义解决方案控件时调用该方法///This method is called when a custom solution control is selected
///</summary>///</summary>
///<param name＝″name″>在SolutionControls XML中定义的解决方案控件的///<param name="name">The solution control defined in SolutionControls XML
名称</param>name</param>
///<param name＝″param″>在SolutionControls XML中定义的参数</param>///<param name=″param″>Parameters defined in SolutionControls XML</param>
void OnSelectControl(string name，string param)；void OnSelectControl(string name, string param);
///<summary>///<summary>
///当用户点击检查器窗口中一不同的Outlook选项卡时调用该方法///This method is called when the user clicks on a different Outlook tab in the inspector window
///</summary>///</summary>
///<param name＝″index″>所选择的选项卡的基于零的次序</param>///<param name="index">Zero-based order of selected tabs</param>
///<param name＝″name″>在XAML页面中指定的选项卡的名称</param>///<param name="name">The name of the tab specified in the XAML page</param>
///<param name＝″caption″>在XAML页面中指定的选项卡的文字说明((为///<param name=″caption″>The text description of the tab specified in the XAML page ((for
文本) )</param>text) )</param>
void OnSelectTab(int index，string name，string caption)；void OnSelectTab(int index, string name, string caption);
///<summary>///<summary>
///当为此窗口创建一新的XAML引擎包装器时调用该方法///This method is called when a new XAML engine wrapper is created for this window
///</summary>///</summary>
///<param name＝″xamlPage″>创建IXamlPage</param>///<param name=″xamlPage″>Create IXamlPage</param>
void OnNewPage(IXamlPage xamlPage)；void OnNewPage(IXamlPage xamlPage);
}}
}}
示例IBoundItem定义Example IBoundItem definition
using System；using System;
using System.Xml；using System.Xml;
using System.ComponentModel；using System. ComponentModel;
namespace Microsoft.OBA.OutlookExt.Interfacesnamespace Microsoft.OBA.OutlookExt.Interfaces
{{
////<summary>////<summary>
///用于PropertyErrorEvent的自变量///Argument for PropertyErrorEvent
///</summary>///</summary>
public sealed class PropertyErrorEventArgs:EventArgspublic sealed class PropertyErrorEventArgs:EventArgs
{{
private bool isXpathError；private bool isXpathError;
private string propertyName；private string propertyName;
private PropertyType type；private PropertyType type;
private string propertyValue；private string propertyValue;
private string xPath；private string xPath;
public PropertyErrorEventArgs(bool isXpathError，string propertyName， public PropertyErrorEventArgs(bool isXpathError, string propertyName,
PropertyType type，object propertyValue，string xPath)PropertyType type, object propertyValue, string xPath)
{{
this.isXpathError＝isXpathError； this.isXpathError = isXpathError;
this.propertyName＝propertyName； this.propertyName=propertyName;
if(propertyValue！＝null)If(propertyValue!=null)
this.propertyValue＝propertyValue.ToString()； this.propertyValue=propertyValue.ToString();
elseelse
this.propertyValue＝string.Empty； this.propertyValue=string.Empty;
this.type＝type； this.type=type;
this.xPath＝xPath； this.xPath = xPath;
}}
public bool IsXpathErrorpublic bool IsXpathError
{{
getget
{{
return isXpathError；return isXpathError;
}}
}}
public string PropertyNamepublic string PropertyName
{{
getget
{{
return propertyName；return propertyName;
}}
}}
public string PropertyValuepublic string PropertyValue
{{
getget
{{
return propertyValue；return propertyValue;
}}
}}
public string XPathpublic string XPath
{{
getget
{{
return xPath；return xPath;
}}
}}
public PropertyType Typepublic PropertyType Type
{{
getget
{{
return type；return type;
}}
}}
}}
///<summary>///<summary>
///包装Outlook项目，根据BoundItemDefinition提供对映射特性的访问/// Wraps the Outlook item, providing access to the mapped properties according to the BoundItemDefinition
///</summary>///</summary>
public interface IBoundItem:IDisposablepublic interface IBoundItem:IDisposable
{{
///<summary>///<summary>
///绑定项目的ID，如果未找到项目则为空/// The ID of the bound item, or empty if no item is found
///</summary>///</summary>
string BoundItemIdstring BoundItemId
{{
get；get;
}}
///<summary>///<summary>
///绑定项目的ID，由LOB系统定义///The ID of the bound item, defined by the LOB system
///可能为空，仅当与BoundItemType一起使用时才是唯一的///May be empty, unique only when used with BoundItemType
///</summary>///</summary>
string CorrelationIdstring CorrelationId
{{
get；get;
}}
///<summary>///<summary>
///包装项目的类型，等价于BoundItemDefinition的名称。///The type of packaging item, which is equivalent to the name of BoundItemDefinition.
///如果项目未绑定则为空/// Empty if the item is not bound
///</summary>///</summary>
string BoundItemTypestring BoundItemType
{{
get；get;
}}
///<summary>///<summary>
///绑定的定义///Definition of binding
///</summary>///</summary>
BoundItemDefinition BoundItemDefinitionBoundItemDefinition BoundItemDefinition
{{
get；get;
}}
///<summary>///<summary>
///绑定项目的同步状态///The synchronization state of the binding item
///</summary>///</summary>
SynchronizationStatus SynchronizationStatusSynchronizationStatus SynchronizationStatus
{{
get；get;
}}
///<summary>///<summary>
///绑定项目的业务状态///Binding the business status of the project
///</summary>///</summary>
string BusinessStatusstring BusinessStatus
{{
get；get;
}}
///<summary>///<summary>
///绑定项目的业务描述///Business description of the binding project
///</summary>///</summary>
string BusinessDescriptionstring BusinessDescription
{{
get；get;
}}
///<summary>///<summary>
///包装Outlook项目/// Wrap Outlook items
///</summary>///</summary>
object OutlookItemobject OutlookItem
{{
get；get;
}}
///<summary>///<summary>
///包装的Outlook项目的EntryId///EntryId of the wrapped Outlook item
///</summary>///</summary>
string EntryIdstring EntryId
{{
get；get;
}}
///<summary>///<summary>
///包装的Outlook项目的MessageClass/// The MessageClass of the wrapped Outlook item
///</summary>///</summary>
string MessageClassstring MessageClass
{{
get；get;
}}
///<summary>///<summary>
///包装的Outlook项目的LastModified时戳///The LastModified timestamp of the wrapped Outlook item
///</summary>///</summary>
DateTime LastModifiedDateTime LastModified
{{
get；get;
}}
///<summary>///<summary>
///映射的特性，作为XML串///Map properties, as an XML string
///</summary>///</summary>
string XmlDatastring XmlData
{{
get；get;
set；set;
}}
///<summary>///<summary>
///映射的特性，作为加密的XML串///Map properties, as an encrypted XML string
///</summary>///</summary>
string BoundDatastring BoundData
{{
get；get;
}}
///<summary>///<summary>
///构建并返回映射的特性，作为XmlDocument；/// Build and return the mapped properties as an XmlDocument;
///XML被保持与Outlook域同步///XML is kept in sync with the Outlook fields
///</summary>///</summary>
///<returns>Mapped properties.</returns>///<returns>Mapped properties.</returns>
XmlDocument GetXmlDocument()；XmlDocument GetXmlDocument();
///<summary>///<summary>
///按照名称返回映射的特性的值///Returns the value of the mapped attribute by name
///</summary>///</summary>
///<param name＝″propName″>特性名称</param>///<param name="propName">property name</param>
///<returns>特性值</returns>///<returns>Characteristic value</returns>
object GetProperty(string name)；object GetProperty(string name);
///<summary>///<summary>
///按照名称改变映射的特性的值///Change the value of the mapped property by name
///</summary>///</summary>
///<param name＝″name″>特性名称</param>///<param name="name">Characteristic name</param>
///<param name＝″value″>特性值</param>///<param name="value">Characteristic value</param>
void SetProperty(string name，object value)；void SetProperty(string name, object value);
///<summary>///<summary>
///当特性值改变时引发/// Fired when the property value changes
///</summary>///</summary>
event PropertyChangedEventHandler PropertyChanged；event PropertyChangedEventHandler PropertyChanged;
///<summary>///<summary>
///当在向特性分配值时发生错误时引发/// Raised when an error occurs while assigning a value to the attribute
///</summary>///</summary>
event EventHandler<PropertyErrorEventArgs>PropertyError；event EventHandler<PropertyErrorEventArgs>PropertyError;
///<summary>///<summary>
///对照来自BoundItemDefinition的XML模式确认包含映射特性的XML/// Validate the XML containing the mapping property against the XML schema from the BoundItemDefinition
///</summary>///</summary>
void Validate()；void Validate();
///<summary>///<summary>
///确认映射特性并保存Outlook项目///Confirm the mapping properties and save the Outlook item
///</summary>///</summary>
void Save()；void Save();
///<summary>///<summary>
///在XML文档和Outlook域(UserProperties)之间同步映射特性的值///Synchronize the value of the mapping property between the XML document and the Outlook field (UserProperties)
///在必要时重新创建遗漏的Outlook域/// Recreate missing Outlook fields if necessary
///不保存Outlook项目；显式调用Save/// Do not save the Outlook item; call Save explicitly
///</summary>///</summary>
void PromoteProperties()；void PromoteProperties();
///<summary>///<summary>
///根据BoundItemDefinition移除所有的自定义Outlook域(UserProperties)///Remove all custom Outlook fields according to BoundItemDefinition (UserProperties)
///</summary>///</summary>
void RemoveProperties()；void RemoveProperties();
///<summary>///<summary>
///将Outlook项目转换成绑定项目///Convert the Outlook item into a bound item
///</summary>///</summary>
void BindItem(string definition)；void BindItem(string definition);
///<summary>///<summary>
///将Outlook项目转换成绑定项目///Convert Outlook items into bound items
///</summary>///</summary>
void BindItem(BoundItemDefinition definition)；void BindItem(BoundItemDefinition definition);
///<summary>///<summary>
///解除Outlook项目的绑定///Unbind the Outlook item
///</summary>///</summary>
void UnbindItem()；void UnbindItem();
}}
}}
示例IBoundItemManager定义Example IBoundItemManager definition
using System；using System;
using System.Collections.Generic；using System.Collections.Generic;
using System.Text；using System. Text;
namespace Microsoft.OBA.OutlookExt.Interfacesnamespace Microsoft.OBA.OutlookExt.Interfaces
{{
public interface IBoundItemManagerpublic interface IBoundItemManager
{{
IBoundItem CreateBoundItem(string boundItemType)；IBoundItem CreateBoundItem(string boundItemType);
IBoundItem CreateBoundItem(BoundItemDefinition definition)；IBoundItem CreateBoundItem(BoundItemDefinition definition);
IBoundItem GetBoundItem(object item)；IBoundItem GetBoundItem(object item);
IBoundItem GetBoundItem(string boundItemId)；IBoundItem GetBoundItem(string boundItemId);
IBoundItem GetBoundItem(string boundItemType，string correlationId)；IBoundItem GetBoundItem(string boundItemType, string correlationId);
IBoundItem GetBoundItem(BoundItemDefinition definition，string correlationId)；IBoundItem GetBoundItem(BoundItemDefinition definition, string correlationId);
}}
}}
示例CodeBehindDefintionsExample CodeBehindDefintions
using System；using System;
using System.Xml.Serialization；using System.Xml.Serialization;
namespace Microsoft.OBA.OutlookExt.Interfacesnamespace Microsoft.OBA.OutlookExt.Interfaces
{{
[SerializableAttribute()][SerializableAttribute()]
[XmlTypeAttribute(AnonymousType＝true)][XmlTypeAttribute(AnonymousType=true)]
[XmlRootAttribute(Namespace＝[XmlRootAttribute(Namespace＝
″http://schemas.microsoft.com/OBA/2005/CodeBehindDefininition″，IsNullable＝false)]"http://schemas.microsoft.com/OBA/2005/CodeBehindDefininition", IsNullable=false)]
public partial class CodeBehindDefinitionpublic partial class CodeBehindDefinition
{{
private string assemblyNameField；private string assemblyNameField;
private string typeNameField；private string typeNameField;
[XmlAttributeAttribute()][XmlAttributeAttribute()]
public string AssemblyNamepublic string AssemblyName
{{
getget
{{
return this.assemblyNameField； return this.assemblyNameField;
}}
setset
{{
this.assemblyNameField＝value；** this.assemblyNameField=value;
}}
}}
[XmlAttributeAttribute()][XmlAttributeAttribute()]
public string TypeNamepublic string TypeName
{{
getget
{{
return this.typeNameField；`` `` return this.typeNameField;
}}
setset
{{
this.typeNameField＝value； this.typeNameField=value;
}}
}}
}}
}}
示例BoundItemDefinitionExample BoundItemDefinition
using System；using System;
using System.Collections；using System. Collections;
using System.Collections.Generic；using System.Collections.Generic;
using System.Diagnostics；using System.Diagnostics;
using System.Xml；using System.Xml;
using System.Xml.Schema；using System.Xml.Schema;
using System.Xml.Serialization；using System.Xml.Serialization;
using System.Text.RegularExpressions；using System.Text.RegularExpressions;
namespace Microsoft.OBA.OutlookExt.Interfacesnamespace Microsoft.OBA.OutlookExt.Interfaces
{{
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
[XmlRoot(Namespace＝[XmlRoot(Namespace＝
″http://schemas.microsoft.com/OBA/2005/BoundItemDefinition″，IsNullable＝false)]"http://schemas.microsoft.com/OBA/2005/BoundItemDefinition", IsNullable=false)]
public sealed class BoundItemDefinitionpublic sealed class BoundItemDefinition
{{
private OutlookItemDefinition outlookField；private OutlookItemDefinition outlookField;
private SynchronizationDefinition synchronizationField；private SynchronizationDefinition synchronizationField;
private MappedProperties propertiesField；private MappedProperties propertiesField;
private EventBehaviorCollection eventBehaviorsField；private EventBehaviorCollection eventBehaviorsField;
[NonSerialized][NonSerialized]
private XmlElement xmlTemplateField；private XmlElement xmlTemplateField;
private string nameField；private string nameField;
[NonSerialized][NonSerialized]
private XmlNamespaceManager namespaceManager；private XmlNamespaceManager namespaceManager;
//用于解析XML名称空间的正则表达式//Regular expression for parsing XML namespaces
//格式为：前缀＝′名称空间′[；前缀＝′名称空间′[；前缀＝′名称空间′[...]]]//The format is: prefix='namespace'[;prefix='namespace'[;prefix='namespace'[...]]]
private const string nameSpaceRegExpression＝″[；][^＝；]+[＝][′][^′]*[′]″；private const string nameSpaceRegExpression = ″[;][^=;]+[=][′][^′]*[′]″;
public BoundItemDefinition()public BoundItemDefinition()
{{
outlookField＝new OutlookItemDefinition()；outlookField = new OutlookItemDefinition();
synchronizationField＝new SynchronizationDefinition()；synchronizationField = new SynchronizationDefinition();
propertiesField＝new MappedProperties()；propertiesField = new MappedProperties();
eventBehaviorsField＝new EventBehaviorCollection()；eventBehaviorsField = new EventBehaviorCollection();
namespaceManager＝null；namespaceManager = null;
}}
public OutlookItemDefinition Outlookpublic OutlookItemDefinition Outlook
{{
getget
{{
return this.outlookField；return this. outlookField;
}}
setset
{{
this.outlookField＝value；` this.outlookField=value;
}}
}}
public SynchronizationDefinition Synchronizationpublic SynchronizationDefinition Synchronization
{{
getget
{{
return this.synchronizationField；return this.synchronizationField;
}}
setset
{{
this.synchronizationField＝value； this.synchronizationField = value;
}}
}}
[XmlArray][XmlArray]
[XmlArrayItem(″EventBehavior″，IsNullable＝false)][XmlArrayItem("EventBehavior", IsNullable=false)]
public EventBehaviorCollection EventBehaviorspublic EventBehaviorCollection EventBehaviors
{{
getget
{{
return this.eventBehaviorsField；return this.eventBehaviorsField;
}}
}}
[XmlArray][XmlArray]
[XmlArrayItem(″Property″，IsNullable＝false)][XmlArrayItem("Property", IsNullable=false)]
public MappedProperties Propertiespublic MappedProperties Properties
{{
getget
{{
return this.propertiesField；return this.propertiesField;
}}
}}
[XmlIgnore][XmlIgnore]
public XmlNamespaceManager XmlNamespaceManagerpublic XmlNamespaceManager XmlNamespaceManager
{{
getget
{{
return namespaceManager；return namespaceManager;
}}
}}
[XmlIgnore][XmlIgnore]
public XmlSchemaSet XmlSchemaSetpublic XmlSchemaSet XmlSchemaSet
{{
getget
{{
return new XmlSchemaSet()；return new XmlSchemaSet();
}}
}}
public XmlElement XmlTemplatepublic XmlElement XmlTemplate
{{
getget
{{
return this.xmlTemplateField； return this.xmlTemplateField;
}}
setset
{{
Exception exception＝null；Exception exception=null;
trytry
{{
XmlDocument xmldoc＝new XmlDocument()；XmlDocument xmldoc = new XmlDocument();
string uri＝String.Empty；String uri = String.Empty;
string prefix＝String.Empty；String prefix = String.Empty;
if(value ！＝null)If(value !=null)
{{
xmldoc.AppendChild(xmldoc.ImportNode(value，true))；xmldoc. AppendChild(xmldoc. ImportNode(value, true));
namespaceManager＝new namespaceManager＝new
XmlNamespaceManager(xmldoc.NameTable)；XmlNamespaceManager(xmldoc. NameTable);
uri＝xmldoc.DocumentElement.NamespaceURI； uri = xmldoc.DocumentElement.NamespaceURI;
prefix＝Prefix=
xmldoc.DocumentElement.GetPrefixOfNamespace(uri)；xmldoc.DocumentElement.GetPrefixOfNamespace(uri);
namespaceManager.AddNamespace(prefix，uri)； namespaceManager. AddNamespace(prefix, uri);
this.xmlTemplateField＝xmldoc.DocumentElement； this.xmlTemplateField=xmldoc.DocumentElement;
//将来自Xml元素的名称空间添加到特性上//Add the namespace from the Xml element to the attribute
foreach(MappedProperty mappedProperty in Properties)foreach(MappedProperty mappedProperty in Properties)
{{
string namespaces＝mappedProperty.Xml.Namespaces； string namespaces=mappedProperty.Xml.Namespaces;
ParseXmlNamespaces(namespaces，namespaceManager)；ParseXmlNamespaces(namespaces, namespaceManager);
} }
} }
}}
//捕获特定异常而非一般异常//Catch specific exceptions instead of general exceptions
catch(ArgumentException ex)catch(ArgumentException ex)
{{
//捕获ArgumentNullException以及//Catch ArgumentNullException and
ArgumentOutOfRangeExceptionArgumentOutOfRangeException
exception＝ex；exception=ex;
}}
catch(InvalidOperationException ex)catch(InvalidOperationException ex)
{{
exception＝ex；exception=ex;
}}
catch(NullReferenceException ex)catch(NullReferenceException ex)
{{
exception＝ex；exception=ex;
}}
if(exception！＝null)If(exception!=null)
{{
Debug.Assert(false，exception.ToString())； Debug.Assert(false, exception.ToString());
this.xmlTemplateField＝null；** this.xmlTemplateField=null;
namespaceManager＝null；namespaceManager=null;
}}
}}
}}
[XmlAttribute][XmlAttribute]
public string Namepublic string Name
{{
getget
{{
return this.nameField；return this.nameField;
}}
setset
{{
this.nameField＝value；`` this.nameField=value;
}}
}}
public static void ParseXmlNamespaces(string namespaces，public static void ParseXmlNamespaces(string namespaces,
XmlNamespaceManager namespaceManager)XmlNamespaceManager namespaceManager)
{{
Debug.Assert(namespaceManager！＝null)； Debug.Assert(namespaceManager!=null);
if(！string.IsNullOrEmpty(namespaces))If(!string.IsNullOrEmpty(namespaces))
{{
//创建新Regex对象并定义正则表达式//Create a new Regex object and define a regular expression
string regexInput＝″；″+namespaces； string regexInput=″;″+namespaces;
Regex regex＝new Regex(nameSpaceRegExpression)； Regex regex = new Regex(nameSpaceRegExpression);
//找到输入串中的全部匹配//Find all matches in the input string
MatchCollection matchCollection＝regex.Matches(regexInput)； MatchCollection matchCollection = regex. Matches(regexInput);
Debug.Assert(matchCollection.Count＞0)； Debug.Assert(matchCollection.Count＞0);
//循环通过匹配集合以检索所有匹配//Loop through the match collection to retrieve all matches
for(int i＝0；i＜matchCollection.Count；i++)for(int i=0; i<matchCollection.Count; i++)
{{
string prefixAndUriStr＝matchCollection[i].Value.Substring(1)； string prefixAndUriStr=matchCollection[i].Value.Substring(1);
string[]prefixAndUri＝prefixAndUriStr.Split(′＝′)；String[] prefixAndUri = prefixAndUriStr.Split('=');
string prefix＝prefixAndUri[0]； string prefix=prefixAndUri[0];
string uri＝prefixAndUriStr.Substring(prefix.Length+1)； string uri = prefixAndUriStr.Substring(prefix.Length+1);
uri＝uri.Trim(′\″)；uri=uri.Trim(′\″);
if(namespaceManager！＝null)If(namespaceManager!=null)
namespaceManager.AddNamespace(prefix，uri)； namespaceManager. AddNamespace(prefix, uri);
}}
}}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public class MappedProperties:IEnumerable<MappedProperty>public class MappedProperties:IEnumerable<MappedProperty>
{{
private SortedList<string，MappedProperty>properties；private SortedList<string, MappedProperty>properties;
private SortedList<string，MappedProperty>propertiesByOutlookName；private SortedList<string, MappedProperty>propertiesByOutlookName;
public MappedProperties()public MappedProperties()
{{
properties＝new SortedList<string，MappedProperty>()；properties = new SortedList<string, MappedProperty>();
propertiesByOutlookName＝new SortedList<string，MappedProperty>()；propertiesByOutlookName = new SortedList<string, MappedProperty>();
}}
public MappedProperty this[int index]public MappedProperty this[int index]
{{
getget
{{
//对XML串行化是必需的//Required for XML serialization
return properties.Values[index]；Return properties. Values[index];
}}
}}
public MappedProperty this[string name]public MappedProperty this[string name]
{{
getget
{{
return properties[name]；return properties[name];
}}
}}
public void Add(MappedProperty property)public void Add(MappedProperty property)
{{
if(propertiesByOutlookName.ContainsKey(property.Outlook.Name))if(propertiesByOutlookName.ContainsKey(property.Outlook.Name))
throw new ArgumentException(″property″，property.Outlook.Name)；throw new ArgumentException("property", property.Outlook.Name);
properties.Add(property.Name，property)；properties.Add(property.Name, property);
//构建Outlook名称到此处的特性的映射//Construct a mapping from the Outlook name to the attributes here
propertiesByOutlookName.Add(property.Outlook.Name，property)；propertiesByOutlookName.Add(property.Outlook.Name, property);
}}
public MappedProperty GetByOutlookName(string name)public MappedProperty GetByOutlookName(string name)
{{
return propertiesByOutlookName[name]；return propertiesByOutlookName[name];
}}
public bool TryToGetByOutlookName(string name，out MappedProperty copy)public bool TryToGetByOutlookName(string name, out MappedProperty copy)
{{
return propertiesByOutlookName.TryGetValue(name，out copy)；return propertiesByOutlookName. TryGetValue(name, out copy);
}}
public bool ContainsKey(string name)public bool ContainsKey(string name)
{{
return properties.ContainsKey(name)；return properties.ContainsKey(name);
}}
public bool ContainsOutlookName(string name)public bool ContainsOutlookName(string name)
{{
return propertiesByOutlookName.ContainsKey(name)；return propertiesByOutlookName.ContainsKey(name);
}}
#region IEnumerable<MappedProperty>Members#region IEnumerable<MappedProperty>Members
public IEnumerator<MappedProperty>GetEnumerator()public IEnumerator<MappedProperty>GetEnumerator()
{{
return properties.Values.GetEnumerator()；return properties. Values. GetEnumerator();
}}
#endregion#endregion
#region IEnumerable Members#region IEnumerable Members
IEnumerator IEnumerable.GetEnumerator()IEnumerator IEnumerable. GetEnumerator()
{{
return properties.Values.GetEnumerator()；return properties. Values. GetEnumerator();
}}
#endregion#endregion
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public class EventBehaviorCollection:IEnumerable<EventBehavior>public class EventBehaviorCollection:IEnumerable<EventBehavior>
{{
private SortedList<EventBehaviorType，EventBehavior>eventbehaviors；private SortedList<EventBehaviorType, EventBehavior> eventbehaviors;
public EventBehaviorCollection()public EventBehaviorCollection()
{{
eventbehaviors＝new SortedList<EventBehaviorType，EventBehavior>()；eventbehaviors = new SortedList<EventBehaviorType, EventBehavior>();
}}
public EventBehavior this[int index]public EventBehavior this[int index]
{{
getget
{{
//对XML串行化是必需的//Required for XML serialization
return eventbehaviors.Values[index]； return eventbehaviors. Values[index];
}}
}}
public EventBehavior this[EventBehaviorType type]public EventBehavior this[EventBehaviorType type]
{{
getget
{{
trytry
{{
return eventbehaviors[type]；return eventbehaviors[type];
}}
catch(System.Collections.Generic.KeyNotFoundException)catch(System.Collections.Generic.KeyNotFoundException)
{{
return null；return null;
}}
}}
}}
public void Add(EventBehavior eventBehavior)public void Add(EventBehavior eventBehavior)
{{
eventbehaviors.Add(eventBehavior.Type，eventBehavior)；eventbehaviors.Add(eventBehavior.Type, eventBehavior);
}}
#region IEnumerable<MappedProperty>Members#region IEnumerable<MappedProperty>Members
public IEnumerator<EventBehavior>GetEnumerator()public IEnumerator<EventBehavior>GetEnumerator()
{{
return eventbehaviors.Values.GetEnumerator()；return eventbehaviors.Values.GetEnumerator();
}}
#endregion#endregion
#region IEnumerable Members#region IEnumerable Members
IEnumerator IEnumerable.GetEnumerator()IEnumerator IEnumerable. GetEnumerator()
{{
return eventbehaviors.Values.GetEnumerator()； return eventbehaviors. Values. GetEnumerator();
}}
#endregion#endregion
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public sealed class OutlookItemDefinitionpublic sealed class OutlookItemDefinition
{{
private string defaultFolderField；private string defaultFolderField;
private string messageClassField；private string messageClassField;
[XmlAttribute][XmlAttribute]
public string DefaultFolderpublic string DefaultFolder
{{
getget
{{
return this.defaultFolderField； return this.defaultFolderField;
}}
setset
{{
this.defaultFolderField＝value； this.defaultFolderField=value;
}}
}}
[XmlAttribute][XmlAttribute]
public string MessageClasspublic string MessageClass
{{
getget
{{
return this.messageClassField； return this. messageClassField;
}}
setset
{{
this.messageClassField＝value；`` this.messageClassField=value;
}}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public sealed class SynchronizationDefinitionpublic sealed class SynchronizationDefinition
{{
private SynchronizationBehavior synchronizationBehaviorField；private SynchronizationBehavior synchronizationBehaviorField;
private string pastOnlyField；private string pastOnlyField;
public SynchronizationBehavior Behaviorpublic SynchronizationBehavior Behavior
{{
getget
{{
return this.synchronizationBehaviorField； return this.synchronizationBehaviorField;
}}
setset
{{
this.synchronizationBehaviorField＝value； this.synchronizationBehaviorField=value;
}}
}}
public string PastOnlypublic string PastOnly
{{
getget
{{
return this.pastOnlyField； return this.pastOnlyField;
}}
setset
{{
this.pastOnlyField＝value；`` this.pastOnlyField=value;
}}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public enum SynchronizationBehaviorpublic enum SynchronizationBehavior
{{
Always，Always,
PastOnly，PastOnly,
Never，Never,
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public sealed class EventBehaviorpublic sealed class EventBehavior
{{
private EventBehaviorType type；private EventBehaviorType type;
private bool enabled；private bool enabled;
private string prompt；private string prompt;
public string Promptpublic string Prompt
{{
get{return prompt；}get{return prompt;}
set{prompt＝value；} set{prompt=value;}
}}
[XmlAttribute][XmlAttribute]
public EventBehaviorType Typepublic EventBehaviorType Type
{{
get{return type；}get{return type;}
set{type＝value；} set{type=value;}
}}
[XmlAttribute][XmlAttribute]
public bool Enabledpublic bool Enabled
{{
get{return enabled；}get{return enabled;}
set{enabled＝value；} set{enabled=value;}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public sealed class MappedPropertypublic sealed class MappedProperty
{{
private MappingBehavior mappingBehaviorField；private MappingBehavior mappingBehaviorField;
private OutlookProperty outlookPropertyField；private OutlookProperty outlookPropertyField;
private MappingDefinition mappingDefinitionField；private MappingDefinition mappingDefinitionField;
private string nameField；private string nameField;
private PropertyType typeField；private PropertyType typeField;
///<summary>///<summary>
///如果应使用Outlook域来读取特性值而非XML则返回真///Returns true if the Outlook field should be used to read the attribute value instead of XML
///</summary>///</summary>
[XmlIgnore][XmlIgnore]
public bool IsOutlookPropertypublic bool IsOutlookProperty
{{
getget
{{
Debug.Assert(Outlook！＝null)；Debug.Assert(Outlook!=null);
Debug.Assert(Xml ！＝null)；Debug. Assert(Xml != null);
switch(Behavior)switch(Behavior)
{{
case MappingBehavior.OutlookOnly:case MappingBehavior.OutlookOnly:
Debug.Assert(！String.IsNullOrEmpty(Outlook.Name))；Debug.Assert(!String.IsNullOrEmpty(Outlook.Name));
Debug.Assert(Xml.XPath＝＝null)；Debug.Assert(Xml.XPath==null);
return true；return true;
case MappingBehavior.OutlookToXml:case MappingBehavior.OutlookToXml:
case MappingBehavior.ReadOnlyOutlookToXml:case MappingBehavior.ReadOnlyOutlookToXml:
Debug.Assert(！String.IsNullOrEmpty(Outlook.Name))；Debug.Assert(!String.IsNullOrEmpty(Outlook.Name));
Debug.Assert(Xml.XPath！＝null)；Debug.Assert(Xml.XPath!=null);
return true；return true;
case MappingBehavior.ReadOnlyXmlToOutlook:case MappingBehavior.ReadOnlyXmlToOutlook:
case MappingBehavior.XmlToOutlook:case MappingBehavior.XmlToOutlook:
Debug.Assert(！String.IsNullOrEmpty(Outlook.Name))；Debug.Assert(!String.IsNullOrEmpty(Outlook.Name));
Debug.Assert(Xml.XPath！＝null)；Debug.Assert(Xml.XPath!=null);
return false；return false;
case MappingBehavior.XmlOnly:case MappingBehavior.XmlOnly:
Debug.Assert(String.IsNullOrEmpty(Outlook.Name))；Debug.Assert(String.IsNullOrEmpty(Outlook.Name));
Debug.Assert(Xml.XPath！＝null)；Debug.Assert(Xml.XPath!=null);
return false；return false;
default:default:
Debug.Assert(false)；Debug. Assert(false);
return false；return false;
}}
}}
}}
public MappingBehavior Behaviorpublic MappingBehavior Behavior
{{
getget
{{
return this.mappingBehaviorField；return this.mappingBehaviorField;
}}
setset
{{
this.mappingBehaviorField＝value； this.mappingBehaviorField=value;
}}
}}
[XmlAttribute][XmlAttribute]
public string Namepublic string Name
{{
getget
{{
return this.nameField；return this.nameField;
}}
setset
{{
this.nameField＝value；` this.nameField=value;
}}
}}
[XmlAttribute][XmlAttribute]
public PropertyType Typepublic PropertyType Type
{{
getget
{{
return this.typeField；return this. typeField;
}}
setset
{{
this.typeField＝value；`` this.typeField=value;
}}
}}
public OutlookProperty Outlookpublic OutlookProperty Outlook
{{
getget
{{
return this.outlookPropertyField； return this. outlookPropertyField;
}}
setset
{{
this.outlookPropertyField＝value； this.outlookPropertyField=value;
}}
}}
public MappingDefinition Xmlpublic MappingDefinition Xml
{{
getget
{{
return this.mappingDefinitionField； return this.mappingDefinitionField;
}}
setset
{{
this.mappingDefinitionField＝value； this.mappingDefinitionField=value;
}}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public sealed class OutlookPropertypublic sealed class OutlookProperty
{{
private string outlookPropertyNameField；private string outlookPropertyNameField;
[XmlAttribute][XmlAttribute]
public string Namepublic string Name
{{
getget
{{
return this.outlookPropertyNameField；return this.outlookPropertyNameField;
}}
setset
{{
this.outlookPropertyNameField＝value； this.outlookPropertyNameField=value;
}}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public sealed class MappingDefinitionpublic sealed class MappingDefinition
{{
private string xPathField；private string xPathField;
private string namespacesField；private string namespacesField;
[XmlAttribute][XmlAttribute]
public string XPathpublic string XPath
{{
getget
{{
return this.xPathField； return this.xPathField;
}}
setset
{{
this.xPathField＝value；`` this.xPathField=value;
}}
}}
[XmlAttribute][XmlAttribute]
public string Namespacespublic string Namespaces
{{
getget
{{
return this.namespacesField； return this.namespacesField;
}}
setset
{{
this.namespacesField＝value； this.namespacesField=value;
}}
}}
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public enum MappingBehaviorpublic enum MappingBehavior
{{
XmlOnly，XmlOnly,
XmlToOutlook，XmlToOutlook,
ReadOnlyXmlToOutlook，ReadOnlyXmlToOutlook,
OutlookOnly，OutlookOnly,
OutlookToXml，OutlookToXml,
ReadOnlyOutlookToXml，ReadOnlyOutlookToXml,
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public enum EventBehaviorTypepublic enum EventBehaviorType
{{
Delete，Delete,
MoveToPst，MoveToPst,
Save，Save,
Copy，Copy,
}}
[Serializable][Serializable]
[XmlType(AnonymousType＝true)][XmlType(AnonymousType=true)]
public enum PropertyTypepublic enum PropertyType
{{
Integer＝1，Integer=1,
DateTime＝2，DateTime=2,
Decimal＝3，Decimal=3,
Boolean＝4，Boolean=4,
String＝5，String=5,
DistributionListMembers＝0，DistributionListMembers=0,
}}
}}
附录IVAppendix IV
用于定义UI表单的示例元数据模式Example metadata schema for defining UI forms
<？xml version＝″1.0″encoding＝″utf-8″？><? xml version = "1.0" encoding = "utf-8"? >
<xs:schema targetNamespace＝″urn-Mendocino/jaml″<xs:schema targetNamespace="urn-Mendocino/jaml"
elementFormDefault＝″qualified″elementFormDefault="qualified"
xmlns:jaml＝″urn-Mendocino/jaml″xmlns:jaml="urn-Mendocino/jaml"
xmlns:xs＝″http://www.w3.org/2001/XMLSchema″> xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:complexType name＝″ControlType″><xs:complexType name="ControlType">
<xs:attributeGroup ref＝″jaml:ControlTypeAttributes″/><xs:attributeGroup ref="jaml:ControlTypeAttributes"/>
</xs:complexType></xs:complexType>
<xs:complexType name＝″ParentControlType″><xs:complexType name="ParentControlType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:sequence><xs:sequence>
<xs:element ref＝″jaml:Control″minOccurs＝″0″<xs:element ref="jaml:Control" minOccurs="0"
maxOccurs＝″unbounded″/>maxOccurs="unbounded"/>
</xs:sequence></xs:sequence>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″PageType″><xs:complexType name="PageType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ParentControlType″><xs:extension base="jaml:ParentControlType">
<xs:sequence><xs:sequence>
<xs:element ref＝″jaml:DataSource″minOccurs＝″0″<xs:element ref="jaml:DataSource" minOccurs="0"
maxOccurs＝″unbounded″/>maxOccurs="unbounded"/>
</xs:sequence></xs:sequence>
<！-- 事件 --><! -- event -->
<xs:attribute name＝″Load″type＝″xs:string″use＝″optional″/><xs:attribute name="Load" type="xs:string"use="optional"/>
<！-- 隐藏代码程序集 --><! -- code-behind assembly -->
<xs:attribute name＝″Assembly″type＝″xs:string″use＝″optional″/><xs:attribute name="Assembly"type="xs:string"use="optional"/>
<xs:attribute name＝″TypeName″type＝″xs:string″use＝″optional″<xs:attribute name="TypeName" type="xs:string"use="optional"
/>/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″DataSourceType″><xs:complexType name="DataSourceType">
<xs:attribute name＝″Name″type＝″xs:string″use＝″required″/><xs:attribute name="Name"type="xs:string"use="required"/>
<!-- 数据源程序集 --><!-- Data Source Assembly -->
<xs:attribute name＝″Assembly″type＝″xs:string″use＝″optional″/><xs:attribute name="Assembly"type="xs:string"use="optional"/>
<xs:attribute name＝″TypeName″type＝″xs:string″use＝″optional″/><xs:attribute name="TypeName"type="xs:string"use="optional"/>
</xs:complexType></xs:complexType>
<xs:complexType name＝″PanelType″><xs:complexType name="PanelType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ParentControlType″><xs:extension base="jaml:ParentControlType">
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″LabelType″><xs:complexType name="LabelType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″TextAlignment″type＝″xs:string″<xs:attribute name=″TextAlignment″type=″xs:string″
use＝″optional″/>use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″TextBoxType″><xs:complexType name="TextBoxType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″TextAlignment″type＝″xs:string″<xs:attribute name="TextAlignment" type="xs:string"
use＝″optional″/>use="optional"/>
<xs:attribute name＝″MaxLength″type＝″xs:string″use＝″optional″<xs:attribute name="MaxLength"type="xs:string"use="optional"
/>/>
<xs:attribute name＝″MinLines″type＝″xs:string″use＝″optional″/><xs:attribute name="MinLines"type="xs:string"use="optional"/>
<xs:attribute name＝″Wrap″type＝″xs:string″use＝″optional″/><xs:attribute name="Wrap"type="xs:string"use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″ButtonType″><xs:complexType name="ButtonType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″TextAlignment″type＝″xs:string″<xs:attribute name="TextAlignment" type="xs:string"
use＝″optional″/>use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″LinkLabelType″><xs:complexType name="LinkLabelType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″TextAlignment″type＝″xs:string″<xs:attribute name="TextAlignment" type="xs:string"
use＝″optional″/>use="optional"/>
<xs:attribute name＝″LinkBehavior″type＝″xs:string″<xs:attribute name="LinkBehavior" type="xs:string"
use＝″optional″/>use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″ImageType″><xs:complexType name="ImageType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″Source″type＝″xs:string″use＝″required″/><xs:attribute name="Source"type="xs:string"use="required"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″CheckBoxType″><xs:complexType name="CheckBoxType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″TextAlignment″type＝″xs:string″<xs:attribute name="TextAlignment" type="xs:string"
use＝″optional″/>use="optional"/>
<xs:attribute name＝″IsChecked″type＝″xs:string″use＝″optional″/><xs:attribute name="IsChecked"type="xs:string"use="optional"/>
<！-- 事件 --><! -- event -->
<xs:attribute name＝″IsCheckedChanged″type＝″xs:string″<xs:attribute name="IsCheckedChanged" type="xs:string"
use＝″optional″/>use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<！-- 列表控件类型 --><! -- list control type -->
<xs:complexType name＝″ListControlType″><xs:complexType name="ListControlType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ControlType″><xs:extension base="jaml:ControlType">
<xs:attribute name＝″DisplayMemberPath″type＝″xs:string″<xs:attribute name="DisplayMemberPath"type="xs:string"
use＝″optional″/>use="optional"/>
<xs:attribute name＝″SelectedValuePath″type＝″xs:string″<xs:attribute name="SelectedValuePath"type="xs:string"
use＝″optional″/>use="optional"/>
<xs:attribute name＝″SelectedValue″type＝″xs:string″<xs:attribute name="SelectedValue" type="xs:string"
use＝″optional″/>use="optional"/>
<xs:attribute name＝″ItemsSource″type＝″xs:string″use＝″optional″<xs:attribute name="ItemsSource"type="xs:string"use="optional"
/>/>
<xs:attribute name＝″SelectedIndex″type＝″xs:string″<xs:attribute name="SelectedIndex" type="xs:string"
use＝″optional″/>use="optional"/>
<！-- 事件 --><! -- event -->
<xs:attribute name＝″SelectionChanged″type＝″xs:string″<xs:attribute name="SelectionChanged" type="xs:string"
use＝″optional″/>use="optional"/>
<！--<! --
<xs:sequence><xs:sequence>
<xs:element ref＝″jaml:ListControlItem″minOccurs＝″0″<xs:element ref="jaml:ListControlItem" minOccurs="0"
maxOccurs＝″unbounded″/>maxOccurs="unbounded"/>
</xs:sequence></xs:sequence>
-->-->
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<！--<xs:element name＝″ListControl″type＝″jaml:ListControlType″<! --<xs:element name="ListControl" type="jaml:ListControlType"
abstract＝″true″/>-->abstract="true"/>-->
<xs:simpleType name＝″ListControlItemType″><xs:simpleType name="ListControlItemType">
<xs:restriction base＝″xs:string″><xs:restriction base=″xs:string″>
</xs:restriction></xs:restriction>
</xs:simpleType></xs:simpleType>
<xs:element name＝″ListControlItem″type＝″jaml:ListControlItemType″<xs:element name="ListControlItem"type="jaml:ListControlItemType"
abstract＝″true″/>abstract="true"/>
<xs:element name＝″ListBoxItem ″type＝″jaml:ListControlItemType″<xs:element name="ListBoxItem"type="jaml:ListControlItemType"
substitutionGroup＝″jaml:ListControlItem″/>substitutionGroup="jaml:ListControlItem"/>
<xs:element name＝″ComboBoxItem″type＝″jaml:ListControlItemType″<xs:element name="ComboBoxItem"type="jaml:ListControlItemType"
substitutionGroup＝″jaml:ListControlItem″/>substitutionGroup="jaml:ListControlItem"/>
<xs:element name＝″RadioButton″type＝″jaml:ListControlItemType″<xs:element name="RadioButton"type="jaml:ListControlItemType"
substitutionGroup＝″jaml:ListControlItem″/>substitutionGroup="jaml:ListControlItem"/>
<xs:complexType name＝″ListBoxType″><xs:complexType name="ListBoxType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ListControlType″><xs:extension base="jaml:ListControlType">
<xs:sequence><xs:sequence>
<xs:element ref＝″jaml:ListBoxItem″minOccurs＝″0″<xs:element ref="jaml:ListBoxItem" minOccurs="0"
maxOccurs＝″unbounded″/>maxOccurs="unbounded"/>
</xs:sequence></xs:sequence>
<xs:attribute name＝″SelectionMode″type＝″xs:string″<xs:attribute name=″SelectionMode″type=″xs:string″
use＝″optional″/>use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″ComboBoxType″><xs:complexType name="ComboBoxType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ListControlType″><xs:extension base="jaml:ListControlType">
<xs:sequence><xs:sequence>
<xs:element ref＝″jaml:ComboBoxItem″minOccurs＝″0″<xs:element ref="jaml:ComboBoxItem" minOccurs="0"
maxOccurs＝″unbounded″/> maxOccurs="unbounded"/>
</xs:sequence></xs:sequence>
<xs:attribute name＝″DropDownStyle″type＝″xs:string″<xs:attribute name=″DropDownStyle″type=″xs:string″
use＝″optional″/>use="optional"/>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<xs:complexType name＝″RadioButtonListType″><xs:complexType name="RadioButtonListType">
<xs:complexContent><xs:complexContent>
<xs:extension base＝″jaml:ListControlType″><xs:extension base=″jaml:ListControlType″>
<xs:sequence><xs:sequence>
<xs:element ref＝″jaml:RadioButton″minOccurs＝″0″<xs:element ref="jaml:RadioButton" minOccurs="0"
maxOccurs＝″unbounded″/>maxOccurs="unbounded"/>
</xs:sequence></xs:sequence>
</xs:extension></xs:extension>
</xs:complexContent></xs:complexContent>
</xs:complexType></xs:complexType>
<！-- UI元素 --><! -- UI elements -->
<xs:element name＝″Control″type＝″jaml:ControlType″abstract＝″true″/><xs:element name="Control"type="jaml:ControlType"abstract="true"/>
<xs:element name＝″Page″type＝″jaml:PageType″<xs:element name="Page" type="jaml:PageType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″DataSource″type＝″jaml:DataSourceType″/><xs:element name="DataSource"type="jaml:DataSourceType"/>
<xs:element name＝″Panel″type＝″jaml:PanelType″<xs:element name="Panel" type="jaml:PanelType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″ListBox″type＝″jaml:ListBoxType″<xs:element name="ListBox" type="jaml:ListBoxType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″ComboBox″type＝″jaml:ComboBoxType″<xs:element name="ComboBox"type="jaml:ComboBoxType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″RadioButtonList″type＝″jaml:RadioButtonListType″<xs:element name="RadioButtonList"type="jaml:RadioButtonListType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″Label″type＝″jaml:LabelType″<xs:element name="Label" type="jaml:LabelType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″TextBox″type＝″jaml:TextBoxType″<xs:element name="TextBox" type="jaml:TextBoxType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″Button″type＝″jaml:ButtonType″<xs:element name="Button" type="jaml:ButtonType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″CheckBox″type＝″jaml:CheckBoxType″<xs:element name="CheckBox" type="jaml:CheckBoxType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″Image″type＝″jaml:ImageType″<xs:element name="Image" type="jaml:ImageType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<xs:element name＝″LinkLabel″type＝″jaml:LinkLabelType″<xs:element name="LinkLabel"type="jaml:LinkLabelType"
substitutionGroup＝″jaml:Control″/>substitutionGroup="jaml:Control"/>
<！-- 控件属性 --><! -- Control properties -->
<！-- 由于所有属性值都可实际上是绑定表达式，<! -- Since all property values can actually be binding expressions,
因此对每一属性的类型是xs:string -->So the type for each attribute is xs:string -->
<xs:attributeGroup name＝″ControlTypeAttributes″><xs:attributeGroup name="ControlTypeAttributes">
<！-- 特性 --><! -- Features -->
<！-Top和Left可以成为必需属性，<! -Top and Left can become required attributes,
但是使其为可任选的也是可以的 -->But it is also possible to make it optional -->
<xs:attribute name＝″Top″type＝″xs:string″default＝″0″use＝″optional″/><xs:attribute name="Top"type="xs:string"default="0"use="optional"/>
<xs:attribute name＝″Left″type＝″xs:string″default＝″0″use＝″optional″/><xs:attribute name="Left" type="xs:string" default="0"use="optional"/>
<xs:attribute name＝″Width″type＝″xs:string″use＝″optional″/><xs:attribute name="Width"type="xs:string"use="optional"/>
<xs:attribute name＝″Height″type＝″xs:string″use＝″optional″/><xs:attribute name="Height"type="xs:string"use="optional"/>
<xs:attribute name＝″Anchor″type＝″xs:string″use＝″optional″/><xs:attribute name="Anchor"type="xs:string"use="optional"/>
<！-- 此处可以具有指定的Anchor值的枚举<! -- An enumeration that can have the specified Anchor value here
但是由于这也可以是绑定表达式But since this can also be a binding expression
因此必须保留它为简单的串 -->So it must be kept as a simple string -->
<xs:attribute name＝″Background″type＝″xs:string″use＝″optional″/><xs:attribute name="Background"type="xs:string"use="optional"/>
<xs:attribute name＝″Foreground″type＝″xs:string″use＝″optional″/><xs:attribute name="Foreground"type="xs:string"use="optional"/>
<xs:attribute name＝″FontFamily″type＝″xs:string″use＝″optional″/><xs:attribute name="FontFamily" type="xs:string" use="optional"/>
<xs:attribute name＝″FontSize″type＝″xs:string″use＝″optional″/><xs:attribute name="FontSize"type="xs:string"use="optional"/>
<xs:attribute name＝″FontStyle″type＝″xs:string″use＝″optional″/><xs:attribute name="FontStyle" type="xs:string" use="optional"/>
<xs:attribute name＝″Name″type＝″xs:string″use＝″required″/><xs:attribute name="Name"type="xs:string"use="required"/>
<xs:attribute name＝″Tag″type＝″xs:string″use＝″optional″/><xs:attribute name="Tag" type="xs:string" use="optional"/>
<xs:attribute name＝″TabIndex″type＝″xs:string″use＝″optional″/><xs:attribute name="TabIndex"type="xs:string"use="optional"/>
<xs:attribute name＝″IsEnabled″type＝″xs:string″use＝″optional″/><xs:attribute name="IsEnabled"type="xs:string"use="optional"/>
<xs:attribute name＝″Visibility″type＝″xs:string″use＝″optional″/><xs:attribute name="Visibility"type="xs:string"use="optional"/>
<xs:attribute name＝″ToolTip″type＝″xs:string″use＝″optional″/><xs:attribute name="ToolTip"type="xs:string"use="optional"/>
<xs:attribute name＝″Text″type＝″xs:string″use＝″optional″/><xs:attribute name="Text"type="xs:string"use="optional"/>
<！-- 事件 --><! -- event -->
<xs:attribute name＝″Click″type＝″xs:string″use＝″optional″/><xs:attribute name="Click"type="xs:string"use="optional"/>
<xs:attribute name＝″GotFocus″type＝″xs:string″use＝″optional″/><xs:attribute name="GotFocus"type="xs:string"use="optional"/>
<xs:attribute name＝″LostFocus″type＝″xs:string″use＝″optional″/><xs:attribute name="LostFocus"type="xs:string"use="optional"/>
<xs:attribute name＝″KeyUp″type＝″xs:string″use＝″optional″/><xs:attribute name="KeyUp"type="xs:string"use="optional"/>
<xs:attribute name＝″KeyDown″type＝″xs:string″use＝″optional″/><xs:attribute name="KeyDown"type="xs:string"use="optional"/>
<xs:attribute name＝″MouseUp″type＝″xs:string″use＝″optional″/><xs:attribute name="MouseUp"type="xs:string"use="optional"/>
<xs:attribute name＝″MouseDown″type＝″xs:string″use＝″optional″/><xs:attribute name="MouseDown"type="xs:string"use="optional"/>
<xs:attribute name＝″TextChanged″type＝″xs:string″use＝″optional″/><xs:attribute name="TextChanged"type="xs:string"use="optional"/>
</xs:attributeGroup></xs:attributeGroup>
</xs:schema></xs:schema>
Claims (20)
Translated fromChineseApplications Claiming Priority (9)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| US71769405P | 2005-09-16 | 2005-09-16 | |
| US60/717,694 | 2005-09-16 | ||
| US75333705P | 2005-12-21 | 2005-12-21 | |
| US75297105P | 2005-12-21 | 2005-12-21 | |
| US60/752,971 | 2005-12-21 | ||
| US60/753,337 | 2005-12-21 | ||
| US11/479,372 | 2006-06-29 | ||
| US11/479,372US7945531B2 (en) | 2005-09-16 | 2006-06-29 | Interfaces for a productivity suite application and a hosted user interface |
| PCT/US2006/036483WO2007035733A2 (en) | 2005-09-16 | 2006-09-18 | Interfaces for a productivity suite application and a hosted user interface |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN101310271A CN101310271A (en) | 2008-11-19 |
| CN101310271Btrue CN101310271B (en) | 2011-04-13 |
Family
ID=40125810
Family Applications (2)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN200680042732.0AExpired - Fee RelatedCN101310265B (en) | 2005-09-16 | 2006-09-18 | Synchronization mechanism from productivity suite to line of business |
| CN2006800427227AExpired - Fee RelatedCN101310271B (en) | 2005-09-16 | 2006-09-18 | Interface for productivity suite applications and the host's user interface |
Family Applications Before (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN200680042732.0AExpired - Fee RelatedCN101310265B (en) | 2005-09-16 | 2006-09-18 | Synchronization mechanism from productivity suite to line of business |
Country Status (1)
| Country | Link |
|---|---|
| CN (2) | CN101310265B (en) |
Families Citing this family (16)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8434097B2 (en)* | 2009-12-30 | 2013-04-30 | Sybase, Inc. | Dynamic data binding for MBOs for container based application |
| CN102455892B (en) | 2010-10-18 | 2014-04-16 | 腾讯科技（深圳）有限公司 | Method and device for realizing miniblog message pages |
| TWI435262B (en)* | 2011-04-22 | 2014-04-21 | Wistron Corp | Rendering and operating method of an user interface, program product and system |
| CN102420857A (en)* | 2011-11-18 | 2012-04-18 | 北京蓝汛通信技术有限责任公司 | Operation instruction transmission and processing method, transmission and cache server and storage system |
| US8499122B2 (en)* | 2011-11-21 | 2013-07-30 | Microsoft Corporation | Asynchronous data binding |
| CN103257967A (en)* | 2012-02-17 | 2013-08-21 | 腾讯科技（深圳）有限公司 | Method and device for shielding influence of custom style on global style in webpage |
| US20140081938A1 (en)* | 2012-09-14 | 2014-03-20 | Microsoft Corporation | Bidirectional synchronization of communications and crm applications |
| EP2977895A1 (en)* | 2014-07-23 | 2016-01-27 | Siemens Aktiengesellschaft | Managing data in a manufacturing execution system |
| CN106155674B (en)* | 2015-04-22 | 2020-04-07 | 阿里巴巴集团控股有限公司 | Method and device for displaying report page |
| CN105824625B (en)* | 2016-03-14 | 2019-07-23 | 北京中电普华信息技术有限公司 | A kind of service application constructing apparatus and method based on cloud environment |
| CN106371845B (en)* | 2016-09-05 | 2019-10-25 | 深圳震有科技股份有限公司 | The method and system of same type control are reused based on WPF by control pond |
| CN107273113A (en)* | 2017-05-05 | 2017-10-20 | 广东网金控股股份有限公司 | The binding of page control and entity, to entity assignment and the method for page control assignment |
| CN110688187A (en)* | 2019-09-27 | 2020-01-14 | 福建工程学院 | Data interaction method for control and function in application program customized function interface |
| CN113064580B (en)* | 2021-03-29 | 2025-02-28 | 上海金融期货信息技术有限公司 | A horizontally scalable client system |
| CN113176901B (en)* | 2021-05-17 | 2023-09-19 | 上海云扩信息科技有限公司 | Program running loading optimization method |
| CN115391697B (en)* | 2022-08-26 | 2025-07-15 | 湖南快乐阳光互动娱乐传媒有限公司 | A module data acquisition method and device, storage medium and electronic device |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6424966B1 (en)* | 1998-06-30 | 2002-07-23 | Microsoft Corporation | Synchronizing crawler with notification source |
| CN1647071A (en)* | 2001-10-24 | 2005-07-27 | Bea系统公司 | Data synchronization |
- 2006
- 2006-09-18CNCN200680042732.0Apatent/CN101310265B/ennot_activeExpired - Fee Related
- 2006-09-18CNCN2006800427227Apatent/CN101310271B/ennot_activeExpired - Fee Related
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6424966B1 (en)* | 1998-06-30 | 2002-07-23 | Microsoft Corporation | Synchronizing crawler with notification source |
| CN1647071A (en)* | 2001-10-24 | 2005-07-27 | Bea系统公司 | Data synchronization |
Also Published As
| Publication number | Publication date |
|---|---|
| CN101310271A (en) | 2008-11-19 |
| CN101310265B (en) | 2013-03-13 |
| CN101310265A (en) | 2008-11-19 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN101310271B (en) | Interface for productivity suite applications and the host's user interface | |
| CA2624270C (en) | Interfaces for a productivity suite application and a hosted user interface | |
| JP5026415B2 (en) | Data centric workflow | |
| JP5787963B2 (en) | Computer platform programming interface | |
| CN102656557B (en) | Automate Enterprise Software Development | |
| AU2006200230B2 (en) | Platform for data services across disparate application frameworks | |
| US7269664B2 (en) | Network portal system and methods | |
| US7516440B2 (en) | System and method for providing a java interface to an application view component | |
| EP1586994B1 (en) | System and method for dynamic binding of user interface controls and commands | |
| US20070219976A1 (en) | Extensible query language with support for rich data types | |
| US20080189679A1 (en) | Method and system for creating, deploying, and utilizing a service | |
| EP1126681A2 (en) | A network portal system and methods | |
| US8904363B2 (en) | Projecting software and data onto client | |
| WO2009043033A4 (en) | Network operating system | |
| KR20060097577A (en) | System Data Interface, Associated Architecture, Print System Data Interface, and Associated Print System Architecture | |
| US7467373B2 (en) | Global object system | |
| US7539687B2 (en) | Priority binding | |
| KR20020038575A (en) | Method and apparatus for maintaining data integrity across distributed computer systems | |
| Zhu et al. | Developing Applications with IBM FileNet P8 APIs | |
| MX2008004932A (en) | Interfaces for a productivity suite application and a hosted user interface |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant | ||
| ASS | Succession or assignment of patent right | Owner name:MICROSOFT TECHNOLOGY LICENSING LLC Free format text:FORMER OWNER: MICROSOFT CORP. Effective date:20150421 | |
| C41 | Transfer of patent application or patent right or utility model | ||
| TR01 | Transfer of patent right | Effective date of registration:20150421 Address after:Washington State Patentee after:Micro soft technique license Co., Ltd Address before:Washington State Patentee before:Microsoft Corp. | |
| CF01 | Termination of patent right due to non-payment of annual fee | ||
| CF01 | Termination of patent right due to non-payment of annual fee | Granted publication date:20110413 Termination date:20190918 |