博客园_heros

url不重复会造成asp.net的私有缓存占用内存过高

2011-12-27T02:57:00Z

asp.net中会对url做MapPath缓存，并且这个缓存的过期时间是never。当url中带有不重复参数时，会造成url的不重复，同时会造成asp.net的私有缓存中存储大量MapPathCacheInfo对象，缓存类型是System.Web.Cache.CacheEntry。在asp.net4正式版中提供了补丁可以对asp.net4版本上的这个问题进行修补http://support.microsoft.com/kb/2504047，修补后可以通过在System.web中添加配置项<hostingEnvironment urlMetadataSlidingExpiration="hh:mm:ss"/>来控制私有缓存的过期时间，建议将urlMetadataSlidingExpiration设置为00:00:00。
记录

本文链接

回“血泪八条---给中国IT教育培训机构” （因评论一再被银光小子删除，所以决定另开一文）

2011-03-08T03:18:00Z

因为评论内容一再被银光小子删除，所以决定另开一文。此为水文，一会本人会自行移除。

对于银光小子删评论的原因，呵呵，不想过多猜测，套句时下流行的话，你懂的。不过这种行为还是挺阴暗的。

首先,培训机构是商业机构，在这个浮躁的炒的年代，不要奢望一个商业机构能有多么的踏实。

学费高:是商业运作成本的问题，培训机构招进一名学员的成本平均在2000元+，另外加盟成本是学生交的钱的25%以上，一个培训中心就不可能靠低学费来生存。

教职水平低：这一点不能一概而论，但也是个实际存在的现象，出于成本考虑，培训机构给教员开的薪水基本上是底薪加课时提成，每个月没日没夜的上到200课时的课也就能挣个10k
。200课时是个什么概念，也就是30天每天讲6节课。可以自己试试，找个人坐下来喝茶聊天六个钟头你也受不了。一个有成熟开发经验的人，如果在公司正常的职业发展，
两三年也就轻轻松松差不多这个薪资(我说的是有成熟开发经验的人)。真有能力的谁愿意放弃自己的职业发展，教一辈子书呢。
本人不才，原来也做过教员，本人水平不行，但在中心能算是技术高手，也就可见一斑了。

夸大的广告：这一点也不是仅是培训行业的事，电视上的广告哪一个不夸大、哪一个挑不出虚假？另外不打广告也是不可能的事，很多品牌效应不是靠产品，而就是靠成功的广告。
培训机构的学员大部分就是被高考筛选下来的，整体学习素质就差一些，想在一年的时间就把他们打造成实力精英并以此深巷飘香，你觉得可能吗。

培训机构确有很多万恶之行为，但话说回来，你本可以不去参加，真的有理想有毅力，就像老赵说的那样自学成才，何苦如今在此抱怨呢。

软件开发很大的成本在于自身的修练和积累，即使是初学也需要通过大量的练习来沉淀自己的经验。而这些关键的东西，培训中心给不了。

请记住一点，成功的主导在于内因，不要过多的苛求外因。

如果你渴望光明，请先去除自己的阴暗。

重发一下被一再删除的评论内容。

呵呵，我是搞技术的，对招生一无所知。
另外请不要随便删除评论。 

重发:
另外每个人的路都是自己的选择，你本可以选择不去参加培训。
每个年轻人，如果你真的有毅力，有理想，就像老赵说的，自己自学成才。

本文链接

android gif 图片显示问题

2011-01-14T08:21:00Z

关于android显示gif图片网上有很多人都给出了解决方案。主要是两种，一种是使gif解码器在程序运行时解码gif，并将gif中帧提取并显示。还有一种就是预先用工具将gif帧打散成n张图，程序中切换加载来显示。两种方法都可以解决部分gif图片的显示问题。

在实际应用中，遇到一些很奇怪的gif图片，有一些帧是非完整图片，这些帧需要在前一些帧基础上合并显示。对于这样的图片逐帧提取单独显示时就会有问题。比如图片中一只小鸟在树林中飞行，那呈现的效果就成了第一张显示出树林，然后显示空白背景中一只小鸟，如果没有处理好小鸟所在帧的宽高和帧坐标，那么显示出的小鸟可能会被拉伸填满imageview区。

