博客园_落叶潇潇雨

Entlib5.0之数据查询

2012-04-23T09:44:00Z

Entlib5.0早就出来了，在这个版本中提供了一些很好用的特性，今天小试一下，用用SprocAccessor和SqlStringAccessor这两个类，这两个类能够将返回的DataSet, DataTable样式的数据集转换为实体数据的形式。

1.原始的查询方式。

            Database db = DatabaseFactory.CreateDatabase();

            DbConnection connection = db.CreateConnection();
            DbCommand cmd = connection.CreateCommand();
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = "select * from person";
            DataSet ds = db.ExecuteDataSet(cmd);

说明：关于数据连接的配置，请参考帮助文档，项目地址：http://entlib.codeplex.com/

2.采用默认的映射。这种映射数据库列和实体数据的属性是一一对应的。

数据库中的列

实体类型：Person

    public class Person
    {
        public int PersonID { get; set; }
        public string LastName { get; set; }
        public string FirstName { get; set; }
        public DateTime? HireDate { get; set; }
        public DateTime? EnrollmentDate { get; set; }
        public override string ToString()
        {
            return string.Format(@"PersonID:{0},Name:{1}-{2}", PersonID, FirstName, LastName);
        }
    }

接下来看看我们如何查询

            string sql1 = "select * from person";//查询全部数据
            DataAccessor<Person> accessor = db.CreateSqlStringAccessor<Person>(sql1);
            List<Person> persons = accessor.Execute().ToList<Person>();
            persons.ForEach(p =>
            {
                Console.WriteLine(p.ToString());
            });

3.自定义映射。

单行数据的映射，考虑到实际项目的情况，我们前段展示的数据形式（ViewModel）可能和原始的Model有些不一样，这里我们重新定义个实体类型，可能和数据库列不存在一一对应的关系

/// <summary>
    /// 数据传输对象
    /// </summary>
    public class PersonCourseGradeDTO
    {
        public string PersonName { get; set; }
        public string CourseName { get; set; }
        public double Grade { get; set; }
        public override string ToString()
        {
            return string.Format(@"PersonName:{0},CourseName:{1},Grade:{2}", PersonName, CourseName, Grade);
        }
    }

这个时候我们就需要自定义一个RowMapper了

    public class PersonRowMapper : IRowMapper<PersonCourseGradeDTO>
    {
        public PersonCourseGradeDTO MapRow(IDataRecord row)
        {
            PersonCourseGradeDTO dto = new PersonCourseGradeDTO();
            int col = row.GetOrdinal("FirstName");
            string FirstName = row.GetValue(col) == DBNull.Value ? "" : row.GetValue(col).ToString();
            col = row.GetOrdinal("LastName");
            string LastName = row.GetValue(col) == DBNull.Value ? "" : row.GetValue(col).ToString();
            col = row.GetOrdinal("Title");
            string Title = row.GetValue(col) == DBNull.Value ? "" : row.GetValue(col).ToString();
            col = row.GetOrdinal("Grade");
            double Grade = row.GetValue(col) == DBNull.Value ? 0 : Convert.ToDouble(row.GetValue(col));

            dto.PersonName = FirstName + "-" + LastName;
            dto.CourseName = Title;
            dto.Grade = Grade;
            return dto;
        }
    }

如何调用？

            IRowMapper<PersonCourseGradeDTO> rowMapper = new PersonRowMapper();
            DataAccessor<PersonCourseGradeDTO> PersonCourseGradeDTOAccessor = db.CreateSqlStringAccessor<PersonCourseGradeDTO>(sql3, rowMapper);
            List<PersonCourseGradeDTO> PersonCourseGradeDTOs = PersonCourseGradeDTOAccessor.Execute().ToList<PersonCourseGradeDTO>();
            PersonCourseGradeDTOs.ForEach(p =>
            {
                Console.WriteLine(p.ToString());
            });

多行数据的映射

    public class PersonRowsetMapper : IResultSetMapper<PersonCourseGradeDTO>
    {
        public IEnumerable<PersonCourseGradeDTO> MapSet(IDataReader reader)
        {
            while (reader.Read())
            {
                PersonCourseGradeDTO dto = new PersonCourseGradeDTO();
                int col = reader.GetOrdinal("FirstName");
                string FirstName = reader.GetValue(col) == DBNull.Value ? "" : reader.GetValue(col).ToString();
                col = reader.GetOrdinal("LastName");
                string LastName = reader.GetValue(col) == DBNull.Value ? "" : reader.GetValue(col).ToString();
                col = reader.GetOrdinal("Title");
                string Title = reader.GetValue(col) == DBNull.Value ? "" : reader.GetValue(col).ToString();
                col = reader.GetOrdinal("Grade");
                double Grade = reader.GetValue(col) == DBNull.Value ? 0 : Convert.ToDouble(reader.GetValue(col));

                dto.PersonName = FirstName + "-" + LastName;
                dto.CourseName = Title;
                dto.Grade = Grade;

                yield return dto;
            }
        }
    }

如何查询？

           IResultSetMapper<PersonCourseGradeDTO> rowMapper2 = new PersonRowsetMapper();
            DataAccessor<PersonCourseGradeDTO> PersonCourseGradeDTOAccessor2 = db.CreateSqlStringAccessor<PersonCourseGradeDTO>(sql3, rowMapper2);
            List<PersonCourseGradeDTO> PersonCourseGradeDTOs2 = PersonCourseGradeDTOAccessor2.Execute().ToList<PersonCourseGradeDTO>();
            PersonCourseGradeDTOs2.ForEach(p =>
            {
                Console.WriteLine(p.ToString());
            });

入门文章，给初次接触企业库的朋友！

本文链接

Jquery Mobile dialog的生命周期

2012-04-05T04:57:00Z

JQuery Mobile对htm5的移动开发绝对是个好用的东西，今天简单谈谈JQuery Mobile中的dialog的使用。

1.对话框的弹出。

2.对话框的生命周期。

3.对话框内事件的注册。

1）第一个问题：对话框的弹出。

如果要弹出一个对话框，可以在页面中添加一个按钮

