国产精品无码亚洲精品2021 ,最新国产AV无码专区亚洲,亚洲视频免费观看

微��Y为VS.net��d��单元��试功能

dennis — Mon, 09 Apr 2007 00:37:00 GMT

开源工具已�l�有NUnit�Q�微软这�ơ给VS增加的单元测试功能不知道是不是直接借鉴NUnit�Q�不�q��M��是好事，�q�集成了静态分析和代码覆盖工具�{�，值的��小期待下。从�q�点上看�Q�单元测试已�l�非常深入�h心咯。消息来�?a >infoq中文�?/a>

dennis 2007-04-09 08:37 发表评论

dennis — Mon, 02 Apr 2007 09:29:00 GMT

二叉查找树（binary search tree)

1�Q�概念：对于树中的每个节点n�Q�其左子节点中保存的所有数值都��于n保存的数��|��叛_��节点保存的数值都大于n保存的数倹{�?/p>

2�Q�二叉查找树可以实现更�ؓ优越的查找性能�Q�主要实现方式有数组和链表结构，相比较而言�Q�链表实现更为容易，因�ؓ数组实现删除和添加功能需要移动数�l�元素（如填补删除空位等�Q?/p>
今天下午在打印问题搞定后用C#实现了一下，比java版本比较有趣的��用C#的delegate来代曉K��历二叉树时的visit�Ҏ(gu��)��Q�这样一来可以在遍历时对节点�q�行你所惌��的�Q何操作。我们知道C#的delegate是类型化的函数指针，而C++的函数指针可以模仿动态语�a�的闭包或者匿名函数。这里也有这��L��味道�?br>
代码如下�Q�只实现了整数型的，节点定义�Q?br>

  public  class BSTIntNode
    {
        public int value;
        public BSTIntNode left;
        public BSTIntNode right;

        public BSTIntNode(int value, BSTIntNode left, BSTIntNode right)
        {
            this.value = value;
            this.left = left;
            this.right = right;
        }

        public BSTIntNode(int value)
        {
            this.value = value;
            this.left = null;
            this.right = null;
        }
    }

然后定义一个Delegate�Q�作为遍历时的访问方法：

public delegate void Visit(BSTIntNode node);

然后��是二叉树的实现�Q�删除算法只实现了复制删除法�Q?br>

public class BSTIntTree
    {
        protected BSTIntNode root;

        public Visit visit;

        public BSTIntTree()
        {
            this.root = null;
        }

        private BSTIntNode Search(BSTIntNode node, int el)
        {
            while (node != null)
            {
                if (el == node.value)
                    return node;
                else if (el < node.value)
                    node = node.left;
                else
                    node = node.right;
            }
            return null;
        }

        //查找
        public BSTIntNode Search(int el)
        {
            return Search(root, el);
        }

        //�q�度优先遍历,利用队列实现,至上而下�Q�至左而右
        public void BreadthFirst()
        {
            BSTIntNode p = root;
            Queue queue = new ListQueue();
            if (p != null)
            {
                queue.Enqueue(p);
                while (!queue.IsEmpty())
                {
                    p = (BSTIntNode)queue.Dequeue();
                    visit(p);
                    if (p.left != null)
                        queue.Enqueue(p.left);
                    if (p.right != null)
                        queue.Enqueue(p.right);
                }
            }
        }

        //深度优先遍历�Q�递归实现�U�序�Q�中序和后序

        //先序
        protected void PreOrder(BSTIntNode p)
        {
            if (p != null)
            {
                visit(p);
                PreOrder(p.left);
                PreOrder(p.right);
            }
        }

        public void PreOrder()
        {
            PreOrder(root);
        }
        //中序
        protected void InOrder(BSTIntNode p)
        {
            if (p != null)
            {
                InOrder(p.left);
                visit(p);
                InOrder(p.right);
            }
        }

        public void InOrder()
        {
            InOrder(root);
        }

        //后序
        protected void PostOrder(BSTIntNode p)
        {
            if (p != null)
            {
                PostOrder(p.left);
                PostOrder(p.right);
                visit(p);
            }
        }

        public void PostOrder()
        {
            PostOrder(root);
        }

        //插入节点操作
        public void Insert(int el)
        {
            BSTIntNode p = root, prev = null;

            //查找节点位置
            while (p != null)
            {
                prev = p;
                if (p.value < el)
                    p = p.right;
                else
                    p = p.left;
            }

            if (root == null)  //�I�树
                root = new BSTIntNode(el);
            else if (prev.value < el)   //大于节点�Q�插入右子树
                prev.right = new BSTIntNode(el);
            else
                prev.left = new BSTIntNode(el);
        }

        //复制删除法的实现�Q�归�q�删除法可能改变树的高度
        public void Delete(int el)
        {
            BSTIntNode node, p = root, prev = null;

            //查找节点位置
            while (p != null&&p.value!=el)
            {
                prev = p;
                if (p.value < el)
                    p = p.right;
                else
                    p = p.left;
            }
            node = p;
            if (p != null && p.value == el)
            {
                if (node.right == null)
                    node = node.left;
                else if (node.left == null)
                    node = node.right;
                else
                {
                    BSTIntNode temp = node.left;
                    BSTIntNode previous = node;
                    while (temp.right != null)  //查找左字节数的最叛_��节点
                    {
                        previous = temp;
                        temp = temp.right;
                    }
                    node.value = temp.value;
                    if (previous == node)
                        previous.left = temp.left;
                    else
                        previous.right = temp.left;
                }
                if (p == root)
                    root = node;
                else if (prev.left == p)
                    prev.left = node;
                else
                    prev.right = node;
            }
            else if (root != null)
            {
                Console.WriteLine("没有扑ֈ�节点�Q�{0}", el);
            }
            else
                Console.WriteLine("树�ؓ�I�！");
        }

    }

注意�Q�在树中我们�l�持了一个Visit的delegate�Q�看看��用方法：

public static void Main(string[] args)
        {
           BSTIntTree tree=new BSTIntTree();
           int []num={10,20,6,12,23,15,8};
           for (int i = 0; i < num.Length; i++)
               tree.Insert(num[i]);
           //��d��遍历处理函数�Q�可以有多个
           tree.visit += new Visit(printNode);

           Console.WriteLine("�q�度优先遍历");
           tree.BreadthFirst();
           Console.WriteLine("先序");
           tree.PreOrder();
           Console.WriteLine("中序");
           tree.InOrder();
           Console.WriteLine("后序");
           tree.PostOrder();

           tree.Delete(8);
           tree.Delete(15);
           Console.WriteLine("删除后广度优先遍�?/span>");
           tree.BreadthFirst();

        }
        public static void printNode(BSTIntNode node)
        {
            Console.WriteLine("讉K��节点:{0}", node.value);
        }

可以看到�Q�C#的delegate机制非常有趣�Q�如果在java中恐怕需要用inner class来实��C��?br>

dennis 2007-04-02 17:29 发表评论

C#实现栈和队列

dennis — Fri, 30 Mar 2007 01:44:00 GMT

有了前一��?a href="/killme2008/archive/2007/03/29/107261.html">C#链表的实�?/a>�Q�实现栈和队列易如反掌�?br />
栈，利用单向链表实现�Q?br />

public abstract class AbstractStack
    {
        public abstract Object Pop();
        public abstract void Push(Object obj);
        public abstract bool IsEmpty();
        public abstract Object Top();
        public abstract void Clear();
    }

    public class Stack : AbstractStack
    {
        private SList list;
        public Stack()
        {
            list = new SList();
        }
        public override bool IsEmpty()
        {
            return list.IsEmpty();
        }
        public override void Push(Object obj)
        {
            list.Push(obj);
        }
        public override object Pop()
        {
            return list.Pop();
        }
        public override object Top()
        {
            return list.getTail();
        }
        public override void Clear()
        {
            list.Clear();
        }
    }

队列的实玎ͼ�通过双向链表实现�Q�对于环形数�l�的实现请参考�?a href="/killme2008/archive/2007/02/20/100239.html">数组�l�构之栈与链�?/a>》：

public interface Queue
    {
        bool IsEmpty();
        void Enqueue(Object obj);
        Object Dequeue();
        Object First();
    }

    public class ListQueue:Queue
    {
        private LinkedList list;
        public ListQueue()
        {
            list = new LinkedList();
        }

        public bool IsEmpty()
        {
            return list.IsEmpty();
        }

        public void Enqueue(Object obj)
        {
            list.Push(obj);
        }
        public Object Dequeue()
        {
            return list.Shift();
        }

        public Object First()
        {
            return list.getHead();
        }
    }

dennis 2007-03-30 09:44 发表评论

C#实现链表

dennis — Thu, 29 Mar 2007 09:02:00 GMT

摘要: C#实现单向和双向链表�?nbsp; 阅读全文

dennis 2007-03-29 17:02 发表评论

dennis — Wed, 28 Mar 2007 09:55:00 GMT

今天看到一�D�介�l�C#实现代理模式的代码，使用��C��MarshalByRefObject。那�?/span>MarshalByRefObject到底是什么东西呢�Q�简单来�Ԍ��l�承此类的对�?/span>可以跨越应用�E�序域边界被引用�Q�甚臌��q�程引用。远�E�调用时�Q�将产生一个远�E�对象在本地的透明代理�Q�通过此代理来�q�行�q�程调用。一��很好的解释文章�Q�来自http://dudu.cnblogs.com/archive/2004/03/04/2182.html

问：

打扰一下，请问MarshalByRefObject中的"Marshal"应该怎样理解�Q?/span>

回复�Q?/span>

按照package的意思理�?/span>—�?/span>当一个对象需要长途跋涉到另一个环境中�Ӟ��需要将�?/span>marshal成一个可以传输的形态（比如�?/span>.NET Remoting中对象将被打包成一�?/span>serializable�?/span>ObjRef实例—�?/span>�q�个ByRef��是�?/span>ObjRef�q�种形态）�Q�同理，当打包以后传输到目标地点�Q�还要执�?/span>unmarshal的操作将其还原�ؓ内存中的对象。：�Q?/span>

问：

谢谢�Q?/span>

MarshalByRefObject是不是可以这��L��解：对被引用的对象进�?/span>Marshal。如果按�?/span>package的意思理解，�?/span>package的过�E�是怎样的？

MSDN上这栯��Q?/span>

MarshalByRefObject是通过使用代理交换消息来跨应用�E�序域边界进行通讯的对象的基类.

MarshalByRefObject对象在本地应用程序域的边界内可直接访问。远�E�应用程序域中的应用�E�序首次讉K��MarshalByRefObject�Ӟ��会向该远�E�应用程序传�?/span>代理。对该代理后面的调用��封送回�ȝ��在本地应用程序域中的对象�?/span>

�?/span>Marshal中，上面所说的代理是什么？有什么用�Q?/span>

MSDN上还讲到�Q?/span>

当跨应用�E�序域边界��用类型时�Q�类型必��L��?/span>MarshalByRefObject�l�承的，而且�׃��对象的成员在创徏它们的应用程序域之外无法使用�Q�所�?/span>不得复制对象的状�?/span>�?/span>

既然对象的状态不能传递过去，那传递这个对象又有何意义�Q?/span>

�W�一�ơ去理解MarshalByRefObject�Q�有的问题可能提的比较肤��，��h��指点�?/span>

回复�Q?/span>

MarshalByRefObject是所有可以在AppDomain边界外部讉K��的对象的基类�Q�重心不�?/span>marshal�Q�而是object�Q�即object that could be marshaled by reference�Q�也��是可以通过Ref�Q�实际上�?/span>ObjRef对象�Q�的机制�q�行�?/span>��?/span>�?/span>�Q?/span>MSDN中文版对marshal一词的��译�Q�的对象。封送的行�ؓ是由代理来做的，�q�里说的代理��是我文章中讲过�?/span>.NET Remoting的真实代理（�?/span>RemotingProxy�Q�。真实代理不是有一�?/span>Invoke()�Ҏ(gu��)��吗？当你透过对一�?/span>MBRO的透明代理讉K��该对象的�Ҏ(gu��)��Ӟ��透明代理��把��Z��堆栈的方法调用�{换�ؓ�Ҏ(gu��)��调用消息�Q?/span>IMethodCallMessage�Q��ƈ转发�l�真实代理（�?/span>Remoting的场合中也即RemotingProxy�Q�，�?/span>RemotingProxy的�Q务就是把对象��送�ƈ�q�同�Ҏ(gu��)��调用消息一赯��{发给�q�程应用�E�序域；到达目的��C��后的操作�c�M��Q�远�E�应用程序域中的监听方当收到发来的方法调用消息时�Q�先取出��送好�?/span>ObjRef�Q�这个对象里面保存着发来调用的那个对象！�Q�，��其�l�封�Q?/span>unmarshal�Q��ؓ本地的对象，�q�获得其透明代理�Q�然后就可以把方法调用消息在转换回基于堆栈的调用发送给�q�个对象�?/span>

对象是在本地�l�护的，但是�Ҏ(gu��)��可以在远�E�调用。你比如说一�?/span>web应用�E�序�Q�你是通过本地的浏览器�q�程讉K��q�个应用�E�序�Q�但是应用程序的状态不会由你的��览器负责（所以你只是在访问这个应用程序提供给你的功能而已�Q�你�q�没于拥有应用程序本�w�，包括其所有数据）�Q�你只是发送一个个的请求，服务器告诉你处理的结果。在Remoting�? 也是一��P��当你获得一个远�E�对象的时候，你实际上只拥有对�q�个对象的一个远�E�引用，虽然你可以调用它的方法，但实际上�q�些操作都是发生在远�E�的�Q�就是前�? 讲过的过�E�）�Q�你只是传入了一些参敎ͼ�得到了一个结果，但对象的状态还是在�q�程�l�护的（换句话说�Q�对象本�w�也��是对象的所有状态�ƈ没有被往�q�传递，传递的只是传入传出的参�?/span>—�?/span>当然�Q�如果参数是一�?/span>MBRO的话�Q�还是传递对象被��送的引用�Q��?/span>

也许应该�l�你准备一个好理解的例�?/span>…�?/span>你就会豁然开朗了。：�Q?/span>

问：

我这��L��理解对不对？

一般的对象与从MarshalByRefObject�l�承的对象区别是�Q?/span>

一般的对象只能在本地应用程序域之内被引用，�?/span>MarshalByRefObject对象可以跨越应用�E�序域边界被引用�Q�甚臌��q�程引用�?/span>

回复�Q?/span>

Exactly! 当对象跨�?/span>AppDomain边界的时候，实际上只是它的一个引用（ObjRef�Q�。你比如说吧�Q?/span>

public class LocalObject
{

public void CallRemoteObject(MarshalByRefObject mbro)
{
Console.WriteLine(mbro.ToString());

}
}

当传入一个在本地创徏�?/span>mbro对象�Ӟ��ToString()�Ҏ(gu��)��是直接发送给对象的；而当mbro是通过Remoting创徏的远�E�对象的话，实际上它只是一个包含有已经marshal好的ObjRef的透明代理�Q?/span>ObjRef里面有什么？对象实例�?/span>URI�Q�所以当你调用这个远�E�对象时�Q�相当于向这个远�E�端口（tcp://remoteServer/xxxx.rem�Q�发送方法调用消息而已。只不过透明代理隐藏了对象位�|�的概念�Q��?/span>RemotingProxy真实代理则是实际上处理远�E�方法调用和对象��送的中枢对象�?/span>

dennis 2007-03-28 17:55 发表评论

体验rails1.2的REST风格

dennis — Tue, 20 Mar 2007 12:04:00 GMT

REST�q�个名词已经听过�怹��Q�在javaeye的ruby版上也看��C��的讨论�Q�一开始是搞不明白的，��g��跟webservice有关。今天读了《RESTfull Rails Development》和几篇介绍REST的文章开始有�Ҏ(gu��)��白。REST 是英�?Representational State Transfer 的羃写，有中文翻译�ؓ“具象状态传输”。读�q�篇文章�?a >学习REST》对于初�ơ接触REST的�h来说更好理解�?p> 我们�?Web 应用中处理来自客��L��的请求时�Q�通常只考虑 GET �?POST �q�两�U?HTTP ��h��Ҏ(gu��)��。实际上�Q�HTTP �q�有 HEAD、PUT、DELETE �{�请求方法。而在 REST 架构中，用不同的 HTTP ��h��Ҏ(gu��)��来处理对资源�? CRUD�Q�创建、读取、更新和删除�Q�操作：

POST: 创徏
GET: ��d��
PUT: 更新
DELETE: 删除

�l�过�q�样的一番扩展，我们对一个资源的 CRUD 操作��可以通过同一�?URI 完成了。需要注意的是REST的核心就是资源（resources�Q�这个概��c��我们所说的webservice是一�U�徏立在http协议上的�q�程调用�Q�而REST��是把远�E�调用抽象成对远�E�资源的CRUD的操作，正好可以用HTTP的PUT GET POST DELETE来对应，而不是重新发明一个协议（比如soap�Q�简单对象访问协议）。REST与AJAX的流行，甚至�q�至设计模式的兴��P��都充分说明一个现象，在成熟的应用的基��上创新而非扩展出复杂所谓“创新性”架构在软�g行业是更为可靠�?/p>

实战体验REST可以从IBM Developer的这��文章开始�?a >跨越边界�Q�Rest On Rails》。这��文章是在Rails1.2发布之前出来的，有些地方已经可以修改的更��l�，我把我的�l�习�q�程记录下，�q�添加了C#调用REST风格web service的例子�?/p>

首先�Q�你的机器上需要安装rails1.2�Q��ƈ且假设你对rails有基本的了解�Q�徏立一个应用叫service,命��o行执行：

rails service

rails自动帮你生成应用的基本结构和基础代码�Q�然后编辑config下面的database.yml讄��数据库，�q�徏立数据service_development�Q�我用的是mysql数据库�?/p>

利用rails1.2新的scaffold命��o�Q?/p>

ruby script/generate scaffold_resource person

�q�个命��o��自动生成ActiveRecord,Controller以及View�Q�在\app\models下可以发现自动生成的Model——person.rb。打开service\db\migrate下面�?01_create_people.rb�Q�编辑如下：

class CreatePeople < ActiveRecord::Migration
  def self.up
    create_table :people do |t|
     t.column :first_name, :string, :limit => 40
     t.column :last_name, :string, :limit => 40
     t.column :email, :string, :limit => 40
     t.column :phone, :string, :limit => 15
    end
  end

  def self.down
    drop_table :people
  end
end

利用rake命��o自动��Q�执�?

rake db:migrate

rails默认表明是Model的复数�Ş式，也就是这里将自动建立一张名叫people的表�?br />
OK�Q�一切就�l�，启动WEBric�Q�访问http://localhost:3000/people�Q�显�C�：

scaffold已经帮我们自动生成了一个对person资源的crud操作�Q�增删改查似乎跟传统的rails没有什么不同嘛。如果你认真观察在操作过�E�中URL的变化情况就会发现在操作�q�程中URL的变化很��，而且与传�l�rails的URL路由相比�Q�省��M��action名称。出现的变化�?people�?people/1�?people/1;edit�?people/new�q�几个之中。在/people的URL中隐藏这可能是http的POST或者GET的方法，前者用于create操作�Q�而GET用于show操作�Q�具体你可以查看app/controllers/目录下的PeopleController�c�，每个action的前面都注释了它们将对应哪个HTTP�Ҏ(gu��)��。�?people/1中的1指的是资源的标志�W�，比如�q�里person的id�Q�通过�q�个ID来进行资源的操作�Q�也许是PUT�Ҏ(gu��)��Q�更斎ͼ��Q�也许是DELETE�Ҏ(gu��)��Q�删除）。rails实现PUT和Delete是通过隐藏字段来实现的�Q�查看编辑页面生成的html源代码，你将发现一个_method的隐藏字�D�，��gؓPUT。而另外两个URL�Q?people/1;edit�?people/new�Q�这两个�q��严格意义上的RESTful URL�Q�它们只是�ؓ了显�C�用�Q�显�C�form表单用于新徏和编辑。关于RESTful风格的URL的详�l�讨��见《RESTfull Rails Development》文档�?br />
如果rails只是�q�样的威力，那就有点��提大做了，看看PeopleController的show action�Q�它对应于http的GET��h��Q�返回people列表�Q?br />

# GET /people/1
  # GET /people/1.xml
  def show
    @person = Person.find(params[:id])

    respond_to do |format|
      format.html # show.rhtml
      format.xml  { render :xml => @person.to_xml }
    end
  end

��奇的地方在respond_to�Ҏ(gu��)��中，�Ҏ(gu��)��h��文�g�c�d��Q�http Header的ContentType�Q�，昄��html格式�Q�或者xml格式�Q�还有其他支持，比如json、RSS、Atom�{�等�Q�。比如你��d��了一个person,通过http://localhost:3000/people/1讉K��Q�可以看到这个�h员的具体信息�Q?br />
我们再通过http://localhost:3000/people/3.xml讉K��看到的却是一个xml文�g�Q?br />

不仅如此�Q�我们也可以通过其他语言�~�写客户端来调用http://localhost:3000/people/1�q�个url�Q�慢着�Q�这不正是web service�q�程调用吗？没错�Q�REST风格的web service相比于wsdl、soap定义的web service��单了太多太多�Q�也更加实用。我们来�~�写一个java�c�调用http://localhost:3000/people获得所有的人员列表�Q?br />

package example;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;

public class RESTDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        RESTDemo restDemo = new RESTDemo();
            restDemo.get();

    }

    void get() {

        try {
            URL url = new URL("http://localhost:3000/people");
            URLConnection urlConnection = url.openConnection();
            urlConnection.setRequestProperty("accept", "text/xml");
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    urlConnection.getInputStream()));
            String str;

            while ((str = in.readLine()) != null) {
                System.out.println(str);
            }

            in.close();
        } catch (Exception e) {
            System.out.println(e);
        }
    }
}

我们没有什么服务端接口class�Q�我们也不用生成什么stub�Q�我们调用的最常见最常见的http协议�Q�发送的是默认的GET��h��Q�rails自动��该��h��转发�l�show action。注意，我们�q�里�?span style="color: rgb(0, 0, 0);">accept讄��为text/xml�Q�show�Ҏ(gu��)��Ҏ(gu��)��此格式返回一个xml文��Q�下面是输出�Q?br />

xml version="1.0" encoding="UTF-8"?>
<people>
  <person>
    <email>killme2008@gmail.comemail>
    <first-name>dennisfirst-name>
    <id type="integer">1id>
    <last-name>zanelast-name>
    <phone>1355XXXXXXXphone>
  person>
people>

如果仅仅是GET��h��是不够的�Q�我们说�q�，把远�E�调用抽象成对远�E�资源的CRUD操作�Q�那么如何create、delete和update�q�程资源呢？同样很简单，比如我们通过C#�q�程调用�Q�创��Z��个新person�Q�还记的我说�q�吗�Q?people可以是POST��h��Q�他��调用PeopleController的create�Ҏ(gu��)��Q?br />

using System;
using System.Net;
using System.IO;
using System.Text;
namespace demo
{
    class RESTDemo
    {
        static void Main(string[] args)
        {
            string xmlText = " " + "

jordan

"
+ "

jordan

"
                    + "maggie@tate.com"
                    + "010-XXXXXXXX" + "";
            Uri address = new Uri("http://localhost:3000/people");

            // 创徏web��h��
            HttpWebRequest request = WebRequest.Create(address) as HttpWebRequest;

            // 讄��h��c�d��为POST�Q�调用create action
            request.Method = "POST";
            request.ContentType = "application/xml";

            byte[] xmlBytes = Encoding.ASCII.GetBytes(xmlText);

            using (Stream reqStream = request.GetRequestStream())
            {
                reqStream.Write(xmlBytes, 0, xmlBytes.Length);
            }
            using (WebResponse wr = request.GetResponse())
            {
                wr.
                //打印�q�回的http�?/span>
                Console.WriteLine(wr.Headers.ToString());

            }


        }
    }
}

执行此程序，��h��http://localhost:3000/people�Q�可以看到新��Z��一个�h员如�?br />

好极了，GET和POST都有了，那么PUT对应的更新和DELETE对应的删除又该怎么做呢�Q�唯一的区别就是设�|�请求类型不同而已�Q�java调用如下�Q?br />

    void put() {
        try {
            String xmlText = " " + "

test

"
+ "

test

"
                    + "maggie@tate.com"
                    + "010-XXXXXXXX" + "";

            URL url = new URL("http://localhost:3000/people/1");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setDoOutput(true);
            //讄��h��为PUT
            conn.setRequestMethod("PUT");
            conn.setRequestProperty("Content-Type", "text/xml");
            OutputStreamWriter wr = new OutputStreamWriter(conn
                    .getOutputStream());
            wr.write(xmlText);
            wr.flush();
            wr.close();
        } catch (Exception e) {
            System.out.println("Error" + e);
        }
    }

    void delete() {
        try {
            URL url = new URL("http://localhost:3000/people/2");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setDoOutput(true);
            //讄��h��为DELETE
            conn.setRequestMethod("DELETE");
            conn.setRequestProperty("Content-Type", "text/xml");
            if(conn.getResponseCode()==200)
                System.out.println("删除成功�Q?/span>");
        }catch (Exception e) {
            System.out.println("Error" + e);
        }
    }

�q�里的put�Ҏ(gu��)��第一个�h员的名字改了�Q�而delete�Ҏ(gu��)��q�脆��刚才C#��d��的�h员删除掉。异构系�l�的�q�程调用变的如此��单很��L��Q�把什么EJB、CORBA、SOAP�l�统忘掉吧。想象这��L��场景�Q�所有的�|�站都提供REST风格的API�Q�这个世界将是什么模��P��

REST带来的不仅仅是web service的改变，对MVC架构同样��h��很重要的意义�Q�过��L��们的复用通常在MODEL层，我们一直希望复用业务逻辑层，却没有想�q�是否能复用Controller甚至View呢？REST为我们提供了可能�Q�比如以一个很�l�常被提到的例子来说�Q�用户加入某个圈子这个操作跟圈子的管理员��用户加入圈子的操作是一��P��但是操作成功后的跌��{昄��的页面也�怸�同，�q�去也许我们是通过写两个不同的Action来实玎ͼ�而现在，同一个Action�Q�加入圈子这个操作）只负责发送数据（XML格式的文��）�Q�而页面的展示��留�l�客��L��去选择�Q�从而复用了Controller�Q�减��了Action和View层的代码量。进一步，请你惌��Q�REST与AJAX的技术结合��生多么有��的画面�?b>REST仅用于提供数�?/b>�Q�展现更多的交给了客��L��?br />
本文仅仅是我接触REST�q�两天的学习�ȝ��Q�对于REST的应用才刚刚��h��Q�需要更多的探讨和实��c��其实java实现REST也是相当��单的�Q�servlet本��n��是很好的模型，恐怕没有多人注意到HttpServlet�c�M��的doPut和doDelete�Ҏ(gu��)��Q�我们过��d��GET和POST�Q�反而忽视了PUT和DELETE可能带来的改变。java开源世界中已经有了REST风格的框�Ӟ��比如cetia4�Q?/a>�q�是一个servlet-base的REST框架�Q�值的��x��?br />

dennis 2007-03-20 20:04 发表评论

dennis — Tue, 20 Mar 2007 08:32:00 GMT

转自�Q�http://www.cnblogs.com/webman/archive/2006/11/17/564106.html

HttpWebRequest 是�?net 基类库中的一个类�Q�在命名�I�间 System.Net 下面�Q�用来��用户通过 HTTP 协议和服务器交互。�?br />
HttpWebRequest 对 HTTP 协议�q�行了完整的��装�Q�对 HTTP 协议中的 Header, Content, Cookie 都做了属性和�Ҏ(gu��)��的支持，很容易就能编写出一个模拟浏览器自动��d��的程序。�?br />
�E�序使用 HTTP 协议和服务器交互主要是进行数据的提交�Q�通常数据的提交是通过 GET 和 POST 两种方式来完成，下面对这两种方式�q�行一下说明：

1. GET 方式。 GET 方式通过在网�l�地址附加参数来完成数据的提交�Q�比如在地址 http://www.google.com/webhp?hl=zh- CN 中，前面部分 http://www.google.com/webhp 表示数据提交的网址�Q�后面部分 hl=zh-CN 表示附加的参敎ͼ�其中 hl 表示一个键(key)�Q� zh-CN 表示�q�个键对应的�?value)。程序代码如下：

HttpWebRequest req = (HttpWebRequest) HttpWebRequest.Create( "http://www.google.com/webhp?hl=zh-CN" );
req.Method = "GET";
using (WebResponse wr = req.GetResponse())
{
//在这里对接收到的��面内容�q�行处理
}

2. POST 方式。 POST 方式通过在页面内容中填写参数的方法来完成数据的提交，参数的格式和 GET 方式一��P��是类��g�� hl=zh-CN&newwindow=1 �q�样的结构。程序代码如下：

string param = "hl=zh-CN&newwindow=1";
byte[] bs = Encoding.ASCII.GetBytes(param);

HttpWebRequest req = (HttpWebRequest) HttpWebRequest.Create( "http://www.google.com/intl/zh-CN/" );
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded";
req.ContentLength = bs.Length;

using (Stream reqStream = req.GetRequestStream())
{
reqStream.Write(bs, 0, bs.Length);
}
using (WebResponse wr = req.GetResponse())
{
//在这里对接收到的��面内容�q�行处理
}

在上面的代码中，我们讉K��了 www.google.com 的网址�Q�分别以 GET 和 POST 方式提交了数据，�q�接收了�q�回的页面内宏V��然而，如果提交的参��C��含有中文�Q�那么这��L��处理是不够的�Q�需要对其进行编码，让对方网站能够识别。�?br />
3. 使用 GET 方式提交中文数据。 GET 方式通过在网�l�地址中附加参数来完成数据提交�Q�对于中文的�~�码�Q�常用的有 gb2312 和 utf8 两种�Q�用 gb2312 方式�~�码讉K��的程序代码如下：

Encoding myEncoding = Encoding.GetEncoding("gb2312");
string address = "http://www.baidu.com/s?" + HttpUtility.UrlEncode("参数一", myEncoding) + "=" + HttpUtility.UrlEncode("��g��", myEncoding);
HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(address);
req.Method = "GET";
using (WebResponse wr = req.GetResponse())
{
//在这里对接收到的��面内容�q�行处理
}

�? 上面的程序代码中�Q�我们以 GET 方式讉K��了网址 http://www.baidu.com/s �Q�传递了参数“参��C��=��g��”，�׃��无法告知�Ҏ(gu��)��? 交数据的�~�码�c�d��Q�所以编码方式要以对方的�|�站为标准。常见的�|�站中， www.baidu.com �Q�百度）的编码方式是 gb2312, www.google.com �Q�谷歌）的编码方式是 utf8。�?br />
4. 使用 POST 方式提交中文数据。 POST 方式通过在页面内容中填写参数的方法来完成数据的提交，�׃��提交的参��C��可以说明使用的编码方式，所以理��Z��能获得更大的兼容性。用 gb2312 方式�~�码讉K��的程序代码如下：

Encoding myEncoding = Encoding.GetEncoding("gb2312");
string param  = HttpUtility.UrlEncode("参数一", myEncoding) + "=" + HttpUtility.UrlEncode ("��g��", myEncoding) + "&" + HttpUtility.UrlEncode("参数�?/span>", myEncoding)  + "=" + HttpUtility.UrlEncode("��g��", myEncoding);

byte[] postBytes = Encoding.ASCII.GetBytes(param);

HttpWebRequest req = (HttpWebRequest) HttpWebRequest.Create( "http://www.baidu.com/s" );
req.Method = "POST";
req.ContentType = "application/x-www-form-urlencoded;charset=gb2312";
req.ContentLength = postBytes.Length;

using (Stream reqStream = req.GetRequestStream())
{
   reqStream.Write(postBytes , 0, postBytes .Length);
}
using (WebResponse wr = req.GetResponse())
{
   //在这里对接收到的��面内容�q�行处理
}

从上面的代码可以看出�Q� POST 中文数据的时候，先��用 UrlEncode �Ҏ(gu��)��中文字�W��{换�ؓ�~�码后的 ASCII 码，然后提交到服务器�Q�提交的时候可以说明编码的方式�Q�用来��Ҏ(gu��)��服务器能够正��的解析。�?br />
�? 上列��Z��客户端程序��用 HTTP 协议与服务器交互的情况，常用的是 GET 和 POST 方式。现在流行的 WebService 也是通过 HTTP 协议来交互的�Q��用的是 POST �Ҏ(gu��)��。与以上�E�有所不同的是�Q� WebService 提交的数据内容和接收到的数据内容都是使用�? XML 方式�~�码。所以， HttpWebRequest 也可以��用在调用 WebService 的情况下�?img src ="http://www.tkk7.com/killme2008/aggbug/105023.html" width = "1" height = "1" />

dennis 2007-03-20 16:32 发表评论

dennis — Sat, 17 Mar 2007 09:01:00 GMT

�pȝ��的演化应当依赖于�l�合�Q�而不是��承；�q�就提出了将�cȝ��实例化委托给一个对象的要求�Q�因此创建型模式��变的越来越重要�?br />

创徏型模式属于对象创建模型。所谓对象创建模型就是说��实例化的工作委托给另一个对象来做。与之相对应的是�c�d��建模型，�q�是一�U�通过�l�承改变被实例化的类�?/div>

创徏型模式有两个重要的特点：

1�Q��?/span>客户不知道创建的具体�c�L��什么（除非看源代码�Q?/div>

2�Q��?/span>隐藏了类的实例是如何被创建和攑֜�一��L��

一。抽象工厂模�?br />1.意图�Q�提供一个创�?b>一�p�d��相关或相互依赖对象的接口�Q�而无需指定它们的具体的�c�R�?br />2.适用场景�Q?br />1)一个系�l�要独立于它的��品的创徏、组合和表示�?br />2�Q�一个系�l�要由多个��品系列中的一个来配置�?br />3�Q�当你要��一�p�d��相关的��品对象的设计以便�q�行联合使用�?br />4�Q�当你提供一个��品类库，而只��x��C�它们的接口而不是实现时

3.UML�䏀�—结�?br />
4.效果�Q?br />1�Q�分��M��具体的类�Q�通过抽象接口��客户与具体的类分离
2�Q�易于交换��品系�?br />3�Q�有利于产品的一致�?br />4�Q�难以支持新�U�类的��品，比如我们现在有一个ProductC产品�Q�我们需要增加类AbstractProductC�Q�增加AbstractFactory:: CreanteProductC�Ҏ(gu��)��Q��ƈ且两个��品系列的实际创徏者ConCreateFactory1、ConCreateFactor2都要实现该方法�?div>可以通过�l�方法加参数的方式来指明创徏的是什么��品，�q�样客户代码��无需改变�Q�只要传递不同的参数。AbstractFactory�c�d��需要提供一个CreateProduct(const string& name)�Ҏ(gu��)��卛_��?br />
5.代码实现�Q�以《深入浅��计模�?java C#)》的动物工厂��Z��Q?br />

using System;
namespace AnimalWorld
{
    // 抽象大陆工厂
    abstract class ContinentFactory
    {
        abstract public Herbivore CreateHerbivore();
        abstract public Carnivore CreateCarnivore();
    }
    //非洲大陆,有角马，狮子
    class AfricaFactory : ContinentFactory
    {
        override public Herbivore CreateHerbivore()
        {
            return new Wildebeest();
        }
        override public Carnivore CreateCarnivore()
        {
            return new Lion();
        }
    }
    // ��洲大陆,有狼,野牛
    class AmericaFactory : ContinentFactory
    {
        override public Herbivore CreateHerbivore()
        {
            return new Bison();
        }
        override public Carnivore CreateCarnivore()
        {
            return new Wolf();
        }
    }
    //食草动物"
    abstract class Herbivore
    {
    }
    //肉食动物"
    abstract class Carnivore
    {
        //猎食食草动物的方�?/span>
        abstract public void Eat( Herbivore h );
    }
    //角马
    class Wildebeest : Herbivore
    {
    }
    //狮子"
    class Lion : Carnivore
    {
        //重蝲猎食食草动物的方�?/span>
        override public void Eat( Herbivore h )
        {
            Console.WriteLine( this + " eats " + h );
        }
    }
    //野牛
    class Bison : Herbivore
    {
    }
    //�?/span>
    class Wolf : Carnivore
    {
        //重蝲猎食食草动物的方�?/span>
        override public void Eat( Herbivore h )
        {
            Console.WriteLine( this + " eats " + h );
        }
    }
    //动物世界�c?/span>
    class AnimalWorld
    {
        private Herbivore herbivore;
        private Carnivore carnivore;
        // 创徏两种动物分类
        public AnimalWorld( ContinentFactory factory )
        {
            carnivore = factory.CreateCarnivore();
            herbivore = factory.CreateHerbivore();
        }
        //�q�行食物�?/span>
        public void RunFoodChain()
        {
            //肉食动物猎食食草动物
            carnivore.Eat( herbivore );
        }
    }
    ///

/// 抽象工厂模式客户应用��试
///

    class GameApp
    {
        [STAThread]
        static void Main(string[] args)
        {
            //创造�ƈ�q�行非洲动物世界
            ContinentFactory africa = new AfricaFactory();
            AnimalWorld world = new AnimalWorld( africa );
            world.RunFoodChain();
            //创造�ƈ�q�行��洲动物世界
            ContinentFactory america = new AmericaFactory();
            world = new AnimalWorld( america );
            world.RunFoodChain();
            Console.Read();
        }

    }
}

二。Builder模式
1.意图�Q�将一�?b>复杂对象的构��Z��它的表示相分��，使得同样的构��E�可以创��Z��同的表示�Q�或者说产品�Q?br />
2.适用场景�Q?br />1�Q�当创徏复杂对象的算法应该独立于改对象的�l�成部分以及它们的装配方式时
2�Q�当构造过�E�必��d��许被构造的对象有不同的表示�?br />
3.UML�䏀�—结�?br />

Director接受一个Builder子类对象�Q�完成创��E�，�q��知Builder对象�q�回以及构造好的��品�?br />
4.效果�Q?br />1�Q�可以��你改变一个对象的内部表示
2�Q�构造代码和表示代码分开
3�Q�可以对构造过�E�进行更�_��的控�?br />
5。实玎ͼ�以一个�R辆徏造过�E��ؓ例（C#)

using System;

namespace CarShop
{
    using System;
    using System.Collections;
    //指挥�?Director
    class Shop{
        public void Construct( VehicleBuilder vehicleBuilder ){
            vehicleBuilder.BuildFrame();
            vehicleBuilder.BuildEngine();
            vehicleBuilder.BuildWheels();
            vehicleBuilder.BuildDoors();
        }
    }
    /* "Builder 建造�?,Builder
    抽象建造者具有四�U�方�?br />    装配框架
    装配发动�?br />    装配轮子
    装配车门
    */
    abstract class VehicleBuilder
    {
        protected Vehicle vehicle;
        //�q�回建造完成的车辆
        public Vehicle Vehicle{
            get{ return vehicle; }
        }
        abstract public void BuildFrame();
        abstract public void BuildEngine();
        abstract public void BuildWheels();
        abstract public void BuildDoors();
    }
    //具体建造�?摩托车�R�?/span>
    class MotorCycleBuilder : VehicleBuilder
    {
        override public void BuildFrame(){
            vehicle = new Vehicle( "摩托�?/span>" );
            vehicle[ "frame" ] = "MotorCycle Frame";
        }

        override public void BuildEngine(){
            vehicle[ "engine" ] = "500 cc";
        }

        override public void BuildWheels(){
            vehicle[ "wheels" ] = "2";
        }

        override public void BuildDoors(){
            vehicle[ "doors" ] = "0";
        }
    }
    //具体建造�?轿�R车间
    class CarBuilder : VehicleBuilder
    {
        override public void BuildFrame(){
            vehicle = new Vehicle( "轿�R" );
            vehicle[ "frame" ] = "Car Frame";
        }
        override public void BuildEngine(){
            vehicle[ "engine" ] = "2500 cc";
        }
        override public void BuildWheels(){
            vehicle[ "wheels" ] = "4";
        }
        override public void BuildDoors(){
            vehicle[ "doors" ] = "4";
        }
    }
    // 具体建造�?单脚滑行车�R�?/span>
    class ScooterBuilder : VehicleBuilder
    {
        override public void BuildFrame(){
            vehicle = new Vehicle( "单脚滑行�?/span>" );
            vehicle[ "frame" ] = "Scooter Frame";
        }

        override public void BuildEngine(){
            vehicle[ "engine" ] = "none";
        }

        override public void BuildWheels(){
            vehicle[ "wheels" ] = "2";
        }

        override public void BuildDoors(){
            vehicle[ "doors" ] = "0";
        }
    }
    //车辆产品�c?/span>
    class Vehicle
    {
        private string type;
        private Hashtable parts = new Hashtable();
        //�{�构函数,军_��c�d��
        public Vehicle( string type ){
            this.type = type;
        }
        //索引
        public object this[ string key ]{
            get{ return parts[ key ]; }
            set{ parts[ key ] = value; }
        }
        //昄��Ҏ(gu��)��
        public void Show()
        {
            Console.WriteLine( "\n---------------------------");
            Console.WriteLine( "车辆�cȝ��? "+ type );
            Console.WriteLine( " 框架 : " + parts[ "frame" ] );
            Console.WriteLine( " 发动机�? "+ parts[ "engine"] );
            Console.WriteLine( " #轮子�? "+ parts[ "wheels"] );
            Console.WriteLine( " #车门敊W? "+ parts[ "doors" ] );
        }
    }
    ///

/// 建造者模式应用测�?br /> ///

     class CarShop
    {
        [STAThread]
        static void Main(string[] args)
        {
            // 创造�R间及车辆建造�?/span>
            Shop shop = new Shop();
            VehicleBuilder b1 = new ScooterBuilder();
            VehicleBuilder b2 = new CarBuilder();
            VehicleBuilder b3 = new MotorCycleBuilder();
            // �{�构�q�显�C��R�?/span>
            shop.Construct( b1 );
            b1.Vehicle.Show();
            shop.Construct( b2 );
            b2.Vehicle.Show();
            shop.Construct( b3 );
            b3.Vehicle.Show();
            Console.Read();

        }
    }
}

三。Factory Method模式
1.意图�Q�定义一个用于创建对象的接口�Q�让子类军_��实例化具体的哪一个类�?br />2.适用场景�Q?br />1�Q�当一个类不知道它所必须创徏的对象的�cȝ��时候，让子�c�L��军_��
2�Q�当一个类希望由它的子�c�L��军_��它所创徏的对象的时�?br />
3。UML�䏀�—结构：

4.效果�Q?br />1�Q��ؓ子类提供回调函数
2�Q�连接��^行的�c�d��?br />

3�Q��?/span>创徏函数可以接收参数来决定创��Z��么��?/div>

4�Q�Factory Method�Ҏ(gu��)��D��创徏�q�多的Creator的子�c�M��对应不同的��品，�q�个�Ҏ(gu��)��可以通过模板技术来解决

6.实现�Q�手机工厂，产品可能是Nokia�Q�也可能是Motorola

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

namespace HandPhone
{
    //手机接口
    interface Mobile
    {
         void call();
    }

    //手机工厂接口
    interface MobileFactory
    {
          Mobile createMobile();
    }

    //Nokia
    class Nokia:Mobile
    {
        public void call()
        {
            Console.WriteLine("This is a {0} phone", this.GetType().Name);
        }
    }

    //Motorola
    class Motorola : Mobile
    {
        public void call()
        {
            Console.WriteLine("This is a {0} phone", this.GetType().Name);
        }
    }

    //Motorola工厂
    class MotorolaFactory : MobileFactory
    {
         public Mobile createMobile()
        {
            return new Motorola();
        }
    }

    //Nokia工厂
    class NokiaFactroy : MobileFactory
    {
        public Mobile createMobile()
        {
            return new Nokia();
        }
    }

    public class Client
    {
        static void Main(String []args)
        {
            MobileFactory factory=null;
            Mobile mobile=null;

            factory=new NokiaFactroy();
            mobile=factory.createMobile();
            mobile.call();

            factory=new MotorolaFactory();
            mobile=factory.createMobile();
            mobile.call();

        }
    }

}

四。Prototype模式

1.意图�Q�通过原型实例指定创徏对象的种�c�，�q��过拯��q�些原型来创建新的对�?br />
2.适用场景�Q?br />1�Q�要实例化的�c�L��在运行时��L��定的�Q�比如动态装�?br />2�Q��ؓ了避免创��Z��个与产品层次�q��的工厂类层次
3�Q�当一个类的实例只能有几个不同的状态组合中的一�U�时�Q�徏立相应数目的原型�q�克隆它们可能比每次用合适的状态手工化该类更方便一些�?br />
3.UML�䏀�—结构：

4.效果�Q?br />1�Q�运行时动态增加或者删除��?br />2�Q�减��子�cȝ��构造数�?br />3�Q�用�c�d��态配�|�应�?br />4�Q�动态指定新的对象，通过改变�l�构或者�?br />5�Q�缺陷在于每一个Prototype的子�c�都需要实现clone操作

5。实�?无论java�q�是C#都从语言层次内置了对prototype模式的支持。具体不再详�q��?br />
五。singleton模式
1。意图：保证一个类仅有一个实例，�q�提供一个访问它的全局讉K��?br />
2.适用场景�Q?br />1�Q�当需要类只有一个实例，�q�且客户只能通过一个全局点去讉K��?br />2�Q�当�q�个唯一实例应该是通过子类化可扩展的，�q�且客户应该无需更改代码��p��使用扩展的实�?br />
3.UML图：�?br />
4.效果�Q?br />1�Q�对唯一实例的受控访�?br />2�Q�羃?y��u)��命名空�?br />3�Q�允许对操作和表�C�的�l�化
4�Q�允许可变数目的实例

5实现�Q�关于singleton在java多线�E�环境下的实玎ͼ�误��讨论�?a id="viewpost1_TitleUrl" class="postTitle2" >当Singleton遇到multi-threading》，C#对singleton多线�E�环境下的能够正��实现Double-checked模式�Q?br />

public sealed class Singleton
{
    private static volatile Singleton instance;
    private static object syncRoot = new Object();

    private Singleton() {}

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (syncRoot)
                {
                    if (instance == null)
                        instance = new Singleton();
                }
            }

            return instance;
        }
    }
}