解决方案其实很简单，不能单张单张的呈现帧，要将帧连续起来，另外要将各帧的坐标及宽高信息全部提取并应用到帧的显示中。

gif文件转成字节流后，7、8字节代表gif框宽，9、10字节代表gif框高。在图像数据块的1、2字节表示x坐标偏移，3、4字节表示y坐标偏移，5、6和7、8分别表示当前帧的宽和高

      byte[] bytes = stream.toByteArray();
      int width = bytes[8]<8|bytes[7];//gif框宽
      int height = bytes[10]<8|bytes[9];//gif框高

在呈现图片时，用叠加的方式来显示图片，图片绘制时根据容器矩形、gif矩形、帧矩形信息来计算在容器中的绘图区，就不会有问题了。另外记得帧转换成bmp时，颜色取argb，这样可以保留透明等效果。

因为是公司项目代码不方便公开提供下载。

本文链接

注意TDes8 -> Expand方法

2010-12-25T13:42:00Z

今天在写程序时，用到了动态缓冲CBufFlat，在读取数据后想当然的使用了TDes8的Expand()方法将TDes8改为TDes16，当然程序报错了，模拟器直接退出，很显然程序发生严重错误。通过实践后发现Expand并非通过扩展内存区域来实现8bit转16bit，而是使用现有的描述符内存区域大小，只是进行了内存合并，两个8成了一个16，如果8位描述符中信息已经超出了最大长度一半，则会转换失败。Expand方法在使用时还可能因为内存地址非偶数地址而发生转换失败。

随笔记录，以防再错。也请大家指点。

本文链接

简单的字符串相似度计算

2010-12-19T07:05:00Z

计算Levenshtein 距离，再和较长字符串求比率

    /// <summary>
    /// Levenshtein Distance
    /// </summary>
    static class StringExt
    {
        /// <summary>
        /// 计算两个字符串的差异距离
        /// </summary>
        /// <param name="source">来源字符串</param>
        /// <param name="target">目标字符串</param>
        /// <returns>字符串差距</returns>
        public static int CalcDistance(this string source, string target)
        {
            int n = source.Length;
            int m = target.Length;
            if (m == 0) return n;
            if (n == 0) return m;
            var matrix = new int[n + 1, m + 1];
            for (int i = 1; i <= n; i++)
            {
                matrix[i, 0] = i;
            }
            for (int i = 1; i <= m; i++)
            {
                matrix[0, i] = i;
            }

            for (int i = 1; i <= n; i++)
            {
                var si = source[i - 1];
                for (int j = 1; j <= m; j++)
                {
                    var tj = target[j - 1];

                    int cost;
                    if (si == tj)
                        cost = 0;
                    else
                        cost = 1;

                    int above = matrix[i - 1, j] + 1;
                    int left = matrix[i, j - 1] + 1;
                    int diag = matrix[i - 1, j - 1] + cost;
                    matrix[i, j] = Math.Min(above, Math.Min(left, diag));
                }
            }
            return matrix[n, m];
        }

        /// <summary>
        /// 计算两个字符串的相似度
        /// </summary>
        /// <param name="source">来源字符串</param>
        /// <param name="target">目标字符串</param>
        /// <returns>相似度</returns>
        public static double CalcSimilarity(this string source, string target)
        {
            int n = source.Length;
            int m = target.Length;
            if (n == 0 || m == 0)
                return 0;
            int distance = source.CalcDistance(target);
            int max = Math.Max(n, m);
            return 1.0 * (max - distance) / max;
        }
    }

本文链接

[转]Carbide.VS 3.0.1的安装问题

2010-12-06T04:24:00Z

在Carbide.VS过程中一个常见的问题是检测不到已安装的SDK，特别是S60v3 FP2。这样的话，安装无法完成，恼人得很。找了很久才找到解决的办法。
步骤1：
打开注册表，找到"HKEY_LOCAL_MACHINE\SOFTWARE\Nokia\"，创建新项"Carbide.vs.30",然后在新项里添加字符串值"ForcePrereq" = "1"。（这一步是为了让安装程序略过SDK的检测）
步骤2：
安装完成后，下载文件S60_3rd_FP2_v2.xml到<drive:>\Program Files\Common Files\Symbian\SDK Descriptors\Nokia目录。（这一步是为了让Carbide.VS激活SDK）
到此，Carbide.vs就可以正常使用了;-)