<a href="dialog.htm" data-role="button" data-inline="true" data-rel="dialog" data-transition="pop">Open dialog</a>

再看看dialog.htm的内容，注意对话框是个单独的页面，jquery mobile将以Ajax方式加载到事件触发的页面，因此dialog.htm页面不需要Header,content,footer之类的文档结构，以下代码就是全部dialog.htm的内容

<div data-role="dialog" id="aboutPage">
    <div data-role="header" data-theme="d">
        <h1>
            Dialog</h1>
    </div>
    <div data-role="content" data-theme="c">
        <h1>
            Delete page?</h1>
        <p>
            This is a regular page, styled as a dialog. To create a dialog, just link to a normal
            page and include a transition and <code>data-rel="dialog"</code> attribute.</p>
        <a href="#" data-role="button" data-rel="back" data-theme="b" id="soundgood">Sounds
            good</a> <a href="demo.htm" data-role="button" data-rel="back" data-theme="c">Cancel</a>
    </div>
</div>

这样当点击Open Dialog之后就会弹出这个对话框了。弹出对话框的形式有多种，大家可以参考http://jquerymobile.com/。

2）第二个问题：对话框事件的生命周期。

当我们弹出一个对话框后，我们可能需要再它的不同的生命周期中去注册不同的回调函数或事件，因此理解各个事件的顺序是很有必要的。

$(document).bind("pagebeforeload", function (event, data) {
            alert('1.pagebeforeload!');
        });
        $('#aboutPage').live('pagebeforecreate', function (event) {
            alert('2.This page was just inserted into the dom!pagebeforecreate!!!');
        })

        $('#aboutPage').live('pagecreate', function (event) {
            alert('3.pagecreate!');
            $("#soundgood").attr("demo.htm");
            $("#soundgood").click(function () {
                alert("soundgood");
            });
        });

        $('#aboutPage').live('pageinit', function (event) {
            alert('4.This page was just enhanced by jQuery Mobile!pageinit!!!');
        });
        $(document).bind("pageload", function (event, data) {
            alert('5.pageload!');
        });
        $('#aboutPage').live('pageshow', function (event) {
            alert('6.pageshow!');
        });
        $('#aboutPage').live('pageremove', function (event) {
            alert('7.pageremove!');
        });
        $('#aboutPage').live('pagehide', function (event) {
            alert('8.pagehide!');
        });

看到上面代码，相信大家一目了然了。对对话框事件的绑定用live或bind，解除绑定用die，或unbind。另外大家可以在事件pagecreate中看到对话框事件的注册。切记，只有在对话框创建后注册的事件才是有用的，也就是说如果你事先在Open dialog按钮所在的页面给dialog里面的元素注册的事件是没用的，因为dialog是后来以Ajax加载进去的。具体原理请参看官方文档。

3）第三个问题：对话框事件的注册。

上面我已稍微提及。为了避免打乱Open Dialog 所在页面（就叫主页面吧）的文档结构。你可以有两种做法，第一种将Open Dialog的样式设为none，将其隐藏。

<a href="dialog.htm" data-role="button" data-inline="true" data-rel="dialog" data-transition="pop">Open dialog</a>

第二种做法是，添加一个javascript函数，来动态往Dom结构中添加这样一个链接，这样你可以随时调用这个函数来打开一个对话框，注意回调函数的写法

//options has properties: href,transition
    //if you need callback method, you must add options.dialog parameter
    openDialog: function (options) {
        var href = options.href || "about:blank";
        var transition = options.transition || "none";
        $('body').append("<a id='tPushDialog' href='" + options.href + "' data-rel=\"dialog\" data-transition=\"" + options.transition + "\" style='display:none;'>Open dialog</a> ");
        $("#tPushDialog").trigger('click');
        $('body').find('#tPushDialog').remove();

        $("#" + options.dialog).live('pageshow', function (event) {
            if (typeof options.callback == 'function')
                options.callback();
        });

    }

另外一个要注意的问题是有的人注册的事件会响应多次，比如在第二个问题中给Sound Good注册的事件会响应多次，你或许感到很奇怪。其实是因为你每次文档加载的时候，你都给这个按钮注册了一个click事件，所以会弹出多次。正确的做法是，给dialog中的元素添加事件时，先unbind再bind。下面给大家一个例子。

再看看MessageDialog.htm的文档结构

<div data-role="dialog" id="MessageDialog" style="z-index: 999">
    <div data-role="header" data-theme="b">
        <div class="dialog_title1">
            Message Received</div>
        <input type="hidden" id="hiddenMessageId" />
    </div>
    <div data-role="content" data-theme="b">
        <div style="margin: 10px 5px 10px 5px;">
            <span id="spanMessage" style="font-weight: bold"></span>
        </div>
        <div id="messageContent">
            <ul style="margin-left: 5px;">
                <li>
                    <input type="button" data-inline="true" id="btnOk" value="Yes" data-rel="back" />
                    <input type="button" data-inline="true" id="Button1" value="No" data-rel="back" />
                </li>
            </ul>
        </div>
    </div>
</div>

大家慢慢体会，：）

本文链接

绝对定位与相对低位的应用

2012-02-14T09:39:00Z

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
    <style type="text/css">
    body,ul,div,li
    {
        padding:0px 0px 0px 0px;
        margin:0px 0px 0px 0px;
    }

    #container
    {
        width:300px;
        height:300px;
        background-color:#efefef;
        position:relative;
        border:1px solid #000000;
    }

    #left
    {
        float:left;
        position:absolute;
        border:1px solid #ff0000;
        bottom:23px;
        left:0px;
        right:80px;
    }

    #right
    {
        float:right;
        position:absolute;
        border:1px solid #ff0000;
        right:10px;
        bottom:23px;
    }

    #bottom
    {
        width:100%;
        height:23px;
        border:1px solid #ff0000;
        bottom:0px;
        position:absolute;
        left:0px;
    }
    .text
    {
        border:1px solid #000000;
        width:100%;
        margin:2px 2px 2px 2px;
        position:absolute;
        bottom:0px;
    }

    /*button 不用绝对地位，在手机浏览器上将会错位*/
    .button
    {
        border:1px solid #000000;margin:2px 2px 2px 2px;
        position:absolute;
        bottom:0px;
        right:0px;
     }
    </style>
