翻译文章:元数据驱动的用户界面(Metadata-Driven User Interfaces)

Posted on 2005-08-13 19:10 美丽心灵阅读(3378) 评论(5) 编辑收藏举报

元数据驱动的用户界面

元数据驱动的用户界面

查看原文

John deVadoss

微软公司

2005.7

用于：

企业体系结构

用户界面

概述:本文解释了如何由元数据动态创建Windows窗体，以及当考虑到客户端逻辑定制时如何执行窗体。

因为客户之间、用户之间需求的变化，很多业务应用程序需要用户界面可护展，用户界面的客户端业务逻辑也需要根据个别用户的需要定制。一个用户与另一个用的屏幕布局可能不同，这可能包括控件位置，可见性等等，或者可能因为设备不同而界面不同，就象智能电话，平板设备或个人数字助理。客户端业务逻辑定制也包括：定制有效性规则，更改控件属性，以及其他修正。例如：为了删除及移动文件，经理比下属拥有不同的特权。

有很多技术能够实现业务应用程序的可护展、可定制，大多数应用程序通过将可定制项，如用户界面布局及客户端业务逻辑作为元数据存储在仓储中解决。元数据因而可由运行时引擎解释，从而为用户显示屏幕，以及当用户在屏幕完成动作时执行客户端业务逻辑。

这种方式的优点是双重的：第一，当表示层相关组件在中心仓储完成定制时，不需要重新部署；第二，仅需要非常轻的客户端安装，也就是仅需将运行时引擎部署到客户端机器上。

本文描述了利用微软.NET Framework实现的此技术，为此，本文解释了如何由元数据创建Windows窗体，以及考虑到客户端逻辑定制时如何运行窗体。

阅读前提

l 了解关于编写Visual Studio Add-Ins的知识

l DTE对象模型的用途

设计要素

实现元数据驱动的用户界面，本质上有三个设计要素。

l 首先是设计元数据架构并决定仓储机制。仓储可以是关系数据库，如SQL Server或任何其他存储，如XML。本文我们使用XML文件作为元数据仓储。

l 当我们确定元数据架构后，我们实现一个设计时环境，在此环境中用户（通常为开发者或定制人）能创建及修改特定屏幕。本文将跨在微软Visual Studio Windows Forms Designer（窗体设计器）之上来实现设计时环境。

l 最后，我们设计并实现运行时引擎。

仓储结构

首先，我们要决定能以元数据存储的内容。如上述所提，元数据应该包含所有可定制的项目。例如，如果客户想定制屏幕布局及客户端验证逻辑，那么元数据应该包含有关界面布局信息，包括放置在屏幕的控件，他们的属性，放置位置，元数据也应该包括客户端业务逻辑。

以下是一个包括界面信息的XML文件例子。

<?xml version="1.0" encoding="utf-8"?>

<form xmlns:xsd=http://www.w3.org/2001/XMLSchema

xmlns:xsi="http://www.w3.org/2001/XMLSchema-

instance" name="Form1" xmlns="http://tempuri.org/

MetadataForm.xsd">

</position>

</position>

<name>button2</name>

<text>button2</text>

<event-handlers />

</control>

</position>

<name>button1</name>

<text>button1</text>

<event-handlers>

<eventInfo eventName=

"Click" eventHandler="button1_Click" />

<eventInfo eventName=

"EnabledChanged" eventHandler="button1_

EnabledChanged" />

</event-handlers>

</control>

</position>

</position>

</position>

<name>button3</name>

<text>button3</text>

<event-handlers>

<eventInfo eventName=

"Click" eventHandler="button3_Click" />

</event-handlers>

</control>

</position>

<name>textBox2</name>

<text>textBox2</text>

<event-handlers />

</control>

</position>

<name>textBox1</name>

<text>textBox1</text>

<event-handlers />

</control>

</controls>

<name>tabPage1</name>

<text>tabPage1</text>

<event-handlers />

</control>

</position>