http://files.cnblogs.com/heros/S60_3rd_FP2_v2.xml.zip

vs2005开发5th版本sdk的descriptor

5th sdk descriptor

本文链接

分享SharpDevelop Asp.net DevServer插件

2010-10-11T15:55:00Z

因为电脑让给老婆用，自己只有上网本一个，要装vs还是太吃力。SharpDevelop是个好的选择，但是有个问题，asp.net程序开发时运行和调试是个问题，老是要挂到iis上。索性把vs的DevServer移了过来。用插件的方式，增加了Debug in Browser和View in browser右键菜单，直接运行，方便许多。

For SharpDevelop 3.2

http://files.cnblogs.com/heros/SharpDevelopWebRunnerAddIn.rar

For SharpDevelop 4.0

http://files.cnblogs.com/heros/WebRunner4.rar

本文链接

算法题:装备合成

2010-09-28T08:40:00Z

你有一些合成元素对象，按指定数量的类型的合成元素可以合成一些装备，合成时候会有一些费用，合成的装备可以卖出，合成元素本身可以卖出。合成一个装备后，剩余元素个数只要还够合成，可以继续合成，也可以选择不合成。

要求所有东西卖出后收入最大化。

一个现实业务精简来的问题，背包、规划或自己的思路都可以。你试一试吧。

本文链接

asp.net treeview 复选后展开的bug

2010-07-15T10:00:00Z

第一次展开勾选了复选框的节点后。树的层次关系会乱掉。通过检查生成的html，发现原来是生成的html中缺少了用来完成缩进的div。不知道是不是asp.net4的bug。记得旧版本上没有问题的。

http://files.cnblogs.com/heros/ADTreeView.rar

本文链接

[转]WebService压缩

2010-03-09T01:14:00Z

原文:http://www.mastercsharp.com/article.aspx?ArticleID=86&&TopicID=7
Introduction
Web Services have already been standardized and its usage if definitely on the rise. Developers are quickly finding new and better ways to apply Web Services in their existing or new application designs. Reviewing many of the Web Services designs I have noticed that developers are increasingly performing heavy weight tasks (passing large SOAP messages) using Web Services. They are passing thousands of records through the Web Methods, there is nothing wrong with this approach, but the only problem (or nightmare) that comes forward is the size of data being passed around. Web Services use XML formatted SOAP messages to communicate but XML is a very verbose language and it can certainly add-up a lot to the size of data being transferred. Global bandwidth conditions do not currently warrant such massive data transfer easily.
One solution to this would be to compress (zip) the SOAP Message before sending it across the wire and then deflate (unzip) the data back on the client. This will help to reduce the amount of data transferred over the wire drastically! Luckily, the .NET Framework provides a very extensible Web Services API which makes it very easy to implement this functionality.

SOAP Extensions
The .NET Web Service API uses SOAP Extensions to provide hooks for developers into the messaging Web Service architecture, both on the client and server side. SOAP Extensions are used to inspect ( and modify ) the SOAP Message at each stage in the Web Services communication cycle.
To visualize the life cycle of a SOAP Request and Response, consider this scenario the client (of the Web Service) prepares the parameters (if any) and then calls the web method through the proxy class. Here the proxy class, inspects the method parameters, marshals them into XML format (serialization) and creates a SOAP Message. This SOAP message is then sent to the server (Web Service). The Web Service receives the SOAP message it converts (deserializes) the XML formatted parameters into the language data-types and then invokes the relevant method. Next, the method on the server-side executes, does the necessary processing and it may return a value. The return value is again marshaled (serialized) into a SOAP message and sent back to the client. The client proxy receives the SOAP message converts (deserializes) the XML value and returns it back to the calling class. In short both client and server carry the task of serialization and deserialization.
SOAP Extensions in ASP.NET allow you to inspect and alter the SOAP Message at all the stages of the XML Web Service Lifetime both at client and server side. This provides you with a very powerful way to extend the existing Web Service framework to suit your requirements.
You can learn more about the Anatomy of an XML Web Services Lifetime in the MSDN documentation.