</head>
<body>

     <div id="container">
        <div>
            <div id="left"><input type="text" class="text"/></div>
            <div id="right"><input type="button" value="button" class="button"/></div>
        </div>

</body>
</html>

本文链接

关于委托Lamda表达式等的一个小例子

2012-02-07T03:25:00Z

using System;
using System.Drawing;

public class Example
{
    public static void Main()
    {
        // Create an array of five Point structures.
        Point[] points = { new Point(100, 200),
            new Point(150, 250), new Point(250, 375),
            new Point(275, 395), new Point(295, 450) };

        // To find the first Point structure for which X times Y
        // is greater than 100000, pass the array and a delegate
        // that represents the ProductGT10 method to the Shared
        // Find method of the Array class.
        //第一种写法
        Point first = Array.Find(points, new Predicate<Point>(Example.ProductGT10));
        //第二种写法
        Point first = Array.Find(points, p => { return p.X * p.Y > 100000; });
        //第三种写法
        Point first = Array.Find(points, p => p.X * p.Y > 100000);
        //第四种写法
        Point first = Array.Find(points, delegate(Point p) { return p.X * p.Y > 100000; });
        //第五种写法
        Point first = Array.Find(points, ProductGT10);

        // Note that you do not need to create the delegate
        // explicitly, or to specify the type parameter of the
        // generic method, because the C# compiler has enough
        // context to determine that information for you.

        // Display the first structure found.
        Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);