</position>

<name>linkLabel1</name>

<text>linkLabel1</text>

<visible>false</visible>

<event-handlers>

<eventInfo

eventName="LinkClicked" eventHandler=

"linkLabel1_LinkClicked" />

</event-handlers>

</control>

</controls>

<name>tabPage2</name>

<text>tabPage2</text>

<visible>false</visible>

<event-handlers />

</control>

</controls>

<name>tabControl1</name>

<event-handlers />

</control>

</controls>

<event-handlers>

</event-handlers>

</control>

</controls>

<content> private void linkLabel1_LinkClicked

(object sender, System.Windows.Forms.

LinkLabelLinkClickedEventArgs e)

{

}</content>

</events>

<content> private void Form1_Load(object sender, System.EventArgs e)

{

textBox1.Text = " " ;

textBox2.Text = " " ;

}</content>

</events>

<content> private void button1_Click(object sender, System.EventArgs e)

{

textBox1.Text = "Button 1 Clicked" ;

}</content>

</events>

<content> private void button1_Enabled

Changed(object sender, System.EventArgs e)

{

}</content>

</events>

<content> private void button3_Click(object sender, System.EventArgs e)

{

Button3.Enabled = true ;

textBox1.Text = "Button 3 Clicked" ;

}</content>

</events>

</script>

</form>

让我们看看XML文件的内容。Form根标记意味着元数据包含同屏幕或对话框有关的信息，在form元素下面是controls及script元素。

Controls元素包含有关内嵌到窗体的控件的信息，它是包括零个或多个control元素的容器，control元素代表含有它自己属性的控件，如控件名称，控件放置的相对位置，标题文本以及tab顺序。Control元素也有一个屏幕元素事件及事件处理程序的集合。如果控件包括子控件，其信息保存在controls素中。Control元素有一个类型属性，它的值是控件的完全限定CLR（公共语言运行时）类型名称，运行时引擎在运行时建立类型时必需此信息。

Script元素是客户端业务逻辑的容器节点，持有事件处理器程序和它的代码定义，当窗体被再现时，代码将被集成到窗体的代码页里面。

在此例子中，我们将利用XML序列化来转换仓储XML到具体的CLR类型。CLR类型利用xsd.exe工具生成，以下给出仓储的XML架构。

<?xml version="1.0" encoding="utf-8" ?>

<xs:schema id="MetadataForm"

targetNamespace=http://tempuri.org/MetadataForm.xsd

elementFormDefault="qualified"

xmlns= http://tempuri.org/

MetadataForm.xsd

xmlns:mstns= http://tempuri.org/MetadataForm.xsd

xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:complexType name="MetadataForm">

<xs:all>

<xs:element name="controls" type=

"MetadataControls" minOccurs="1"

maxOccurs="1" />

<xs:element name="script" type=

"MetadataScript" minOccurs="1"

maxOccurs="1" />

</xs:all>

<xs:attribute name="name" type="xs:string" use="required" />

</xs:complexType>

<xs:complexType name="MetadataControls">

<xs:sequence>

<xs:element name="control" type=

"MetadataControl" minOccurs="0"

maxOccurs="unbounded"></xs:element>

</xs:sequence>

</xs:complexType>

<xs:complexType name=

"MetadataControl">

<xs:all>

<xs:element name="position" type="Position" />

<xs:element name="controls" type="MetadataControls" />

<xs:element name="name" type="xs:string" />

<xs:element name="text" type="xs:string" />

<xs:element name="visible" type="xs:boolean" default="true" />

<xs:element name="tabIndex" type="xs:int" />

<xs:element name="event-handlers" type="AllEvents" />

</xs:all>

<xs:attribute name="type" type="xs:string" />

</xs:complexType>

<xs:complexType name=

"AllEvents">

<xs:sequence>

<xs:element name="eventInfo" type=

"EventInfo" minOccurs ="0" maxOccurs =

"unbounded" ></xs:element>