本文仅作速查记忆用，摘记于《设计模式——可复用面向对象软�g基础》和《深入浅��计模式（java C#)》两�?br />

dennis 2007-03-17 17:01 发表评论

图文�q�茂——��用xfire�~�写webservice,�q��过C#调用

dennis — Wed, 07 Mar 2007 10:13:00 GMT

摘要: 使用MyEclipse�~�写web service�Q��ƈ通过java与C#调用阅读全文

dennis 2007-03-07 18:13 发表评论

C#的using语句

dennis — Mon, 12 Feb 2007 07:53:00 GMT

C#的using语句设计的蛮贴心�Q�比java的import有趣一炏V��{一��文�?

C#中的using除了作�ؓ命名�I�间指示�W?using System)�Q�类型的别名指示�W?using Dos=System.Console)�Q�还有资源管理的语句功能�Q?br /> using (R r1 = new R ()) {
r1.F();
}
在C#中被��译为：

R r1 = new R();
try {
r1.F();
}
finally {
if (r1 != null) ((IDisposable)r1).Dispose();
}

r1当然要支持Dispose()�Ҏ(gu��)��?br />
再来一个例子：

# MyObject.cs

using System;

namespace MyProjects

{

     public class MyObject : IDisposable

    {

         public MyObject()

        {

        }