SOAP Message Compression
Currently, there are no standards involving compression of SOAP Messages, hence we are on our own implement a suitable extension. I have chosen to use zip algorithm, you can feel free to choose your own algorithm, but since I am using industry standard algorithms I can be sure they will be supported across platforms and programming languages. I am using the #ziplip library from ICSharpCode which is a GPL based implementation for the standard ZIP, GZIP, TAR and BZip2 algorithms in C# (with source code) by Mike Krueger. A special thanks to Mike Krueger for developing such a wonderful library in C#!

Another important question that comes into mind is Should we compress the whole SOAP Message before we send it across the wire or parts of it? The up-coming new standards rely a lot on the SOAP Headers, hence we chosen not to compress the SOAP Headers since they might be needed in plain XML format for your Web Service to function correctly. So we just compress the contents of the SOAP Body and then send the message across the wire. Also remember we are implementing this extension on both the client and server side, so all communication between the client and server will be compressed.

Please note that you will have to download and install the #ziplib library on both the client and server for this extension to work correctly. Instructions for installation of the library are clearly outlined in the support documentation.

Let's Dive into some code.
In order to implement a SOAP Extension we need to define 2 classes, the first class extends the SoapExtention class and it contains all the processing logic for the extension. The class extends the SoapExtensionAttribute class which is the attribute used to apply on the Web Methods that need to support the SOAP Extension.

CompressionExtension
In the CompressionExtension class I check for the two stages, AfterSerialize and BeforeDeserialize. In the AfterSerialize stage, I inspect the contents of the SOAP Body and zip them, then the zipped stream is saved back into the SOAP Body and the SOAP Message is passed over the wire. On the other hand in BeforeDeserialize stage, I inspect the SOAP Body and retrieve the zipped contents, unzip them, and restore the original content. Later, the SOAP Message is sent to the Web Method for processing.
Also remember while zipping the XML nodes we get a binary array, but binary arrays are not correctly represented in XML Web Services, hence we have to use Base64 encoding to convert the binary array into appropriate format.

Update: As per Tobias Gansen's suggestion, the source code has been updated. Now I use InnerXml instead of InnetText to retrieve the contents of the SOAP Body, so complex obhjects like DataSet's are correctly handled.
25 October 2002 - As per Don Bunt's suggestion the code has been updated. Now all the WebMethod parameters get compressed correctly.

using System;

using System.IO;

using System.Text ;

using System.Web.Services;

using System.Web.Services.Protocols ;

using ICSharpCode.SharpZipLib.Checksums;

using ICSharpCode.SharpZipLib.Zip;

using ICSharpCode.SharpZipLib.GZip;

using System.Xml ;

 

namespace MasterCSharp.WebServices

{

  /// <summary>

  /// Summary description for ConpressionExtension.

  /// </summary>

  public class CompressionExtension : System.Web.Services.Protocols.SoapExtension

  {

    Stream oldStream;

    Stream newStream;

 

 

    public override object GetInitializer(LogicalMethodInfo methodInfo,

                               SoapExtensionAttribute attribute)

    {

      return attribute;

    }

 

    // Get the Type

    public override object GetInitializer(Type t)

    {

      return typeof(CompressionExtension);

    }

 

    // Get the CompressionExtensionAttribute

    public override void Initialize(object initializer)

    {

      CompressionExtensionAttribute attribute =

               (CompressionExtensionAttribute) initializer;

 

      return;

    }

 

    // Process the SOAP Message

    public override void ProcessMessage(SoapMessage message)

    {

      // Check for the various SOAP Message Stages 

      switch (message.Stage)

      {

 

        case SoapMessageStage.BeforeSerialize:

          break;

 

        case SoapMessageStage.AfterSerialize:

          // ZIP the contents of the SOAP Body after it has

          // been serialized

          Zip();

          break;

 

        case SoapMessageStage.BeforeDeserialize:

          // Unzip the contents of the SOAP Body before it is

          // deserialized

          Unzip();

          break;

 

        case SoapMessageStage.AfterDeserialize:

          break;

 

        default:

          throw new Exception("invalid stage");

      }

    }

 

    // Gives us the ability to get hold of the RAW SOAP message

    public override Stream ChainStream( Stream stream )

    {

      oldStream = stream;

      newStream = new MemoryStream();

      return newStream;

    }

 

    // Utility method to copy streams

    void Copy(Stream from, Stream to)