        Console.Read();
    }

    // This method implements the test condition for the Find
    // method.
    private static bool ProductGT10(Point p)
    {
        if (p.X * p.Y > 100000)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

本文链接

重温.NET Remoting(四)

2011-09-09T07:05:00Z

(一) Remoting框架图

这是msdn上关于Remoting客户端与服务器端进行通信的示意图。客户端与服务端的通信是通过发送消息来实现的。消息的处理是由客户端，服务端创建的一系列的通信信道来处理的。客户端通过代理将消息的调用转换为IMessage，IMessage传入通信处理链，经过客户端FormatterSink转换为消息流，然后通过IClientChannelSink对消息进一步处理，然后进入TransportSink传输到服务端。服务端收到消息后，通过FormatterSink将流转换为消息，让远程对象进行处理。这种消息的处理流程统称为信道接收器（如格式化程序、传输或堆栈生成器接收器），但您可以自定义信道接收器链，以使用消息或流执行特殊任务。 每个信道接收器要么实现 IClientChannelSink，要么实现 IServerChannelSink。 客户端上的第一个信道接收器还必须实现 IMessageSink。 它通常实现 IClientFormatterSink（继承自 IMessageSink、IChannelSinkBase 和 IClientChannelSink），被称为格式化程序接收器，因为它将传入的消息转换为流（IMessage对象）。

信道接收器提供程序（实现 IClientChannelSinkProvider、IClientFormatterSinkProvider 或 IServerChannelSinkProvider 接口的对象）负责创建处理 .NET 远程处理消息的信道接收器。在激活远程类型时，将从信道中检索信道接收器提供程序，并在接收器提供程序上调用 CreateSink 方法，以检索链中的第一个信道接收器。

信道接收器负责在客户端和服务器之间传输消息。它们彼此链接而形成一条链。当在接收器提供程序上调用 CreateSink 方法时，该方法应执行下列操作：

· 创建一个信道接收器。

· 在链中的下一个接收器提供程序上调用 CreateSink。

· 确保下一个接收器和当前接收器链接在一起。

· 将其接收器返回调用方。

信道接收器负责将这些接收器上执行的所有调用转发给链中的下一个接收器，同时还应当提供一种机制，用来存储对下一个接收器的引用。

对于沿接收链发送哪些内容，信道接收器有很大的灵活性。例如，在发送实际的序列化原始消息之前协商身份验证的安全接收器可以截获完整的信道消息，用其自己的内容替换内容流，然后再沿着接收器链将内容流一直发送到远程应用程序域。在返回过程中，安全接收器可以截获答复消息，并与远程应用程序域中对应的安全接收器进行对话。协议一经达成，起始安全接收器便可以将原始内容流一直发送到远程应用程序域。

信道接收器链中的消息处理

一旦 .NET 远程处理系统找到可以处理消息的信道，该信道便将消息传递给格式化程序信道接收器，此过程通过调用 SyncProcessMessage（或 AsyncProcessMessage）来实现。格式化程序接收器创建传输标头数组，并对下一个接收器调用 GetRequestStream。此调用沿接收器链向下转发，并且任何接收器均可创建将被传递回格式化程序接收器的请求流。如果 GetRequestStream 返回 null 引用（在 Visual Basic 为 Nothing），格式化程序接收器将创建自己的接收器以用于序列化。此调用一经返回，即会序列化消息，并在接收器链的第一个信道接收器上调用相应的消息处理方法。

虽然接收器无法将数据写入流，但可以从流中读取数据，或沿所需位置传递新流。接收器还可以向标头数组添加标头（如果它们以前没有在下一个接收器上调用 GetRequestStream），并在将调用转发到下一个接收器之前将它们本身添加到接收器堆栈。（同步堆栈的作用是允许异步调用在其完成时对调用方进行回调。）当调用到达链末端的传输接收器时，传输接收器会将标头和序列化消息通过信道发送到服务器，在该服务器上，整个过程将反向进行。传输接收器（位于服务器上）从服务器端的流中检索标头和序列化消息，并通过接收器链转发它们，直至送达格式化程序接收器为止。格式化程序接收器反序列化该消息并将其转发给 .NET 远程处理系统，消息在此处被恢复为方法调用，并在服务器对象上被调用。

创建信道接收器链

若要创建新的信道链，必须实现和配置 .NET 远程处理系统，以识别 IServerChannelSinkProvider 或 IClientChannelSinkProvider 实现，您可以借助这两个实现来创建自定义的 IClientChannelSink 或 IServerChannelSink 实现，或检索链中的下一个接收器。您可以使用 BaseChannelSinkWithProperties 抽象类来帮助实现自定义的信道接收器。

生成信道接收器提供程序

在构造信道时，应用程序可以将服务器或客户端信道接收器提供程序作为参数来提供。信道接收器提供程序应当存储在一个链中，在向信道构造函数传递外部信道接收器提供程序之前，开发人员负责将所有的信道接收器提供程序链接在一起。为此，信道接收器提供程序实现了 Next 属性。下面的代码示例阐释如何生成客户端信道接收器提供程序。完整的示例可以在远程处理示例：信道接收器提供程序中找到。

格式化程序接收器

格式化程序接收器会将信道消息作为实现 IMessage 的对象而序列化为消息流。有些格式化程序接收器实现使用系统提供的格式化程序类型（BinaryFormatter和 SoapFormatter）。其他实现可以使用自己的方法将信道消息转换为流。

格式化程序接收器的作用是生成所需的标头并将消息序列化为流。在格式化程序接收器之后，消息将通过 SyncProcessMessage 或 AsyncProcessMessage 调用转发给接收器链中的所有接收器。在此阶段，消息已经序列化，不能再进行修改。

必须创建或修改消息的接收器本身一定要放在接收器链中的格式化程序之前。通过实现 IClientFormatterSink 可以轻松地实现这一点，从而告诉系统它已经具有对该格式化程序接收器的引用。然后可以将真实的格式化程序接收器放到该接收器链中后面的位置上。

在返回过程中，格式化程序接收器将消息流转换回信道消息对象（返回消息）。客户端上的第一个接收器必须实现 IClientFormatterSink 接口。当 CreateSink 返回信道时，返回的引用将被强制转换为 IClientFormatterSink 类型，以便可以调用 SyncProcessMessage 方法。请记住，IClientFormatterSink 是从 IMessageSink 派生而来的。如果强制转换失败，系统会引发异常。

自定义信道接收器

在客户端上，自定义信道接收器将被插入到格式化程序接收器与最后一个传输接收器之间的对象链中。通过在客户端或服务器信道中插入自定义信道接收器，您可以在下面所列的时间点之一处理 IMessage：

· 在表示为消息的调用被转换为流，并通过网络发送的过程中。

· 在流被从网络中取出，并发送至服务器或代理对象（在客户端）上远程对象前面最后一个消息接收器的过程中。

自定义接收器可以从流中读取数据或向流写入数据（具体取决于是传出调用还是传入调用），还可以根据需要将附加信息添加到标头。在此阶段，消息已被格式化程序序列化，不能再进行修改。当消息调用被转发到链末端的传输接收器时，传输接收器将标头写入流，并使用信道专用的传输协议将该流转发给服务器上的传输接收器。

传输接收器

传输接收器是客户端上链中的最后一个接收器，同时也是服务器上链中的第一个接收器。除了传输序列化的消息外，传输接收器还负责将标头发送到服务器，并在服务器返回调用时检索标头和流。这些接收器都内置于信道中，无法扩展。

(二) TransparentProxy与RealProxy

上面说到代理，不得不提到TransparentProxy（透明代理）与 RealProxy（真实代理），代理是本地对象与远程对象的桥梁，通过继承RealProxy，将方法的调用转换为基于Invoke(IMessage msg)的形式。// Create a custom 'RealProxy'.
public class MyProxy : RealProxy
{
String myURIString;
MarshalByRefObject myMarshalByRefObject;

[PermissionSet(SecurityAction.LinkDemand)]
public MyProxy(Type myType) : base(myType)
{
// RealProxy uses the Type to generate a transparent proxy.
myMarshalByRefObject = (MarshalByRefObject)Activator.CreateInstance((myType));
// Get 'ObjRef', for transmission serialization between application domains.
ObjRef myObjRef = RemotingServices.Marshal(myMarshalByRefObject);
// Get the 'URI' property of 'ObjRef' and store it.
myURIString = myObjRef.URI;
Console.WriteLine("URI :{0}", myObjRef.URI);
}

[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.Infrastructure)]
public override IMessage Invoke(IMessage myIMessage)
{
Console.WriteLine("MyProxy.Invoke Start");
Console.WriteLine("");

if (myIMessage is IMethodCallMessage)
Console.WriteLine("IMethodCallMessage");

if (myIMessage is IMethodReturnMessage)
Console.WriteLine("IMethodReturnMessage");

Type msgType = myIMessage.GetType();
Console.WriteLine("Message Type: {0}", msgType.ToString());
Console.WriteLine("Message Properties");
IDictionary myIDictionary = myIMessage.Properties;
// Set the '__Uri' property of 'IMessage' to 'URI' property of 'ObjRef'.
myIDictionary["__Uri"] = myURIString;
IDictionaryEnumerator myIDictionaryEnumerator =
(IDictionaryEnumerator) myIDictionary.GetEnumerator();

while (myIDictionaryEnumerator.MoveNext())
{
Object myKey = myIDictionaryEnumerator.Key;
String myKeyName = myKey.ToString();
Object myValue = myIDictionaryEnumerator.Value;

Console.WriteLine("\t{0} : {1}", myKeyName,
myIDictionaryEnumerator.Value);
if (myKeyName == "__Args")
{
Object[] myObjectArray = (Object[])myValue;
for (int aIndex = 0; aIndex < myObjectArray.Length; aIndex++)
Console.WriteLine("\t\targ: {0} myValue: {1}", aIndex,
myObjectArray[aIndex]);
}

if ((myKeyName == "__MethodSignature") && (null != myValue))
{
Object[] myObjectArray = (Object[])myValue;
for (int aIndex = 0; aIndex < myObjectArray.Length; aIndex++)
Console.WriteLine("\t\targ: {0} myValue: {1}", aIndex,
myObjectArray[aIndex]);
}
}

IMessage myReturnMessage;

myIDictionary["__Uri"] = myURIString;
Console.WriteLine("__Uri {0}", myIDictionary["__Uri"]);

Console.WriteLine("ChannelServices.SyncDispatchMessage");
myReturnMessage = ChannelServices.SyncDispatchMessage(myIMessage);

// Push return value and OUT parameters back onto stack.

IMethodReturnMessage myMethodReturnMessage = (IMethodReturnMessage)
myReturnMessage;
Console.WriteLine("IMethodReturnMessage.ReturnValue: {0}",
myMethodReturnMessage.ReturnValue);

Console.WriteLine("MyProxy.Invoke - Finish");

return myReturnMessage;
}
}