         public void Dispose ( )

        {

             // Dispose

            Console.WriteLine ( " Disposed " ) ;

             //

        }

    }

}

# Class1.cs

using System;

namespace MyProjects

{

      public class Class1

     {

          public Class1()

         {

         }

          public static void Main ( string [] args )

         {

               using ( MyObject myObject = new MyObject ( ) )

              {

                   Console.WriteLine ( " quit " ) ;

              }

         }

     }

}

使用using会自动调�?span lang="EN-US">MyObject�?span lang="EN-US">Dispose�Ҏ(gu��)��.

dennis 2007-02-12 15:53 发表评论

dennis — Mon, 12 Feb 2007 04:30:00 GMT

一.C#的统一�c�d��pȝ��
1.C#的类型系�l�是�l�一的，java的类型系�l�分为：基本�c�d��Q�原生类型）和类�c�d��Q�而C#的所有类型直接或间接��C��object�cȝ��型派生而来�Q�从�c�d��pȝ��上来看比java更OO�?br />2.C#的类型分��Z��c�：
�Q?�Q�值类型，一个值类型或是结构类�?/span>�Q?/span>或是枚�D�c�d��
�Q?�Q�引用类�?br />�Q?�Q�指针类�?br />值类型与引用�c�d��的不同在于：值类型的变量直接包含其数�?/span>�Q?/span>而引用类型的变量存储对其数据的引�?/span>(reference)�Q?/span>后者称为对�?/span>(object)。对于引用类�?/span>�Q?/span>两个变量可能引用同一个对�?/span>�Q?/span>因此对一个变量的操作可能影响另一个变量所引用的对象。对于值类型，每个变量都有自己的数据副本，对一个变量的操作不可能媄响另一个变量�?br />二。值类�?br />1.所有值类型从�c?/span>System.ValueType隐式�l�承�Q?/span>后者又从类object�l�承。�Q何类型都不可能从值类型派生�?br />
2.所有值类型都隐式声明一个称为默认构造函�?/span>(default constructor)的公共无参数实例构造函数。默认构造函数返回一个零初始化实�?/span>�Q?/span>它就是该值类型的默认�?/span>(default value)�Q?/span>