    {

      TextReader reader = new StreamReader(from);

      TextWriter writer = new StreamWriter(to);

      writer.WriteLine(reader.ReadToEnd());

      writer.Flush();

    }

 

 

    // Zip the SOAP Body

    private void Zip()

    {

      newStream.Position = 0;

      // Zip the SOAP Body

      newStream = ZipSoap(newStream);

      // Copy the streams

      Copy(newStream, oldStream);

    }

 

    // The actual ZIP method

    private byte[] Zip(string stringToZip)

    {

      byte[] inputByteArray = Encoding.UTF8.GetBytes(stringToZip);

      MemoryStream ms = new MemoryStream();

 

      // Check the #ziplib docs for more information

      ZipOutputStream zipOut = new ZipOutputStream( ms ) ;

      ZipEntry ZipEntry = new ZipEntry("ZippedFile");

      zipOut.PutNextEntry(ZipEntry);

      zipOut.SetLevel(9);

      zipOut.Write(inputByteArray, 0 , inputByteArray.Length ) ;

      zipOut.Finish();

      zipOut.Close();

 

      // Return the zipped contents

      return ms.ToArray();

    }

 

    // Select and Zip the appropriate parts of the SOAP message

    public MemoryStream ZipSoap(Stream streamToZip)

    {

      streamToZip.Position = 0;

      // Load a XML Reader

      XmlTextReader reader = new XmlTextReader(streamToZip);

      XmlDocument dom = new XmlDocument();

      dom.Load(reader);

      // Load a NamespaceManager to enable XPath selection

      XmlNamespaceManager nsmgr = new XmlNamespaceManager(dom.NameTable);

      nsmgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");

      XmlNode node = dom.SelectSingleNode("//soap:Body", nsmgr);

      // Select the contents within the method defined in the SOAP body

      node = node.FirstChild.FirstChild;

      // Check if there are any nodes selected

      while( node != null )

      {

        if( node.InnerXml.Length > 0 )

        {

          // Zip the data

          byte[] outData = Zip(node.InnerXml);

          // Convert it to Base64 for transfer over the internet

          node.InnerXml = Convert.ToBase64String(outData) ;

        }

        // Move to the next parameter

        node = node.NextSibling ; 

      }

      MemoryStream ms = new MemoryStream();

      // Save the updated data

      dom.Save(ms);

      ms.Position = 0;

 

      return ms;

    }

 

    // Unzip the SOAP Body

    private void Unzip()

    {

      MemoryStream unzipedStream = new MemoryStream();

 

      TextReader reader = new StreamReader(oldStream);

      TextWriter writer = new StreamWriter(unzipedStream);

      writer.WriteLine(reader.ReadToEnd());

      writer.Flush();

      // Unzip the SOAP Body

      unzipedStream = UnzipSoap(unzipedStream);

      // Copy the streams

      Copy(unzipedStream, newStream);

 

      newStream.Position = 0;

    }

 

    // Actual Unzip logic

    private byte[] Unzip(string stringToUnzip)

    {

      // Decode the Base64 encoding

      byte[] inputByteArray = Convert.FromBase64String( stringToUnzip ) ;

      MemoryStream ms = new MemoryStream(inputByteArray) ;

      MemoryStream ret = new MemoryStream();

 

      // Refer to #ziplib documentation for more info on this

      ZipInputStream zipIn = new ZipInputStream(ms);

      ZipEntry theEntry = zipIn.GetNextEntry();

      Byte[] buffer = new Byte[2048] ;

      int size = 2048;

      while (true)

      {

        size = zipIn.Read(buffer, 0, buffer.Length);

        if (size > 0)

        {

          ret.Write(buffer, 0, size);

        }

        else

        {

          break;

        }

      }

      return ret.ToArray();

    }

 

    // Unzip the SOAP Body

    public MemoryStream UnzipSoap(Stream streamToUnzip)