(三) IMessage

(四) IClientFormatterSinkProvider与IClientFormatterSink，IMessageSink

BinaryClientFormatterSinkProvider和SoapClientFormatterSinkProvider均实现了 IClientChannelSinkProvider接口，该接口用来生成客户端信道中的 IClientChannelSink

的实例对象BinaryClientFormatterSink和SoapClientFormatterSink来处理消息，及处理请求的数据流，我们来看看 IClientChannelSinkProvider及IClientChannelSink的方法

public interface IClientChannelSinkProvider

{

IClientChannelSinkProvider Next { get; set; }

IClientChannelSink CreateSink(IChannelSender channel, string url, object remoteChannelData);

}

IClientChannelSink的方法

public interface IClientChannelSink : IChannelSinkBase

{

IClientChannelSink NextChannelSink { get; }

void AsyncProcessRequest(IClientChannelSinkStack sinkStack, IMessage msg, ITransportHeaders headers, Stream stream);

void AsyncProcessResponse(IClientResponseChannelSinkStack sinkStack, object state, ITransportHeaders headers, Stream stream);

Stream GetRequestStream(IMessage msg, ITransportHeaders headers);

void ProcessMessage(IMessage msg, ITransportHeaders requestHeaders, Stream requestStream, out ITransportHeaders responseHeaders, out Stream responseStream);

}

因此如果我们需要自定义自己的消息处理，客户端可以实现IClientChannelSinkProvider及IClientChannelSink接口，然后通过注册或配置文件注册到消息处理链中。客户端上的第一个接收器必须实现 IClientFormatterSink 接口，因为在这里消息将被序列化为消息流。

(五) IServerFormatterSinkProvider与IServerChannelSink

而在服务端通过实现ISeverChannelSinkProvider的BinaryServerFormatterSinkProvider和SoapServerFormatterSinkProvider，生成消息处理的BinarySeverFormatterSink和SoapServerFormatterSink来对客户端发送过来的消息进行处理，这两个类实现了ISeverChannelSink，这个接口是服务器处理消息必须实现的接口，而ISeverChannelSinkProvider服务端消息处理对象提供者必须实现的接口

IServerChannelSinkProvider的方法

public interface IServerChannelSinkProvider

{

IServerChannelSinkProvider Next { get; set; }

IServerChannelSink CreateSink(IChannelReceiver channel);

void GetChannelData(IChannelDataStore channelData);

}

IServerChannelSink的方法

public interface IServerChannelSink : IChannelSinkBase

{

IServerChannelSink NextChannelSink { get; }

void AsyncProcessResponse(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers, Stream stream);

Stream GetResponseStream(IServerResponseChannelSinkStack sinkStack, object state, IMessage msg, ITransportHeaders headers);

ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream);

}

在服务端如果对消息处理进行扩展，这两个接口是必须实现的接口。

(六) IChannel

消息的传递可以通过HttpChannel，TcpChannel，IpcChannel来传递，关于信道的选择可以参考ms-help://MS.MSDNQTR.v90.chs/ws_fxremoting/html/c4959f26-a935-42fd-8dcf-0c35de5fb860.htm

(七) 扩展

(八) Aop

本文链接

EntLib缓存框架的实现

2011-08-29T09:54:00Z

(一) 缓存架构

这是官方文档的架构图，图中Cache引用了BackgroundScheduler与实际的有些异议，可以和我自己画的结合起来看。

客户端通过CacheManagerFactory获取配置文件所配置的CacheManager，CacheManager中引用了3个对象，Cache，ExpirationPollTimer，BackgroundScheduler，

Ø Cache是真正的缓存类，用于缓存项目的Add,Remove,并通过IBackingStore获取数据GetData，和保存数据Flush。Cache中保存的是CacheItem，CacheItem引用了ICacheItemExpition和ICahceItemRefreshAction，ICacheItemExpition用于缓存项目的过期策略，是否过期，过期时间等。ICahceItemRefreshAction用户缓存项目的刷新。

Ø CacheManager引用的ExpirationPollTimer通过一个Timer调用回调方法，调用BackgroundScheduler中的ExpirationTask的DoExpirations查找过期项，移除过期项

Ø ExpirationTask 和ScavengerTask都引用了 ICacheOperations，ICacheOperations用于缓存项目过期后缓存项目的操作，ScavengerTask用于标识缓存项目是否需要获取

(二) 缓存配置<configuration>
<configSections>
<section name="cachingConfiguration" type="Microsoft.Practices.EnterpriseLibrary.Caching.Configuration.CacheManagerSettings,Microsoft.Practices.EnterpriseLibrary.Caching" />
</configSections>

<cachingConfiguration defaultCacheManager="Default Cache Manager">
<backingStores>
<add name="inMemory"
type="Microsoft.Practices.EnterpriseLibrary.Caching.BackingStoreImplementations.NullBackingStore, Microsoft.Practices.EnterpriseLibrary.Caching" />
</backingStores>

<cacheManagers>
<add name="Default Cache Manager"
type="Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager, Microsoft.Practices.EnterpriseLibrary.Caching"
expirationPollFrequencyInSeconds="60"
maximumElementsInCacheBeforeScavenging="1000"
numberToRemoveWhenScavenging="10"
backingStoreName="inMemory" />
<add name="Loading Scenario Cache Manager"
type="Microsoft.Practices.EnterpriseLibrary.Caching.CacheManager, Microsoft.Practices.EnterpriseLibrary.Caching"
expirationPollFrequencyInSeconds="60"
maximumElementsInCacheBeforeScavenging="1000"
numberToRemoveWhenScavenging="10"
backingStoreName="inMemory" />
</cacheManagers>
</cachingConfiguration>
</configuration>

(三) 缓存使用

//获取默认的缓存配置ICacheManager primitivesCache;