· 对于所�?/span>simple-types�Q?/span>默认值是��其所有位都置零的位模式所形成的�?/span>�Q?/span>

o 对于sbyte�?/span>byte�?/span>short�?/span>ushort�?/span>int�?/span>uint�?/span>long�?/span>ulong�Q?/span>默认��gؓ0�?/span>

o 对于char�Q?/span>默认��gؓ'\x0000'�?/span>

o 对于float�Q?/span>默认��gؓ0.0f�?/span>

o 对于double�Q?/span>默认��gؓ0.0d�?/span>

o 对于decimal�Q?/span>默认��gؓ0.0m�?/span>

o 对于bool�Q?/span>默认��gؓfalse�?/span>

· 对于enum-typeE�Q?/span>默认��gؓ0�?/span>

· 对于struct-type�Q?/span>默认值是通过��所有值类型字�D�设�|��ؓ它们的默认倹{��将所有引用类型字�D�设�|��ؓnull而��生的倹{�?/span>

3.C#中有所谓的��单类型概念（simple type�Q�，�c�M��于java的基本类型，但又不同�Q�C#的简单类型本质上都是�l�构�c�d��Q�预定义集合的结构类型）�Q�所以还是值类型，�?span class="Codefragment">System.ValueType�l�承而来。C#的简单类型包括：

保留�?/span>	化名的类�?/span>
sbyte	System.SByte
byte	System.Byte
short	System.Int16
ushort	System.UInt16
int	System.Int32
uint	System.UInt32
long	System.Int64
ulong	System.UInt64
char	System.Char
float	System.Single
double	System.Double
bool	System.Boolean
decimal	System.Decimal

�q�些��单类型都是System命名�I�间中预定义�l�构�c�d��的别名（ruby的别名实在脓(chu��ng)心）

4.枚�D�c�d��Q?span style="font-size: 11pt; font-family: 宋体;">枚�D�c�d��是具有命名常量的独特的类型。每个枚丄��型都有一个基��c�d��Q�该基础�c�d��必须�? byte�?/span>sbyte�?/span>short�?/span>ushort�?/span>int�?/span>uint�?/span>long �?ulong。如果没有�ؓ枚�D�c�d��中的元素指定基础��|��默认是从0开始逐一递增�?br />
三。引用类�?br />

1.引用�c�d��是类�c�d��、接口类型、数�l�类型或委托�c�d��?/span>

2.�cȝ��型：包括预定义的�cȝ��型和用户通过class关键字的自定义类�c�d��

3.对象�c�d��Q?/span>

object�cȝ��型是所有其他类型的最�l�基�c�R�?/span>C# 中的每种�c�d��都是直接或间接从object�cȝ��型派生的�?/span>

关键�?/span>object只是预定义类System.Object的别名�?/span>

4.string�c�d��:
string�c�d��是直接从object�l�承的密��类�c�d��?/span>关键�?/span>string只是预定义类System.String的别�?
5.接口�c�d��Q?br />与java中的接口概念基本一��_��可以变相实现多重�l�承�?br />

�cȝ��?/span>	说明
System.Object	所有其他类型的最�l�基�c�R�?/span>
System.String	C# 语言的字�W�串�c�d��?/span>
System.ValueType	所有值类型的基类�?/span>
System.Enum	所有枚丄��型的基类�?/span>
System.Array	所有数�l�类型的基类�?/span>
System.Delegate	所有委托类型的基类�?/span>
System.Exception	所有异常类型的基类�?/span>

四。装��、拆��概�?br />1.装箱和拆��q��概念�?/span>C# 的类型系�l�的核心。它�?value-type �?reference-type 之间的架起了一座桥梁，使得��M�� value-type 的值都可以转换�?object �c�d��的��|��反过来�{换也可以�?br />2.装箱�Q?/span>装箱转换允许��?/span>value-type隐式转换�?/span>reference-type�?br />装箱的行为可以用下面的过�E�描�q�ͼ�

sealed class T_Box: System.ValueType
{
T value;

public T_Box(T t) {
value = t;
}
}

分配一个对象实�?/span>�Q?/span>然后��?/span>value-type的值复制到该实例中
3.拆箱�Q?/span>拆箱转换允许��?/span>reference-type昑ּ�转换�?/span>value-type�?br />从对�?/span>box�?/span>value-typeT的拆��p�{换相当于执行表达�?/span>((T_Box)box).value

dennis 2007-02-12 12:30 发表评论

dennis — Sat, 10 Feb 2007 09:39:00 GMT

    �|�上到处充斥�q�c#与java�Ҏ(gu��)��的文章，看了看，�q�是觉的MSDN上的一��文章很全面和客观。�?a >针对JAVA开发�h员的C#�~�程语言》�?br />
    我的�W�一天C#学习�Q��M��感觉C#在语�a�层面上保留了更多C++/C的特点，比如virtual,override关键字的使用�Q�比如结构（值类型，存储在栈上）�Q�比如delegate�Q�类似函数指针）。比较感兴趣的也��是delegate、事件和attribute斚w��。C#某种意义上讲比java�E�微复杂�Q�比C++��单�?br />
    参照语言规范写的例子�Q�抽象类、��承的例子�Q�可以扩展成一个简单计��器�Q?br />

using System;
using System.Collections;

namespace VirtualDemo
{
    public abstract class Expression
    {
        public abstract double Evaluate(Hashtable vars);

    }
    public class Constant : Expression
    {
        double value;
        public Constant(double value)
        {
            this.value = value;
        }
        public override double Evaluate(Hashtable vars)
        {
            return value;
        }
    }
    public class VariableReference : Expression
    {
        string name;
        public VariableReference(string name)
        {
            this.name = name;
        }
        public override double Evaluate(Hashtable vars)
        {
            object value = vars[name];
            if (value == null)
            {
                throw new Exception("Unknown variable: " + name);
            }
            return Convert.ToDouble(value);
        }
    }
    public class Operation : Expression
    {
        Expression left;
        char op;
        Expression right;
        public Operation(Expression left, char op, Expression right)
        {
            this.left = left;
            this.op = op;
            this.right = right;
        }
        public override double Evaluate(Hashtable vars)
        {
            double x = left.Evaluate(vars);
            double y = right.Evaluate(vars);
            switch (op)
            {
                case '+': return x + y;
                case '-': return x - y;
                case '*': return x * y;
                case '/': return x / y;
            }
            throw new Exception("Unknown operator");
        }
    }
    public class Test
    {
        public static void Main(string []args)
        {
            Expression e = new Operation(
            new VariableReference("x"),
            '*',
            new Operation(
                new VariableReference("y"),
                '+',
                new Constant(2)
            )
        );
        Hashtable vars = new Hashtable();
        vars["x"] = 3;
        vars["y"] = 5;
        Console.WriteLine(e.Evaluate(vars));        // Outputs "21"
        vars["x"] = 1.5;
        vars["y"] = 9;
        Console.WriteLine(e.Evaluate(vars));        // Outputs "16.5"

        }
    }

}

再来一个委托的例子�Q�函��C��为变量的传递和使用�Q�对有C++�l�验或者动态语�a��l�验的�h来说不会奇怪：

using System;
namespace DelegateDemo
{
    delegate double Function(double x);
    class Multiplier
    {
        double factor;
        public Multiplier(double factor)
        {
            this.factor = factor;
        }
        public double Multiply(double x)
        {
            return x * factor;
        }
    }

    class Test
    {
        static double Square(double x)
        {
            return x * x;
        }
        static double[] Apply(double[] a, Function f)
        {
            double[] result = new double[a.Length];
            //直接通过f()调用
            for (int i = 0; i < a.Length; i++) result[i] = f(a[i]);
            return result;
        }
        static void Main()
        {
            double[] a = { 0.0, 0.5, 1.0 };
            //delegate Function分别赋予了不同的�Ҏ(gu��)��
            double[] squares = Apply(a, new Function(Square));
            double[] sines = Apply(a, new Function(Math.Sin));
            Multiplier m = new Multiplier(2.0);
            double[] doubles = Apply(a, new Function(m.Multiply));
            foreach (double b in doubles)
            {
                Console.WriteLine(b);
            }
        }

    }
}

dennis 2007-02-10 17:39 发表评论

我的�W�一个C#�E�序

dennis — Fri, 09 Feb 2007 02:38:00 GMT

我得老实承认�Q�我很早��想好好学习下C#�Q�学习下ASP.NET。因为我听说ASP.NET的开发速度很让人�M慕，听说C#也是蛮有��的语言。装�?net Framework2.0�Q�下了C#的语�a�规范�Q�本来想找本书，发现�|�上的电子书都做的很�p�糕�Q�还是看语言规范得了�Q�，写第一个Hello World�?br />

using System;

public class HelloWorld
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
    }


}

存�ؓhello.cs。配�|�好环境变量�Q�在命��o行运�?csc hello.cs。在目录下会生成一个hello.exe,直接�q�行hello。打华ͼ�

Hello World

看�v来跟java��实没什么不同，除了字母的大��写�Q�和java默认引入java.lang包，而这里需要using System;
�E�微复杂点的例子�Q�我们写一个库文�gstack.dll�Q�或者说一个程序集�Q�java中包的概念）�Q?br />

using System;

namespace Acme.Collections
{
    public class Stack
    {
        Entry top;
        public void push(object data)
        {
            top = new Entry(top, data);


        }
        public object pop()
        {
            if (top == null) throw new InvalidOperationException();
            object result = top.data;
            top = top.next;
            return result;

        }
        public Stack()
        {

        }
        class Entry
        {
            public Entry next;
            public object data;
            public Entry(Entry next, object data)
            {
                this.next = next;
                this.data = data;
            }
        }
    }
}

代码很明显，一个简单的栈结构，我们把Stack�c�L��在命名空�?span style="color: rgb(0, 0, 0);">Acme.Collections中�?/span>�q�行�Q�csc /t:library stack.cs�Q�在应用目录下生成一个stack.dll。我们怎么调用�q�个链接库呢�Q�写个测试类�Q?br />

using System;
using Acme.Collections;
public class Test
{
    public static void Main()
    {
        Stack stack = new Stack();
        stack.push(1);
        stack.push(10);
        stack.push(100);

        Console.WriteLine(stack.pop());
        Console.WriteLine(stack.pop());
        Console.WriteLine(stack.pop());
    }
}

很明显，只是把java的import换成了using�Q�而且不需要通配�W�。编译test.cs:csc /r:stack.dll test.cs�?br /> C#和ruby��是�?7�q�主要的学习计划�Q�另外就是J2EE深入技术方面的掌握和理�?特别是模式、工作流和Portal斚w��?br />

dennis 2007-02-09 10:38 发表评论