XCF之实用篇

上集回顾

    上集中已经实现了XCF的基础，但是不难发现这样的实现没有多少实用意义。

    本集的重点就是讨论怎么把XCF实用化。

准备Xsd

    想一下如果要定义一个xml来描述，那么需要哪些元素。

    首先是一个模板，这个模板描述了请求的总体结构。

    其次是变量，这些变量描述了请求中的变化值。

    然后是需要一个机制，将模板和变量融合起来，变成一个真正的请求实例。

    最后是对响应的处理，如果不关心响应的话，这部分可以省略。

    所以，可以简单的定义出这样的Schema：

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="WcfFantasia"
    targetNamespace="http://www.cnblogs.com/vwxyzh/WcfFantasia/"
    elementFormDefault="qualified"
    attributeFormDefault="qualified"
    xmlns:f="http://www.cnblogs.com/vwxyzh/WcfFantasia/"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  
  <xs:complexType name="Request">
    <xs:sequence>
      <xs:element name="template" type="xs:anyType"/>
      <xs:element name="transform" type="xs:anyType" minOccurs="0"/>
    </xs:sequence>
  </xs:complexType>

  <xs:complexType name="Response">
    <xs:sequence minOccurs="0" maxOccurs="unbounded">
      <xs:element name="item" type="f:ResponseItem"/>
    </xs:sequence>
  </xs:complexType>
  <xs:complexType name="ResponseItem">
    <xs:attribute name="name" type="xs:string" use="required"/>
    <xs:attribute name="path" type="xs:string" use="required"/>
  </xs:complexType>

  <xs:complexType name="RequestResponse">
    <xs:sequence>
      <xs:element name="request" type="f:Request"/>
      <xs:element name="response" type="f:Response"/>
    </xs:sequence>
    <xs:attribute name="method" type="xs:string" use="required"/>
    <xs:attribute name="address" type="xs:string" use="required"/>
  </xs:complexType>

  <xs:element name="root" type="f:RequestResponse"/>

  <xs:element name="bind">
    <xs:complexType>
      <xs:attribute name="value" type="xs:string" use="required"/>
    </xs:complexType>
  </xs:element>
</xs:schema>

    其中，request中的template节允许承载任何内容，用于记录模板，而transform节主要承载一个Xslt，但是由于无法在Xsd中指定Xslt，就暂时用任意内容代替。

XCF的请求/响应Xml实例

    看了xsd还在云里雾里？不妨直接看Xml实例吧，服务继续用上次的服务：

<?xml version="1.0" encoding="utf-8"?>
<f:root f:method="Echo"
        f:address="http://localhost:12345/EchoService/"
        xmlns:f="http://www.cnblogs.com/vwxyzh/WcfFantasia/">
  <f:request>
    <f:template>
      <Echo xmlns="urn:test">
        <p>
          <Age>
            <f:bind value="age"/>
          </Age>
          <Name>
            <f:bind value="name"/>
          </Name>
        </p>
      </Echo>
    </f:template>
    <f:transform>
      <xsl:stylesheet version="1.0"
                      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                      xmlns:f="http://www.cnblogs.com/vwxyzh/WcfFantasia/">
        <xsl:output omit-xml-declaration="yes" method="xml" encoding="utf-8"/>
        <xsl:template match="f:bind">
          <xsl:variable name="name" select="@value"/>
          <xsl:value-of select="f:GetContextValue($name)"/>
        </xsl:template>
        <xsl:template match="/|@*|node()">
          <xsl:copy>
            <xsl:apply-templates select="@*|node()"/>
          </xsl:copy>
        </xsl:template>
      </xsl:stylesheet>
    </f:transform>
  </f:request>
  <f:response>
    <f:item f:name="name" f:path="/a:EchoResponse/a:EchoResult/a:Name" xmlns:a="urn:test"/>
    <f:item f:name="age" f:path="/a:EchoResponse/a:EchoResult/a:Age" xmlns:a="urn:test"/>
  </f:response>
</f:root>

    乍看上去是不是有点多？

    别急，接下来，一步一步的分析一下。

    首先，看一下template的内容：

      <Echo xmlns="urn:test">
        <p>
          <Age>
            <f:bind value="age"/>
          </Age>
          <Name>
            <f:bind value="name"/>
          </Name>
        </p>
      </Echo>

    是不是有点熟悉，去掉bind节，换成产量的话，这个就是上集中的请求内容。

    那么bind节是干什么的？就把它当成一个变量占位符，在后面的Xslt中会对这一节做运算，并替换内容。

    接着，看一下transform节的内容：

      <xsl:stylesheet version="1.0"
                      xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                      xmlns:f="http://www.cnblogs.com/vwxyzh/WcfFantasia/">
        <xsl:output omit-xml-declaration="yes" method="xml" encoding="utf-8"/>
        <xsl:template match="f:bind">
          <xsl:variable name="name" select="@value"/>
          <xsl:value-of select="f:GetContextValue($name)"/>
        </xsl:template>
        <xsl:template match="/|@*|node()">
          <xsl:copy>
            <xsl:apply-templates select="@*|node()"/>
          </xsl:copy>
        </xsl:template>
      </xsl:stylesheet>

    这里使用了一个通用的转换方式，当然这里也可以使用特定转换。

    至于response节，暂时不作为重点介绍。