</xs:sequence>

</xs:complexType>

<xs:complexType name="EventInfo">

<xs:attribute name="eventName" type="xs:string"></xs:attribute>

<xs:attribute name="eventHandler" type="xs:string"></xs:attribute>

</xs:complexType>

<xs:complexType name="Position">

<xs:sequence>

<xs:element name="height" type="xs:int"></xs:element>

<xs:element name="width" type="xs:int"></xs:element>

<xs:element name="top" type="xs:int"></xs:element>

<xs:element name="left" type="xs:int"></xs:element>

</xs:sequence>

</xs:complexType>

<xs:complexType name=

"MetadataScript">

<xs:sequence>

<xs:element name="events" type=

"eventItem" minOccurs="0" maxOccurs=

"unbounded" />

</xs:sequence>

</xs:complexType>

<xs:simpleType name="contentType">

<xs:restriction base="xs:string">

<xs:enumeration value="text" />

<xs:enumeration value="binary" />

</xs:restriction>

</xs:simpleType>

<xs:complexType name=

"eventItem">

<xs:all>

<xs:element name="content" type="xs:string" />

<xs:element name="type" type="contentType" />

</xs:all>

<xs:attribute name="eventHandler" type="xs:string" />

</xs:complexType>

<xs:element name="form" type="MetadataForm" />

</xs:schema>

当我们在以上.xsd文件上运行命令XSD.exe，将创建称为MetadataForm的CLR类型，此类型的源文件位置为：$SOLUTIONDIR\MetadataLibrary\MetadataForm.xsd，目标文件位置为：$SOLUTIONDIR\MetadataLibrary\MetadataForm.cs。

这是MetadataForm类看起来的样子：

[System.Xml.Serialization.XmlTypeAttribute

(Namespace="http://tempuri.org/MetadataForm.xsd")]

[System.Xml.Serialization.XmlRootAttribute

("form", Namespace="http://tempuri.org/MetadataForm.xsd",

IsNullable=false)]

public class MetadataForm