primitivesCache = CacheFactory.GetCacheManager();

cache.Add()…

cache.Remove()…

或者获取指定的缓存配置readonly ICacheManager cache;

cache = CacheFactory.GetCacheManager("Loading Scenario Cache Manager");

cache.Add()…

cache.Remove()…

本文链接

重温.NET Remoting(三)

2011-08-16T13:44:00Z

这节谈谈.Net Remoting比较重要的部分，数据传递，这次我们在上一节的基础上，对数据契约做出如下修改

public interface IMyService
    {
        //1.返回一个字符串给客户端
        string SayHello(string name);
        //2.返回一个datatable给客户端
        DataTable GetTable();
        //3.返回一个PersonData的实例对象给客户端
        PersonData GetPerson();
        //4.从客户端传datatable到服务器端
        void ClientToServer(DataTable dt);
        //5.实例的集合
        IList<PersonData> GetPersons();
    }

大家可以看到，从服务端可以返回字符串，数据表，实例对象，以及实例的集合，并且4有一个方法是从客户端传入一个数据表到服务端，下面我们来看看服务端的简单实现

public class MyServiceImpl : MarshalByRefObject,ShareDLL.IMyService
    {
        public string SayHello(string name)
        {
            return string.Format(@" Message from Server :"+ name);
        }
        //返回一个datatable给客户端
        public DataTable GetTable()
        {
            //这个地方模拟一个datatable，实际可以从数据库中获得
            DataTable dt = new DataTable();
            dt.Columns.Add(new DataColumn("Id", typeof(string)));
            dt.Columns.Add(new DataColumn("Name", typeof(string)));
            DataRow row = dt.NewRow();
            row["Id"] = Guid.NewGuid().ToString().ToUpper();
            row["Name"] = "Tom";
            dt.Rows.Add(row);

            row = dt.NewRow();
            row["Id"] = Guid.NewGuid().ToString().ToUpper();
            row["Name"] = "Jack";
            dt.Rows.Add(row);

            return dt;
        }
        //返回一个PersonData的实例对象给客户端
        public ShareDLL.PersonData GetPerson()
        {
            return new ShareDLL.PersonData("Mike", 23);
        }

        //从客户端传datatable到服务器端
        public void ClientToServer(DataTable dt)
        {
            Console.WriteLine("datatable from client:" + dt.Rows[0][0].ToString());
        }

        //实例的集合
        public IList<ShareDLL.PersonData> GetPersons()
        {
            IList<ShareDLL.PersonData> list=new List<ShareDLL.PersonData>(2);
            list.Add(new ShareDLL.PersonData("Mike", 23));
            list.Add(new ShareDLL.PersonData("Tom", 25));
            return list;
        }

    }

实现后，我们开启服务端应用程序：

RemotingConfiguration.Configure("Server.exe.config",false);
Console.WriteLine("Server is Running...");
Console.Read();

接着我们开启客户端调用程序：

RemotingConfiguration.Configure("Client.exe.config", false);
            WellKnownClientTypeEntry[] types = RemotingConfiguration.GetRegisteredWellKnownClientTypes();
            if (types.Length > 0)
            {
                ShareDLL.IMyService service = (ShareDLL.IMyService)Activator.GetObject(types[0].ObjectType,
                    types[0].ObjectUrl);
                try
                {
                    //从服务端返回字符串
                    string returnString = service.SayHello("mike");
                    Console.WriteLine(returnString);
                    //从服务端返回datatable
                    DataTable dt = service.GetTable();
                    Console.WriteLine("DataTable from Server:" + dt.Rows[0][0].ToString());
                    //从客户端传datatable到服务器端
                    service.ClientToServer(dt);

                    //从服务端返回PersonData（实例对象）
                    ShareDLL.PersonData person = service.GetPerson();
                    Console.WriteLine("PersonData instance from server:" + person.ToString());
                    //实例的集合
                    IList<ShareDLL.PersonData> persons = service.GetPersons();
                    Console.WriteLine("list from server:"+persons.Count);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            else
                Console.WriteLine("no service reigstered");
            Console.Read();

下面我们分别看看服务调用的结果

客户端调用结果

服务端调用后的结果：

全部实例代码下载：http://files.cnblogs.com/jackhuclan/RemotingConfig.rar

本文链接

重温.NET Remoting(二)

2011-08-15T14:20:00Z

这节来谈谈关于Remoting的简单配置

服务端配置

<?xml version="1.0"?>
<configuration>
  <system.runtime.remoting>
    <application>
      <channels>
        <channel ref="tcp" port="9999"/>
      </channels>
      <service>
        <wellknown mode="Singleton" type="Server.MyServiceImpl,Server" objectUri="myservice.rem"/>
      </service>
    </application>
  </system.runtime.remoting>
</configuration>

服务端调用

RemotingConfiguration.Configure("Server.exe.config",false);
Console.WriteLine("Server is Running...");

当服务开启后，可以通过控制台查看端口是否开始监听，运行-》cmd-》netstat -a ，通过查看命令显示的信息，判断你所设置的服务是否开启

客户端配置

<?xml version="1.0"?>
<configuration>
  <system.runtime.remoting>
    <application>
      <channels>
        <channel ref="tcp"/>
      </channels>
      <client>
        <wellknown type="ShareDLL.IMyService,ShareDLL" url="tcp://localhost:9999/myservice.rem"/>
      </client>
    </application>
  </system.runtime.remoting>
</configuration>

客户端调用

更多关于Remoting的配置，可以参考其他

本文链接

重温.NET Remoting(一)

2011-08-14T02:36:00Z

.NET Remoting是一种分布式技术，当客户端调用远程服务端对象的时候，取得一个Proxy对象，对此对象的操作将被Formatter转换成SOAP或Binary消息，然后通过通信协议Http或者Tcp传到远程服务端。服务端将调用Dispatcher组件，将消息分发到不同的Message Sink对调用做出反应。

.NET Remoting对象的创建方式有两种，SAO(Server Activate Object)服务端激活和CAO(Client Activate Object)客户端激活，其中SAO可以通过RegisterConfiguration.RegisterWellKnownType将对象创建为WellKnownObjectMode.Singleton模式或WellKnownObjectMode.SingleCall模式。

其中前者将会对所有的调用请求启用同一个服务对象，而后者将对不同的请求启用不同的服务对象。SAO调用示例可以通过共享一个数据契约程序集（契约的实现不必提供给客户端）供Client和Server端调用。

Ø SAO调用示例

服务契约

using System;
using System.Collections.Generic;
using System.Text;

namespace ShareDLL
{
    public interface IMyService
    {
        string SayHello(string name);

    }

    [Serializable]
    public class PersonData
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        private int _age;

        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
        public PersonData(string name, int age)
        {
            this._name = name;
            this._age = age;
        }
    }

}

服务端

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpChannel chnl = new TcpChannel(9012);
            ChannelServices.RegisterChannel(chnl, false);

            //SingleCall方式
            RemotingConfiguration.RegisterWellKnownServiceType(typeof(MyServiceImpl),
                "myservice.rem",
                WellKnownObjectMode.SingleCall);

            //Singleton方式
            //RemotingConfiguration.RegisterWellKnownServiceType(typeof(MyServiceImpl),
            //    "myservice.rem",
            //    WellKnownObjectMode.Singleton);

            Console.WriteLine("Server is Running...");
            Console.Read();
        }
    }

    public class MyServiceImpl : MarshalByRefObject,ShareDLL.IMyService
    {
        public string SayHello(string name)
        {
            return string.Format(@" Message from Server :"+ name);
        }
    }
}