    {

      streamToUnzip.Position = 0;

      // Load a XmlReader

      XmlTextReader reader = new XmlTextReader(streamToUnzip);

      XmlDocument dom = new XmlDocument();

      dom.Load(reader);

 

      XmlNamespaceManager nsmgr = new XmlNamespaceManager(dom.NameTable);

      nsmgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");

      // Select the SOAP Body node 

      XmlNode node = dom.SelectSingleNode("//soap:Body", nsmgr);

      node = node.FirstChild.FirstChild;

 

      // Check if node exists

      while( node != null )

      {

        if( node.InnerXml.Length > 0 )

        {

          // Send the node's contents to be unziped

          byte[] outData = Unzip(node.InnerXml);

          string sTmp = Encoding.UTF8.GetString(outData);

          node.InnerXml = sTmp;

        }

        // Move to the next parameter

        node = node.NextSibling ; 

      }

 

      MemoryStream ms = new MemoryStream();

 

      dom.Save(ms);

      ms.Position = 0;

 

      return ms;

    }

 

  }

}

CompressionExtensionAttribute
This class defines an Attribute which will be used to mark-up Web Methods that need to be compressed. This class inherits the SoapExtensionAttribute class and overrides its ExtensionType and Priority properties.

using System;

using System.Web.Services;

using System.Web.Services.Protocols;

 

namespace MasterCSharp.WebServices

{

 

  /// <summary>

  /// Summary description for CompressionExtensionAttribute.

  /// </summary>

  // Make the Attribute only Applicable to Methods

  [AttributeUsage(AttributeTargets.Method)]

  public class CompressionExtensionAttribute : SoapExtensionAttribute

  {

 

    private int priority;

 

    // Override the base class properties

    public override Type ExtensionType

    {

      get { return typeof(CompressionExtension); }

    }

 

    public override int Priority

    {

      get

      {

        return priority;

      }

      set

      {

        priority = value;

      }

    }

 

  }

}

Code Compilation
Once you have the CompressionExtension.cs and CompressionExtensionAttribute.cs files ready, its time to compile them and convert them into a library. If you use VS.NET then you need to Add Reference to the System.Web.Services, System.Xml and SharpZipLib assemblies and compile the project. If you are manually compiling the files, then following compilation string:
csc /t:library /out:CompressionExtension.dll /r:SharpZipLib.dll CompressionExtension.cs CompressionExtensionAttribute.cs

This will produce the CompressionExtension.dll library. Now you can use this library in your clients and Web Services to enable compression extension. Note: Remember the clients and servers will also need to install the SharpZibLib.dll library also for this extension to work!

Sample Web Service
Our Compression Extension is ready for usage. I will create a simple Web Service which will demonstrate the usage of the Compression Extension, note the goal here is show the usage of the Compression Extension and not to teach how to create and deploy Web Services. If you want to learn more about Web Service basics please read this article.

I am using the Pubs sample database which installs with MSDE 2000 (SQL Server), just because I want to return a lot of data for testing purpose. But the Compression Extension is in no way tied to the database, it can be applied on any Web Method. As a matter of fact the Compression Extension does not even dictate there method parameter and return parameter data type. Hence you can apply this extension on any Web Method no matter what parameters / return types it uses.
In the listing below, I have defined a basic Web Service that returns a string containing the XML representation of the Authors, Titles and Publishers tables from the Pubs database.
There are only two changes; Firstly, I have referenced the MasterCSharp.WebServices namespace that contains the Compression Extension. Secondly, I have applied the Compression Extension on the GetDetails Web Method. That's all you need to do!!! It just can't get any simpler than this :).
While deploying the Web Service, you should ensure the SharpZipLib assembly has been registered in the GAC, alternatively you can also copy the library into the BIN directory of the Virtual Directory hosting this Web Service. Also don't forget to copy the CompressionExtension.dll library into BIN directory of the Virtual Root hosting this Web Service.

One important point to be noted is that we have applied a SOAP Extension, and this SOAP Extension is called only when a SOAP call is made to a Web Method. Hence if we are making HTTP GET / POST calls the Compression Extension is NOT in effect. Hence when we check the Web Service in Internet Explorer using the ASP.NET rendered test interface, you cannot see any compressed output.

<%@ WebService class="PubsService" %>

 

using System.Web.Services;

using MasterCSharp.WebServices ;

using System.Data ;

using System.Data.SqlClient ;

 

public class PubsService {

 

  [WebMethod]

  [CompressionExtension]