{

/// <remarks/>

[System.Xml.Serialization.XmlArrayItemAttribute

("control", IsNullable=false)]

public MetadataControl[] controls;

/// <remarks/>

[System.Xml.Serialization.XmlArrayItemAttribute

("events", IsNullable=false)]

public eventItem[] script;

/// <remarks/>

[System.Xml.Serialization.XmlAttributeAttribute()]

public string name;

public MetadataForm ()

{

controls = null;

script = null;

name = null;

}

public MetadataForm(ArrayList ctrlList,

ArrayList evtList, string formName)

{

name = formName;

controls = new MetadataControl[ctrlList.Count];

script = new eventItem[evtList.Count];

int cnt = 0;

if(ctrlList.Count > 0)

{

foreach(object ctrl in ctrlList)

{

controls[cnt] = (MetadataControl)ctrl;

cnt++;

}

if(evtList.Count > 0)

{

cnt = 0; foreach(object evt in evtList)

{

script[cnt] = (eventItem)evt;

cnt++;

}

MetadataForm类包含一个MetadataControl数组对象，以及一个eventItem数组对象。

以下是eventItem类的定义：

/// <remarks/>

[System.Xml.Serialization.XmlTypeAttribute

(Namespace="http://tempuri.org/MetadataForm.xsd")]

public class eventItem

{

/// <remarks/>

public string content;

/// <remarks/>

public contentType type;

/// <remarks/>

[System.Xml.Serialization.Xml

AttributeAttribute()]

public string eventHandler;

public eventItem() {

eventHandler = content = null;

type = contentType.text ;

}

public eventItem(string eventHandler, string content,

contentType cType )

{

this.eventHandler = eventHandler;

this.content = content;

this.type = cType;

}

每个eventItem对象包含存储代码的事件处理程序名称，代码本身，以文本或二进制的形式（由contentType枚举定义）保持在content元素中，当前代码仅支持以文本形式存储内容，然而，此方案可以扩展来支持以二进制形式存储代码。

/// <remarks/>

public enum contentType {

/// <remarks/>

text,

/// <remarks/>

binary,

}

MetadataControl类型定义为：

/// <remarks/>

[System.Xml.Serialization.XmlTypeAttribute

(Namespace=http://tempuri.org/MetadataForm.xsd ]

public class MetadataControl

{

/// <remarks/>

public Position position;

/// <remarks/>

[System.Xml.Serialization.Xml

ArrayItemAttribute("control", IsNullable=false)]

public MetadataControl[] controls;

/// <remarks/>

public string name;

/// <remarks/>

public string text;

/// <remarks/>

[System.ComponentModel.DefaultValueAttribute(true)]

public bool visible = true;

/// <remarks/>

public int tabIndex;

/// <remarks/>

[System.Xml.Serialization.XmlArrayItemAttribute

("eventInfo", IsNullable=false)]

public EventInfo[] event-handlers;

/// <remarks/>

[System.Xml.Serialization.XmlAttributeAttribute()]

public string type;

public MetadataControl()

{

position = new Position ();

tabIndex = 0;

type = name = text = null;

visible = true;

event-handlers = null;

controls = null; public MetadataControl(string name,

string text, bool visible, int tabIndex,

string type, int ht, int wd, int top,

int left ,ArrayList evts )

{

this.name = name ;

this.text = text ;

this.visible = visible;

this.tabIndex = tabIndex;

this.type = type;

position = new Position (ht,wd,top,left);

event-handlers = new EventInfo[evts.Count];

int cnt = 0;

if(evts.Count > 0)

{

foreach(object evt in evts)

{

event-handlers[cnt] = (EventInfo)evt;

cnt++;

}

最后，Position类型定义为：

/// <remarks/>

[System.Xml.Serialization.XmlTypeAttribute

(Namespace=http://tempuri.org/MetadataForm.xsd )]

public class Position

{

/// <remarks/>

public int height;

/// <remarks/>

public int width;

/// <remarks/> public int top;

/// <remarks/>

public int left;

public Position()

{

height = width = top = left = 0;

}

public Position( int ht, int wd, int top, int left)

{

height = ht;

width = wd;

this.top = top;

this.left = left;

}

MetadataControl类拥有设计窗体内的所有控件的控件信息。窗体的属性包容在根元素，并且其他的所有控件是它controls数组的一部分。每个控件的名字，文本，tab顺序，可见性，位置及类型被收集，同样，如果一个控件是一些其他控件的父控件，子控件的信息被保持在controls数组。每个控件，它们事件的触发及事件处理程序被保持在event-handlers数组，这是EventInfo数组对象。

EventInfo类型定义为：

/// <remarks/>

[System.Xml.Serialization.XmlTypeAttribute

(Namespace="http://tempuri.org/MetadataForm.xsd")]

public class EventInfo

{

/// <remarks/>

[System.Xml.Serialization.XmlAttributeAttribute()]

public string eventName;

/// <remarks/>

[System.Xml.Serialization.XmlAttributeAttribute()]

public string eventHandler;

public EventInfo()

{

eventName = null;

eventHandler = null ;

}

public EventInfo(string eventName, string eventHandler)

{

this.eventName = eventName;

this.eventHandler = eventHandler; }

}

设计时实现

我们把设计时环境作为Visual Studio .Net的附加组件实现，关于如可开发附加件的更多信息，请参考文章“定制附加件帮您最大化Visual Studio .NET的生产力”。

为什么要设计时？

您需要设计时工具提供图形界面来操纵原始的XML仓储存储，此工具将在两个阶段内用到：

l 在屏幕的最初开发期间；

l 在定制化阶级期间；

此工具应提供图形设计器来操纵用户界面布局，就象在屏幕上添加控件，操纵控件的属性，重定屏幕大小等等。它应该能为控件添加事件及事件处理程序，从用户的角度来看，此工具抽象元数据结构，元数据存在哪里及如何存储。

在这里，我们不深究Visual Studio附加组件及客户端脚本，仅指望您清楚理解Visual Studio附加组件如何工作。示例源代码演示如何实现我们的Visual Studio附加组件。

设计器实现

使用Windows窗体设计器来设计窗体布局并为控件挂接事件，Visual Studio附件组件编程模型可让我们访问Visual Studio环境中当前开放的Window对象，通过检查Window对象是否是从称为IDesignerHost的接口继承的，来让我们查询window是否是设计窗口。

一旦安装附加组件，Tools菜单下将会有一个菜单项。

图1. 在Tools菜单下的附加组件

初始化后，设计时附加组件在Tools菜单下添加一组菜单项。现在，Tools菜单看起来如下：

图2. 附加组件初始化后展开的Tools菜单

表1. 附件菜单项摘要

菜单项	行为
Attach	从活动文档获取IDesignerHost接口指针。活动文档应为Windows窗体设计器。在某私有变量中保存IDesignerHost指针，以备将来使用。
New	新建一个元数据文档。
Open	从仓储中打开一个已存在的元数据文档。显示“打开文件”对话框，允许用户选择适当的元数据文档。
Show Form	转为XML文件形式。
Save	保存元数据文档。
Detach	从Windows窗体设计器分离。

Attach菜单项

打开一个新的C#语言的Windows窗体项目，为活动窗口获取IDesignerHost句柄，并保存在一个内部变量中。这也使其他菜单项允许。

每个设计器表面提供特定服务以监视它发生的动作，在当前情况下，我们获得IComponentChangeService，用来获取有关设计器表面发生的变化信息。我们为设计器编写了适当的事件处理器。

internal void AttachDesignerToForm()

{

if (applicationObject.ActiveDocument != null)

{

foreach (Window W in applicationObject.ActiveDocument.Windows)

{

designerHost = W.Object as IDesignerHost;

}

AttachDesignerEvent-handlers();

}

private void AttachDesignerEvent-handlers()

{

//Component change events.

IComponentChangeService ccs =

(IComponentChangeService)designerHost.GetService

(typeof(IComponentChangeService));

if (ccs != null)

{

ccs.ComponentChanged += new

ComponentChangedEventHandler(this.OnComponentChanged);

}

Detach菜单项

将designerHost对象置为空，并解开设计器上的所有事件处理程序，也要禁止除Attach外的所有附加组件菜单项。

public void DetachFromDesigner()

{

DetachDesignerEvent-handlers();

this.designerHost = null;

}

private void DetachDesignerEvent-handlers()

{

IComponentChangeService ccs =

(IComponentChangeService)designerHost.GetService

(typeof(IComponentChangeService));

if (ccs != null)

{

ccs.ComponentChanged -= new

ComponentChangedEventHandler(this.OnComponentChanged);

}

New菜单项

为当前项目添加一个空的窗体，并为窗体获取设计器对象，您可通过拖放开始窗体设计，添加事件处理器，设置控件属性，及实现事件处理器。

设计器仅需捕获的事件是ComponentChanged事件，这用来记录控件触发的事件及相应的事件处理器名称。

private void OnComponentChanged(object sender, ComponentChangedEventArgs cea)

{

if (cea.Member.GetType().Name.Equals("EventPropertyDescriptor"))

{

string ctrlName = ((Control)cea.Component).Name;

EventInfo ei = new EventInfo(cea.Member.Name,cea.NewValue.ToString());

ArrayList evtInfoList = new ArrayList();

if (!ctrlEvtList.ContainsKey(ctrlName))

{

evtInfoList.Add(ei);

}

else

{

evtInfoList = (ArrayList)ctrlEvtList[ctrlName];

if(!evtInfoList.Contains(ei))

{

evtInfoList.Add(ei);

}

ctrlEvtList.Remove(ctrlName);

}

ctrlEvtList.Add(ctrlName,evtInfoList);

}

Save菜单项

开始以下几步：

1. 提示您为XML文件提供要保存的位置及名称；

2. 递归处理当前设计器对象，收集其中的所有控件信息；

l 为每个在设计器内的对象创建一个MetadataControl对象，保存属性，就象name，tabIndex，location，size，type及visibility。

l 如果控件是其他控件的父控件，子控件的信息收集到父控件的数组成员MetadataControl中。

private MetadataControl GetTheControl(Control formCtrl)

{

MetadataControl newCtrl = new MetadataControl();

newCtrl.name = formCtrl.Name;

newCtrl.text = formCtrl.Text;

newCtrl.position.height = formCtrl.Height;

newCtrl.position.width = formCtrl.Width;

newCtrl.position.top = formCtrl.Top;

newCtrl.position.left = formCtrl.Left;

newCtrl.tabIndex = formCtrl.TabIndex;

newCtrl.type = formCtrl.GetType().ToString();

newCtrl.visible = formCtrl.Visible;

newCtrl.controls = new MetadataControl[formCtrl.Controls.Count];

newCtrl.event-handlers = null;

if(newCtrl.controls.Length > 0)

{

int cnt = 0;

foreach (Control childCtrl in formCtrl.Controls)

{

newCtrl.controls[cnt] = GetTheControl(childCtrl);

cnt++;

}

return newCtrl;

}

3. 控件触发的事件及相应的处理程序名称存在event-handlers（类型为EventInfo）成员中，这是更新窗体的MetadataControls成员。

private void IntegrateCtrlWithEvents(MetadataControl[] arr)

{

foreach(MetadataControl ctrl in arr)

{

if(ctrlEvtList.ContainsKey(ctrl.name))

{

ArrayList ei = (ArrayList)ctrlEvtList[ctrl.name];

ctrl.event-handlers = new EventInfo[ei.Count];

ei.CopyTo(ctrl.event-handlers);

}

else

{

ctrl.event-handlers = new EventInfo[0];

}

if (ctrl.controls.Length > 0)

{

IntegrateCtrlWithEvents(ctrl.controls);

}

4. 解析窗体代码文件以得到事件处理器代码。这是添加MetadataForm的脚本元素。

private ArrayList GetEventCode()

{

ArrayList evtCode = null;

try

{

ProjectItem pi = applicationObject.ActiveDocument.ProjectItem;

MetadataCodeSpace codespace = new MetadataCodeSpace(pi);

string[] evtHdlrNames = GetOnlyEvtHandlers(ctrlEvtList.Values);

evtCode = codespace.ExtractEventCode(evtHdlrNames);

}

catch(Exception e)

{

MessageBox.Show(e.Message,"Error !!!");

return null;

}

return evtCode;

}

public ArrayList ExtractEventCode(string[] evtHandlers)

{

eventItem tempEvt;

// Parse code file for event code

try

{

CodeElement celt = projectItem.FileCodeModel.CodeElements.Item(1);

CodeNamespace cNamespace = (CodeNamespace)celt;

CodeClass cClass = (CodeClass)(cNamespace.Members.Item(1));

foreach (CodeElement ce in cClass.Members)

{

switch (ce.Kind)

{

case EnvDTE.vsCMElement.vsCMElementFunction:

CodeFunction cf = (CodeFunction)ce;

//Chk whether its an eventhandler

if (foundEvtHandler(evtHandlers,cf.Name))

{

TextPoint startPt = cf.StartPoint;

TextPoint endPt = cf.EndPoint;

EditPoint editPt = startPt.CreateEditPoint();

tempEvt = new eventItem(cf.Name,editPt.GetLines(startPt.Line,endPt.Line+1),contentType.text);

evtCodeList.Add(tempEvt);

}

tempEvt = null;

break;

}

catch(Exception e)

{

string s = e.Message;

}

return evtCodeList;

}

5. 一旦收集到所有窗体信息，新的MetadataForm对象被创建并序列化成XML，此XML按步骤1中的文件名保存。

// Add all the controls to the form object

activeForm = new MetadataForm(ctrls,evts,GetActiveFormName());

//activeFileName contains name of the file user has chosen

StreamWriter sw = new StreamWriter(activeFileName);

XmlSerializer writer = new XmlSerializer(typeof(MetadataForm));

//Serialize the activeForm member variable

writer.Serialize(sw, activeForm);

sw.Close();

运行时实现

Open菜单项

提示您提供在设计器中想打开的XML文件路径，当指定名字后，将发生由XML文件重现窗体的过程。

以下是此过程内的有关步骤：

l 反序列化XML文件到CLR类型MetadataForm；

l 创建空的窗体并基于MetadataForm对象内的form控件设置它的属性；

l 创建控件并在窗体上适当定位；

l 挂接窗体上控件的事件处理程序

l 插入从XML文件内读取的事件处理程序代码到后台代码文件内。

反序列化

象我们以前看到的，第一步是反序列化仓储文件为MetadataForm类型并将创建的类型存在一个称为activeFom的成员变量中，这里是完成这个的代码片断。

//Create the serializer

XmlSerializer serializer = new XmlSerializer(typeof(MetadataForm));

FileStream stream = null;

try {

//Open the file

Stream

= new FileStream(filename, FileMode.Open,

FileAccess.Read);

//De-serialize the XML into CLR type

activeForm =

(MetadataForm)serializer.Deserialize(stream);

stream.Close();

}

catch(Exception e) {

MessageBox.Show(e.Message);

}

创建新窗体

为当前项目添加新的空窗体并用MetadataForm对象内的窗体属性初始化。

// Adding a new form to project

Project proj = applicationObject.Solution.Projects.Item(1);

ProjectItem pi = proj.ProjectItems.AddFromTemplate

(@"C:\Program Files\Microsoft Visual Studio .NET

2003\VC#\CSharpProjectItems\CSharpAddWinFormWiz.vsz",

formName+".cs");

applicationObject.Windows.Item(formName+".cs [Design]").Activate();

// Setting properties of the form

private void SetNewFormProperties(MetadataControl ctrl)

{

((Form)designerHost.RootComponent).Name=ctrl.name;

((Form)designerHost.RootComponent).Text=ctrl.text;

((Form)designerHost.RootComponent).Height=ctrl.position.height;

((Form)designerHost.RootComponent).Width=ctrl.position.width;

}

运行时创建控件

反射的概念用来在运行时创建控件，就象我们在仓储讨论中看到的，仓储结构包含关于窗体内嵌控件的信息。

</position>

<name>button1</name>

<text>Submit</text>

</control>

如果看一下XML片断，control标记包含type特性，该特性含有控件的完全限定CLR类型，此刻，我们需要做的是利用反射创建控件，我们用Activator类来创建控件实例，完成这个的代码片断如下所示。此函数接受父控件（Winodws.Forms.Control）及子控件集合（MetadataControl）作为参数。

private void AddControlsToActiveForm(MetadataControl[] ctrl,Control parent)

{

try

{

foreach (MetadataControl child in ctrl)

{

System.Type controltype = Type.GetType(child.type);

//unknown control type. Handle this as an error

if (controltype == null) continue;

//Create the control

Control control = (Control)Activator.CreateInstance(controltype);

control.Name = child.name;

control.Text = child.text;

control.Top = child.position.top;

control.Left = child.position.left;

control.Height = child.position.height;

control.Width = child.position.width;

control.Visible = true;

control.TabIndex = child.tabIndex;

parent.Container.Add(control);

PropertyDescriptor parentProp =

TypeDescriptor.GetProperties(control).Find

("Parent",true);

parentProp.SetValue(control, parent );

if (child.controls.Length > 0)

AddControlsToActiveForm(child.controls,control);

}

catch (Exception e)

{

MessageBox.Show(e.Message );

}

1. 首先我们使用Type.GetType得到给定类型的CLR类型，它接受一个包含完全限定CLR类型名称的字符串作为参数；

2. 然后，我们调用Activator类的CreateInstance方法创建控件实例并转换控件类型为典型控件，即所有Windows窗体控件的基类；

3. 然后我们设置控件的适当属性；

4. 当创建控件后，我们把它添加到父控件的Controls集合，如果子控件还有子控件，我们传递适当参数递归调用该函数。

为控件附加事件处理程序

每一个在仓储内的MetadataControl维护一个触发的事件及相应事件处理程序的集合，此信息用来绑定运行时创建的控件与指定的事件处理程序。designerHost的IEventBindingService服务可用于此。每个控件有一个可触发事件列表，利用控件的属性列表绑定事件与相应的事件处理程序。

IEventBindingService eventservice =

IEventBindingService)designerHost.GetService

(typeof(IEventBindingService));

if( eventservice != null )

{

if((child.event-handlers != null) || (child.event-handlers.Length > 0))

{

EventInfo[] eiArr = child.event-handlers;

foreach( EventInfo ei in eiArr)

{

EventDescriptor ed =

TypeDescriptor.GetEvents(control).Find(ei.eventName,true);

if( ed == null )

break;

PropertyDescriptor pd = eventservice.GetEventProperty(ed);

if( pd == null )

break;

pd.SetValue(control, ei.eventHandler);

}

插入事件处理程序代码

最后，事件处理程序代码被插入到窗体代码文件，窗体的所有事件处理程序存于MetadataForm对象的Script元素中，利用CodeDom名称空间中的类，我们解析整个文件代码并适当插入代码处理程序。

private void AddEventHandlerCode()

{

eventItem[] eiArr = activeForm.script;

ProjectItem pi = applicationObject.ActiveDocument.ProjectItem;

CodeElement celt = pi.FileCodeModel.CodeElements.Item(1);

CodeNamespace cNamespace = (CodeNamespace)celt;

CodeClass cClass = (CodeClass)(cNamespace.Members.Item(1));

foreach (CodeElement ce in cClass.Members)

{

switch (ce.Kind)

{

case EnvDTE.vsCMElement.vsCMElementFunction:

CodeFunction cf = (CodeFunction)ce;

foreach(eventItem ei in eiArr)

{

if (cf.Name.Equals(ei.eventHandler))

{

EditPoint ep =

cf.GetStartPoint(vsCMPart.vsCMPartBody)

.CreateEditPoint();

ep.Insert(justCodeBlock(ei.content));

}

break;

}

private string justCodeBlock(string fnCode)

{

string tmpcode = fnCode.Substring(fnCode.IndexOf("{")+1);

return tmpcode.Substring(0,tmpcode.Length-1);

}

Show Fom菜单项

XML文件窗体可通过附加组件从其菜单调用Show Fom来运，这是运行一个在设计中已经打开的已存在的XML文件，或者另外提示您提供XML文件路径，这会打开当前项目中的XML文件（与Open 菜单过程一样），通过生成方案，由附加组件代码来运行。

public void ShowForm()

{

try

{

if( applicationObject.Solution.Projects.Item(1).ProjectItems.Count == 0 )

{

OnOpen();

}

BuildNRunSolution();

}

catch(Exception e)

{

MessageBox.Show(e.Message);

}

private void BuildNRunSolution()

{

applicationObject.Solution.SolutionBuild.Build(true);

applicationObject.Solution.SolutionBuild.Run();

}

结论

在本文当中，我讨论了利用.NET Framework实现仓储或元数据驱动的用户接口方法，我们也解释了如何利用.NET Framework类建立可定制化窗体，以XML存储窗体，加载XML文件到设计器，修改XML文件以及加载并运行窗体。

会员力量，点亮园子希望

刷新页面返回顶部

美丽心灵

公告

翻译文章:元数据驱动的用户界面(Metadata-Driven User Interfaces)