客户端

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpChannel chnl = new TcpChannel();
            ChannelServices.RegisterChannel(chnl, false);
            ShareDLL.IMyService service=(ShareDLL.IMyService)Activator.GetObject(typeof(ShareDLL.IMyService),
                "tcp://localhost:9012/myservice.rem");
            Console.WriteLine(service.SayHello("code6421"));
            Console.Read();
        }
    }
}

关于CAO创建对象，用三种方式，

Ø Share Implement共享数据契约与实现。即将契约的定义与实现放在一个程序集，然后供服务端和客户端引用。

Ø Soapsuds通过元数据生成供客户端使用的dll。即将契约的定义与实现放在一个程序集，然后通过通过工具将服务生成一个dll，供客户端引用。

Soapsuds –url:http://localhost:9012/myservice.rem?wsdl –oa:d:\share.dll，在应用此工具的时候，

/*如果要通过wsdl发布服务，需要公开一个httpChanel，
            *然后通过Soapsuds –url:http://localhost:9012/myservice.rem?wsdl –oa:d:\share.dll，
            *生成供客户端应用的dll
            */
            HttpChannel chnl = new HttpChannel(9012);
            ChannelServices.RegisterChannel(chnl, false);
            RemotingConfiguration.ApplicationName = "MyServer";
            RemotingConfiguration.RegisterWellKnownServiceType(typeof(CAO.ShareDLL.MyService),
                "myservice.rem",
                 WellKnownObjectMode.SingleCall);

Ø Client Object Factory，通过客户端调用服务端的对象工厂，创建服务对象。

契约层：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CAO.Factory.ShareDLL
{
    public interface IMyService
    {
        string SayHello(string name);
        ICAOObject CreateCAO(string name);

    }

    public interface ICAOObject
    {
        string Name { get; set; }
        string SayHelloCAO();
    }
}

服务端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Remoting.Channels.Http;

namespace CAO.Factory.Server
{
    class Program
    {
        static void Main(string[] args)
        {
            TcpChannel chnl = new TcpChannel(9012);
            ChannelServices.RegisterChannel(chnl, false);

            //SingleCall方式
            RemotingConfiguration.RegisterWellKnownServiceType(typeof(MyService),
                "myservice.rem",
                WellKnownObjectMode.SingleCall);

            Console.WriteLine("Server is Running...");
            Console.Read();
        }
    }

    public class MyService:MarshalByRefObject,ShareDLL.IMyService
    {
        public string SayHello(string name)
        {
            return string.Format("Hello {0}",name);
        }

        public ShareDLL.ICAOObject CreateCAO(string name)
        {
            return new MyCAOImpl(name);
        }
    }

    public class MyCAOImpl : MarshalByRefObject, ShareDLL.ICAOObject
    {
        private string _name;

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public string SayHelloCAO()
        {
            return string.Format("Hello {0}", this.Name);
        }

        public MyCAOImpl(string name)
        {
            this._name = name;
        }

    }
}

客户端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace CAO.Factory.Client
{
    class Program
    {
        static void Main(string[] args)
        {

            TcpChannel chnl = new TcpChannel();
            ChannelServices.RegisterChannel(chnl, false);
            ShareDLL.IMyService service = (ShareDLL.IMyService)Activator.GetObject(typeof(ShareDLL.IMyService),
                "tcp://localhost:9012/myservice.rem");

            ShareDLL.ICAOObject obj1 = service.CreateCAO("mike");
            Console.WriteLine(obj1.SayHelloCAO());
            Console.Read();
        }
    }
}

以上是《Framework的架构设计与应用》关于Remoting的读书笔记。全部源代码下载： http://files.cnblogs.com/jackhuclan/RemotingTest.rar，关于更多高深的话题，可以参考：http://www.cnblogs.com/rickie/category/5082.html

本文链接

关于WebBrowser.DrawToBitmap

2010-12-17T07:22:00Z

概述

最近在Winform的开发中用到了Flash动态图表FusionCharts Free，这是个开源的flash组件。商业版可以使用FusionCharts V3，免费版本的是FusionCharts Free v2.2。下载地址：http://www.fusioncharts.com/free/download/。大家可以去看看，效果还是非常炫的。商业版比免费版能够提供更多的图表，导出pdf，image，csv等功能，当然免费版这些功能大家就别指望了。

一般flash组件都是以flash的形式在网页中呈现的。因此如果要在Winform中Flash图表个人认为有两种方案。1. 利用WebBrowser控件，将url执行包含这个flash的网页。2.利用Flash的com组件shockwave Flash。第一种方式实现方式比较简单，第二种个人认为最好的是有Flex的组件作为容器，这样可以根据传递进来的参数显示不同的图表。