实现XcfEngine

    简单的实现一下：

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;

namespace WcfFantasia
{
    public class XcfEngine
    {

        public const string XcfNamespace = "http://www.cnblogs.com/vwxyzh/WcfFantasia/";
        private readonly XcfChannelFactory m_factory;

        public XcfEngine(XcfChannelFactory factory)
        {
            m_factory = factory;
        }

        public Dictionary<string, object> Call(XmlReader reader, IDictionary<string, object> contexts)
        {
            XPathDocument doc = new XPathDocument(reader);
            XmlNameTable nameTable = reader.NameTable;
            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(nameTable);
            namespaceManager.AddNamespace("f", XcfNamespace);
            var root = doc.CreateNavigator().SelectSingleNode("f:root", namespaceManager);
            using (var stream = new MemoryStream())
            {
                CreateRequest(contexts, root, stream, namespaceManager);
                stream.Seek(0L, SeekOrigin.Begin);
                var address = root.SelectSingleNode("@f:address", namespaceManager).Value;
                var method = root.SelectSingleNode("@f:method", namespaceManager).Value;
                using (var c = m_factory.Create(new Uri(address)))
                using (var requestReader = XmlReader.Create(stream))
                using (var resp = c.Request(method, requestReader))
                using (var respBody = resp.GetBody())
                    return ProcessResponse(root, namespaceManager, respBody);
            }
        }

        private void CreateRequest(IDictionary<string, object> contexts, XPathNavigator root, MemoryStream stream, XmlNamespaceManager namespaceManager)
        {
            var template = root.SelectSingleNode("f:request/f:template", namespaceManager).SelectChildren(XPathNodeType.Element);
            template.MoveNext();
            var transform = root.SelectSingleNode("f:request/f:transform", namespaceManager).SelectChildren(XPathNodeType.Element);
            transform.MoveNext();
            using (var input = template.Current.ReadSubtree())
            using (var trans = transform.Current.ReadSubtree())
                Transform(trans, input, stream, contexts);
        }

        private void Transform(XmlReader transform, XmlReader input,
            Stream result, IDictionary<string, object> dict)
        {
            var f = new XslCompiledTransform();
            f.Load(transform);
            XsltArgumentList xal = new XsltArgumentList();
            xal.AddExtensionObject(XcfNamespace, new XcfContext(dict));
            f.Transform(input, xal, result);
        }

        private static Dictionary<string, object> ProcessResponse(XPathNavigator root, XmlNamespaceManager namespaceManager, XmlReader respBody)
        {
            Dictionary<string, object> result = new Dictionary<string, object>();
            XPathDocument respDoc = new XPathDocument(respBody);
            foreach (XPathNavigator item in root.Select("f:response/f:item", namespaceManager))
            {
                foreach (var nspair in item.GetNamespacesInScope(XmlNamespaceScope.Local))
                    namespaceManager.AddNamespace(nspair.Key, nspair.Value);
                string xpath = item.GetAttribute("path", XcfNamespace);
                string name = item.GetAttribute("name", XcfNamespace);
                var itemNode = respDoc.CreateNavigator().SelectSingleNode(xpath, namespaceManager);
                if (itemNode != null)
                    result[name] = itemNode.Value;
                else
                    result[name] = null;
            }
            return result;
        }

    }
}

public class XcfContext
{
    private Dictionary<string, object> m_dict;

    public XcfContext(IDictionary<string, object> dict)
    {
        m_dict = new Dictionary<string, object>(dict);
    }

    public object GetContextValue(string key)
    {
        object result;
        m_dict.TryGetValue(key, out result);
        return result ?? string.Empty;
    }

}

    整个XcfEngine就完成了，来看看怎么用吧：

using (var f = new XcfChannelFactory(new WSHttpBinding()))
{
    XcfEngine engine = new XcfEngine(f);
    using (var reader = XmlReader.Create("sample.xml"))
    {
        var result = engine.Call(reader, new Dictionary<string, object>
        {
            { "age", 1 },
            { "name", "xcf" },
        });
        foreach (var item in result)
            Console.WriteLine("Name={0}, Value={1}", item.Key, item.Value);
    }
}

    这样就把整个xcf调用起来了，当然变量部分目前直接使用Dictionary，当然可以使用更好的方式，毕竟这个只是初步的实现。

XCF展望

    说了三篇的XCF，那么定位是什么哪？

    无契约类型的优势是什么？或者说把契约还原成xml的优势是什么？

    首先，xml而不是类型就不依赖编译，也就是当对方契约变化的时候，可以直接更新，这个特性看起来不怎么重要，但是在特定的场合下非常重要。

    其次，xml可以有更多的存储/发布方式，例如数据库或web/wcf等各种方式。

    再次，xml本身是一整套解决方案，可以用各种Xml的应用组合出更强大的xml应用。

    最后，可以利用xml调用那些编译程序时完全未知的web/wcf服务。