  public string GetDetails() {

 

    // Replace with the connection string to connect to your database

    SqlConnection myCon = new SqlConnection("server=(local)\\NetSDK;database=pubs;" ;

                               +Trusted_Connection=yes");

    SqlDataAdapter myCommand1 = new SqlDataAdapter("SELECT * FROM Authors", myCon);

    SqlDataAdapter myCommand2 = new SqlDataAdapter("SELECT * FROM Titles", myCon);

    SqlDataAdapter myCommand3 = new SqlDataAdapter("SELECT * FROM Publishers", myCon);

 

    DataSet ds = new DataSet();

    myCommand1.Fill(ds, "Authors");

    myCommand2.Fill(ds, "Titles");

    myCommand3.Fill(ds, "Publishers");

 

    return ds.GetXml() ;

  }

 

}

Test Web Service Client
In order to consume our PubsService I create a console based test client. In VS.NET you can create a new Console Project and then Add Web Reference to the PubsService and Add Reference to the CompressionExtension.dll library. Remember even method parameters sent from the client are compressed, hence you need to reference the Compression Extension library even at the client side.
In case of manual class creation, use the WSDL tool to generate a Proxy Class for the PubsService (replace the URL to the Web Service as per your setup):
wsdl http://localhost/PubsService/PubsService.asmx?WSDL

This creates a PubsService.cs Proxy Class file. Now let's create the Pubs Test Application using this proxy class. The listing below shows the code for the PubsTestApp. In this test application, I just make an instance of the Proxy class and call a Web Method. The value returned by the Web Service is saved to a file (so I can measure the bytes returned) and also printed on the console screen. Compile this application using the following compilation string:
csc /out:PubsTestApp.exe PubsService.cs PubsTestApp.cs

using System;

using System.IO ;

 

public class PubsTestApp

{

  public static void Main()

  {

    // Create an instance of the Proxy Class

    PubsService pws = new PubsService();

    // Open a StreamReader to a local file

    // This file will be used to log the return value

    // of the SOAP call

    StreamWriter sw = new StreamWriter( "log.txt" );

    // Call the Web Method and write the return value to file

    sw.Write( pws.GetDetails() ) ;

    sw.Close();

    // Call the Web Method again and write value to Console

    Console.WriteLine( pws.GetDetails() ) ;

 

    Console.WriteLine();

    Console.WriteLine("Hit Enter to Close Window!");

    Console.ReadLine();

  }

}

Once the application is compiled we call the PubsTestApp, it runs and shows some garbage characters, this output is even saved to the log.txt file. In reality what's shown is not garbage, but its the Base 64 encoding of the zipped data. Open Windows Explorer and observe the file size of the file log.txt, its approximately 4,864 bytes on my computer. This is the compressed data that's been sent to the client.

Next, you need to apply the the Compression Extension to the Proxy Class, so that you can receive normal output (unzipped data) from the Web Service. This is the step you would normally be taking right after generating the Proxy Class. Open the PubsService.cs proxy class file and add the [CompressionExtension] attribute above the public string GetDetails() method definition. Also reference the MasterCSharp.WebServices namespace which contains the Compression Extension. Once you apply the attribute, re-compile the PubsTestApp this time using the following compilation string:
csc /out:PubsTestApp.exe /r:CompressionExtension.dll PubsService.cs PubsTestApp.cs

Note: The CompressionExtension.dll library should be in the same directory we are compiling the application and the SharpZipLib.dll library should also be appropriately installed on the client.

Now run the PubsTestApp again, this time correct XML output is shown on the console screen, indicating the extension works on both ends seamlessly. Observe the size of the log.txt file again and this time its around 15,908 bytes, this is the amount of data that would have been passed if we did not use compression. Hence the Compression Extension has achieved almost 30% size reduction in the SOAP Messages used to communicate between the client and the server. Although, this compression ratio will vary on compression algorithm and the type of data you are compressing.

Conclusion
This article provides a practical SOAP Extension that can be used in any kind of Web Services, to utilize network resources better. In this article I not only highlighted the creation and deployment of a SOAP Extension in .NET, but I also silently displayed how to pass binary data using Web Service i.e. using Base 64 Encoding. If you are wondering if this method would still let your Web Service interop with other platforms and programming languages, well I haven't worked with other toolkits, but I am sure, they would definitely allow you to manipulate the SOAP Message. And since we are using standard ZIP algorithms, I don't see a huge barrier to the usage of this Web Service across different platforms and programming languages. If some of you get a chance to test this, please do let me know!!

本文链接