因为免费版没有导出pdf，image，csv等功能，所以只好自己去写了。而且是加载到WebBrowser控件，因此我对WebBrowser进行了扩展。目前常用的Flash图表都可以展示，导出pdf，image，excel，等格式。

相关图片预览

先上几张图片给大家一个直观点的认识

图1.导出的图片

图2.导出的pdf

遇到的问题

1. 如标题所说的关于WebBrowser.DrawToBitmap问题，因为此控件是没有这个方法的，但是你用了也不会出错，但是问题就来了，有时候可以导出图片有时候又不能，加载的网页里面不存在Ajax内容之类的。网上有不少对此问题的解决办法，但是所见之处基本都是错误的。一种普遍的做法如下：

public void WriteBmp(string bmpPath)
        {
            while (webbrowser.ReadyState != WebBrowserReadyState.Complete)
            {
                Application.DoEvents();
            }
            System.Drawing.Rectangle r = new System.Drawing.Rectangle(Point.Empty,
                new Size(int.Parse(webbrowser.Document.Body.GetAttribute("scrollWidth")), int.Parse(webbrowser.Document.Body.GetAttribute("scrollHeight"))));
            Bitmap bmp = new Bitmap(r.Width, r.Height);
            webbrowser.DrawToBitmap(bmp, r);
            bmp.Save(bmpPath);
            bmp.Dispose();
        }

结果就导致了时而可以时而不可以的问题。对这个问题，国外的站点有不错的解决方法：
1.http://bytes.com/topic/c-sharp/answers/605264-taking-screenshot-webbrowser-tab。
2. http://efreedom.com/Question/1-2434156/WebBrowser-DrawToBitmap-Methods

根据上面的方法，我将代码列出来给大家供参考，以上两种方法我用过了效果都很棒（上面的截图就是这样生成的）：

[DllImport("user32.dll")]
        private static extern bool PrintWindow(IntPtr hwnd, IntPtr hdcBlt, uint nFlags);

        public void WriteBmp(string bmpPath)
        {

            int screenWidth = webbrowser.Document.Body.ScrollRectangle.Width;
            int screenHeight = webbrowser.Document.Body.ScrollRectangle.Height;

            IntPtr myIntptr = webbrowser.Handle;
            int hwndInt = myIntptr.ToInt32();
            IntPtr hwnd = myIntptr;

            // Set hdc to the bitmap

            Bitmap bm = new Bitmap(screenWidth, screenHeight);
            Graphics g = Graphics.FromImage(bm);
            IntPtr hdc = g.GetHdc();

            // Snapshot the WebBrowser

            bool result = PrintWindow(hwnd, hdc, 0);
            g.ReleaseHdc(hdc);
            g.Flush();

            // Save the bitmap, if successful

            if (result == true)
                bm.Save(bmpPath);
        }

第2种方式：

public static class ApiConstants
    {
        public const int SRCCOPY = 13369376;
    }

    public static class Utilities
    {
        public static Image CaptureScreen()
        {
            return CaptureWindow(User32.GetDesktopWindow());
        }

        public static Image CaptureWindow(IntPtr handle)
        {

            IntPtr hdcSrc = User32.GetWindowDC(handle);

            RECT windowRect = new RECT();
            User32.GetWindowRect(handle, ref windowRect);

            int width = windowRect.right - windowRect.left;
            int height = windowRect.bottom - windowRect.top;

            IntPtr hdcDest = Gdi32.CreateCompatibleDC(hdcSrc);
            IntPtr hBitmap = Gdi32.CreateCompatibleBitmap(hdcSrc, width, height);

            IntPtr hOld = Gdi32.SelectObject(hdcDest, hBitmap);
            Gdi32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, ApiConstants.SRCCOPY);
            Gdi32.SelectObject(hdcDest, hOld);
            Gdi32.DeleteDC(hdcDest);
            User32.ReleaseDC(handle, hdcSrc);

            Image image = Image.FromHbitmap(hBitmap);
            Gdi32.DeleteObject(hBitmap);

            return image;
        }
    }

    public static class User32
    {
        [DllImport("user32.dll")]
        public static extern IntPtr GetDesktopWindow();
        [DllImport("user32.dll")]
        public static extern IntPtr GetWindowDC(IntPtr hWnd);
        [DllImport("user32.dll")]
        public static extern IntPtr GetWindowRect(IntPtr hWnd, ref RECT rect);
        [DllImport("user32.dll")]
        public static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDC);
    }

    public class Gdi32
    {
        [DllImport("gdi32.dll")]
        public static extern bool BitBlt(IntPtr hObject, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hObjectSource, int nXSrc, int nYSrc, int dwRop);
        [DllImport("gdi32.dll")]
        public static extern IntPtr CreateCompatibleBitmap(IntPtr hDC, int nWidth, int nHeight);
        [DllImport("gdi32.dll")]
        public static extern IntPtr CreateCompatibleDC(IntPtr hDC);
        [DllImport("gdi32.dll")]
        public static extern bool DeleteDC(IntPtr hDC);
        [DllImport("gdi32.dll")]
        public static extern bool DeleteObject(IntPtr hObject);
        [DllImport("gdi32.dll")]
        public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct RECT
    {
        public int left;
        public int top;
        public int right;
        public int bottom;
    }

    //如果是.net的扩展方法，如果你.net库版本比较高就去掉注释
    //public static class ControlExtensions
    //{
    //    public static Image DrawToImage(this Control control)
    //    {
    //        return Utilities.CaptureWindow(control.Handle);
    //    }
    //}

2.关于导出pdf的问题，大家可以去下载itextsharp开源的组件，学习文档可以参考

1. http://itextpdf.com/book/examples.php。java版的

2. http://www.cnblogs.com/islands/archive/2008/06/27/1231288.html

小结

以上是自己在Flash动态图表开发中一点小小的心得，写出来和大家一起分享，本文的目的给遇到类似问题的朋友一种解决方案，在你搜索完google，再搜索baidu发现都不能解决你问题的时候，或许此文能给你点帮助。

本文链接