http://www.ywqi.com/index.php zh-cn http://www.ywqi.com/read.php/491.htm bgaidu <admin@yourname.com> Wed, 03 Mar 2010 07:17:25 +0000 http://www.ywqi.com/read.php/491.htm
　　游历任务：蓝色任务。经验高，也是跑路多。到一定级别就能接到相应的任务（多使用查找最新任务这个功能）。经验颇高，而且有称号奖励。 内容来自dedecms

　　挑战任务：红色任务……很难接到，经验颇高，有几率得到物品奖励比如：魔影（天工宝鉴）。 dedecms.com

　　寻宝任务：橘Y任务。很低等级可以接到，完成任务需要的道具都要从寻宝任务中随机获得。很难接到，经验一般。有物品奖励。但是好浪费时间

dedecms.com

　　平妖任务：暗绿色任务，经验高，容易接到。

内容来自dedecms

　　试练任务：白色任务，接得最多的任务。60级以前有概率得到紫星石，60以后有概率得到暗月石，刷当级别传功必备。

内容来自dedecms

　　诛仙任务和游历任务的特点就是经验奖励高，但是做起来麻烦，很耗时间。建议有效率队伍的时候不要做诛仙任务和游历任务，队伍效率的时候刷任务管理员那里接的任务，那是最快的，一满队人，10来分钟就可以刷一轮任务（5个任务接满）。但是人总有落单的时候，你不可能永远在效率队伍里的，特别是级别冲到了前面就比较孤单了，队伍很难组了，这种时候就做诛仙任务和游历任务比较划算了。

copyright dedecms


　　要什么样的队伍才算效率呢？我个人觉得职业无所谓，因为这个游戏的职业平衡比武林好，组满队以后，每种职业都可以做为输出，都可以贡献自己的力量，所以我组人一般都不分职业。在我的概念里，大家级别差不多，都努力打怪不偷懒，5到6个人的队伍就是效率队伍了。

copyright dedecms


　　有了效率的队伍以后，就是升级的路线了，下面介绍一下我升级的路线，供大家参考。

dedecms.com

　　1到15级就很简单了。做完这个级别的诛仙和游历就差不多14级了，到了14级没有诛仙任务和游历任务了，就组好队伍去任务管理员那里接试练任务吧，这个级别主要刷去草庙村路上的怨灵和凶灵这两种怪的任务，大概个把小时不到就可以到15级了，选择好自己的门派组转职去吧。

织梦内容管理系统

　　转好职业就该去青云混了，做完青云地图的诛仙任务和游历任务，你也差不多23级了，这时候刷野猪，通臂猿的任务升到24. 内容来自dedecms

　　24到28：组好效率队伍，在青云任务管理员那里接剑奴和剑魔的任务，接满5个，就去青云后山刷怪了，如果队伍好，大概10分钟就可以刷完任务回去交了。这个级别就不停的刷这里的任务。 织梦好，好织梦

　　28到30：在后山升到了28就可以接到猫女，神火教护法，幼齿猫女的任务了，因为这几种怪的位置距离城里比较远，路上很容易造成队伍分散，所以建议队伍里的人一起接任务一起去刷，然后一起回来交任务。在这里刷到30以后就换装备吧，准备去天音咯。

dedecms.com

　　30到34：30级以后，诛仙任务和游历任务在升级的时候占的比例比较小了，所以在有效率队伍的时候建议先不做，等每队伍的时候再做。这个级别就接门口的鸦人和黑熊兽妖的任务，也是接满5个任务直奔怪点去刷，经验相当快。

内容来自dedecms

　　34到38：这个级别主要接骷髅魔兵和山贼的任务，最近的骷髅魔兵和山贼在天音地图的仙姝林，这个级别段也是比较好冲的。

本文来自织梦


　　38到42是天音地图最难冲的，因为这个级别要刷的是流寇和骷髅魔兵，而这两种怪的任务相对比较少，任何一种怪的任务都接不满5个，所以一般接三个流寇任务，两个骷髅射手的任务，而最让人郁闷的是，这两种怪是分开的，不象前面的怪在一个区域。所以队伍很容易分散，因此还是建议大家统一行动，一起接任务，一起交任务。

本文来自织梦


　　42到45是比较好冲的，前面刷了那么多任务，这个时候你的紫星石应该不少了吧，做做传功，做做游历和诛仙任务，很容易就44了，到44以后建议不要刷传功，因为44级可以接到很多人梦想的马牌任务，所以建议44以后接凶鸦和嗜血妖僧的白任务刷，这样刷到马牌的概率大，而且冲级也快。

织梦好，好织梦

　　到了45级就去河阳自己的门派使者那里接转职任务吧（顺便鄙视一下完美，鬼王的转职要杀500个比自己级别高的蜘蛛，而且是在换装备之前杀，太变态了，偶当时杀了一个下午啊）

织梦好，好织梦


　　做完转职就该去流波混了，升级没其他法门，还是组起效率队，队伍效率才是升级的王道。

copyright dedecms

　　45到49：到了流波以后我几乎就放弃了做诛仙任务和游历任务了，这个级别段就不停的刷门口的蜘蛛（毒蜘蛛和5花蛛），组好队伍接好任务，就开始冲级吧。 织梦好，好织梦

　　49到53：这个级别主要刷螃蟹（铁背蟹和横行蟹），怪也在门口，螃蟹和蜘蛛都在门口，离村子里好近的，所以这段时间冲级显得很轻松。 copyright dedecms

　　53到57：这个级别主要刷海女和流波海贼。这里的任务在地图上看起来好象离村子比较远，其实并不远的，因为渡口那里有个传送，那里传送过去很快就到鱼澄溪和流波水塞之间那块沙滩就是这两种怪的最近点，我一般都组队伍去那里刷，因为近嘛，所以刷任务快些的。 本文来自织梦

　　57到60：这个级别段比较难升，任务比较难接，而且是血蜘蛛，流波海盗和远古犀甲人这三种怪的任务，最变态的就是血蜘蛛了，技能多多，还是主动攻击的，可怜我的小青云，云天帅帅在那里挂了N次咯（网络卡，米办法）。所以我一般都接海盗和犀甲人的任务去那里刷，能不接血蜘蛛的就尽量不接（偶怕怕）。要想尽快结束这段非人的生涯，紫星刷传功是必不可少的，不过那是有钱人的玩法，仅贡参考哈。

本文来自织梦

　　到了60去死亡沼泽，升级又开始变容易了。 copyright dedecms

　　60到65：以前一直是接耕地任务，接了任务跑到任务地点，然后回来交，一分钟可以做两次，升级很快的，不过现在更新了之后，貌似耕地任务每以前那么好接了，以前60级到75级，有这个任务都是必接的。现在不好接到耕地任务了，就只要刷门口的死泽孤魂和死泽巨鳄好了，怪点里城近，升级刷任务都很容易，还有暗月石（60级以后的传功任务必须）拿。

本文来自织梦

　　65到68：这个级别刷的是蚂蚁（蜢毒蚁和腐尸蚁），怪在长生堂废墟处，接好任务组好队就开始刷吧，跟前面升级也没什么两样。 copyright dedecms

　　68到72：主要刷死泽铁鳄和毒血飞芒，怪在毒蚁巢处，65到68刷的怪都离村子不算远，练起来也算比较容易吧，只是升级需要的经验多了，花的时间当然也要多些，但是这个是一种必然，没办法解决的。68级以后打怪好耗药，因为怪的攻击太高了，但是打出来的东西也很值钱，比如75的配方，一个就可以卖10来金，再比如75的材料，那也是高价啊，所以在这里是不会穷的，放心大胆的喝药冲级吧。 织梦好，好织梦

　　72到75：到了72，你也是个高手了，也不用我多说什么，就接死泽野鬼和死泽鱼人的任务刷，怪在内泽那里，离城里也不算远，但是这个时候升级需要的经验实在是太多了，需要的时间也太多了，不过好在前面应该刷到了不少暗月石，刷传功应该可以帮助你升一级，如果你有钱，也可以收暗月石刷。
]]> http://www.ywqi.com/read.php/490.htm bgaidu <admin@yourname.com> Sun, 28 Feb 2010 00:03:04 +0000 http://www.ywqi.com/read.php/490.htm
C#时间间隔计算举例说明：

实现两个时间之间C#时间间隔计算：

TimeSpan ts1 = new TimeSpan(DateTime.Now.Ticks);
//获取当前时间的刻度数 //你的代码或者其他操作 TimeSpan ts2 = new TimeSpan(DateTime.Now.Ticks);
TimeSpan ts = ts2.Subtract(ts1).Duration();
//时间差的绝对值 String spanTime = ts.Hours.ToString() + "小时" + ts.Minutes.ToString() + "分" + ts.Seconds.ToString() + "秒";
//以X小时X分X秒的格式现实执行时间 C#时间间隔计算的一些说明：

TimeSpan值包含了许多属性与方法，用于访问或处理一个TimeSpan值

下面的列表涵盖了其中的一部分：

Add：与另一个TimeSpan值相加。

Days:返回用天数计算的TimeSpan值。

Duration:获取TimeSpan的绝对值。

Hours:返回用小时计算的TimeSpan值

Milliseconds:返回用毫秒计算的TimeSpan值。

Minutes:返回用分钟计算的TimeSpan值。

Negate:返回当前实例的相反数。

Seconds:返回用秒计算的TimeSpan值。

Subtract:从中减去另一个TimeSpan值。

Ticks:返回TimeSpan值的tick数。

TotalDays:返回TimeSpan值表示的天数。

TotalHours:返回TimeSpan值表示的小时数。

TotalMilliseconds:返回TimeSpan值表示的毫秒数。

TotalMinutes:返回TimeSpan值表示的分钟数。

TotalSeconds:返回TimeSpan值表示的秒数。
]]> http://www.ywqi.com/read.php/489.htm bgaidu <admin@yourname.com> Thu, 25 Feb 2010 02:27:11 +0000 http://www.ywqi.com/read.php/489.htm
首先介绍一下HTTP协议，HTTP亦即Hpyer Text Transfer Protocal的缩写，它是现代互联网上最重要的一种网络协议，超文本传输协议位于TCP/IP协议的应用层，是一个面向无连接、简单、快速的C/S结构的协议。HTTP的工作过程大体上分连接、请求、响应和断开连接四个步骤。C#语言对HTTP协议提供了良好的支持，在.NET类库中提供了WebRequest和WebResponse类，这两个类都包含在System.Net命名空间中，利用这两个类可以实现很多高级的网络功能，本文中多线程文件下载就是利用这两个类实现的。 WebRequest和WebResponse都是抽象基类，因此在程序中不能直接作为对象使用，必须被继承，实际使用中，可根据URI参数中的URI前缀选用它们合适的子类，对于HTTP这类URI,HttpWebRequest和HttpWebResponse类可以用于处理客户程序同WEB服务器之间的HTTP通讯。
HttpWebRequest类实现了很多通过HTTP访问WEB服务器上文件的高级功能。HttpWebRequest类对WebRequest中定义的属性和方法提供支持，HttpWebRequest将发送到Internet资源的公共HTTP标头的值公开为属性，由方法或系统设置，常用的由属性或方法设置的HTTP标头为：接受, 由Accept属性设置, 连接, 由Connection属性和KeepAlive属性设置, Content-Length, 由ContentLength属性设置, Content-Type, 由ContentType属性设置, 范围, 由AddRange方法设置. 实际使用中是将标头信息正确设置后,传递到WEB服务器,WEB服务器根据要求作出回应。

　　HttpWebResponse类继承自WebResponse类，专门处理从WEB服务器返回的HTTP响应，这个类实现了很多方法，具有很多属性，可以全面处理接收到的互联网信息。在HttpWebResponse类中，对于大多数通用的HTTP标头字段，都有独立的属性与其对应，程序员可以通过这些属性方便的访问位于HTTP接收报文标头字段中的信息，本例中用到的HttpWebResponse类属性为：ContentLength 既接收内容的长度。



c#代码：（Form1.cs）

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

using System.Net;
using System.IO;
using System.Threading;

namespace HttpTransfer
{
    public partial class Form1 : Form
    {
        public bool[] threadw;//每个线程结束标志
        public string[] filenamew;//每个线程接收文件的文件名
        public int[] filestartw;//每个线程接收文件的起始位置
        public int[] filesizew;//每个线程接收文件的大小
        public string strurl;//接收文件的url
        public bool hb;//文件合并标志
        public int thread;//进程数

        //UI上的控件不是线程安全的,所以跨线程的操作UI控件需要通过Invoke的方式
        delegate void SetTextCallback(string text);
        private void SetText(string text)
        {
            if (this.textBox4.InvokeRequired)
            {
                SetTextCallback d = new SetTextCallback(SetText);
                this.Invoke(d, new object[] { text });
            }
            else
            {
                this.textBox1.Text = text;
            }
        }


        public Form1()
        {
            InitializeComponent();
          
        }

        private void button1_Click(object sender, EventArgs e)
        {
            DateTime dt = DateTime.Now;//开始接收时间
            textBox4.Text = dt.ToString();
            strurl = textBox1.Text.Trim().ToString();
            HttpWebRequest request;
            long filesize = 0;
            try
            {
                request = (HttpWebRequest)HttpWebRequest.Create(strurl);
                filesize = request.GetResponse().ContentLength;//取得目标文件的长度
                this.label5.Text = "文件大小为" + Convert.ToString(filesize) + "bytes";
                request.Abort();
            }
            catch (Exception er)
            {
                MessageBox.Show(er.Message);
            }
            // 接收线程数
            thread = Convert.ToInt32(textBox3.Text.Trim().ToString(), 10);
            //根据线程数初始化数组
            threadw = new bool[thread];
            filenamew = new string[thread];
            filestartw = new int[thread];
            filesizew = new int[thread];

            //计算每个线程应该接收文件的大小
            int filethread = (int)filesize / thread;//平均分配
            int filethreade = filethread + (int)filesize % thread;//剩余部分由最后一个线程完成
            //为数组赋值
            for (int i = 0; i < thread; i++)
            {
                threadw[i] = false;//每个线程状态的初始值为假
                filenamew[i] = i.ToString() + ".dat";//每个线程接收文件的临时文件名
                if (i < thread - 1)
                {
                    filestartw[i] = filethread * i;//每个线程接收文件的起始点
                    filesizew[i] = filethread - 1;//每个线程接收文件的长度
                }
                else
                {
                    filestartw[i] = filethread * i;
                    filesizew[i] = filethreade - 1;
                }
            }
            //定义线程数组，启动接收线程
            Thread[] threadk = new Thread[thread];
            HttpFile[] httpfile = new HttpFile[thread];
            for (int j = 0; j < thread; j++)
            {
                httpfile[j] = new HttpFile(this, j);
                threadk[j] = new Thread(new ThreadStart(httpfile[j].receive));
                threadk[j].Start();
            }
            //启动合并各线程接收的文件线程
            Thread hbth = new Thread(new ThreadStart(hbfile));
            hbth.Start();

        }

      

        //合并线程
        public void hbfile()
        {
            string locaUrl = this.textBox2.Text.Trim();
            while (true)//等待
            {
                hb = true;
                for (int i = 0; i < thread; i++)
                {
                    if (threadw[i] == false)//有未结束线程，等待
                    {
                        hb = false;
                        Thread.Sleep(100);
                        break;
                    }
                }
                if (hb == true)//所有线程均已结束，停止等待，
                {
                    break;
                }
            }
            FileStream fs;//开始合并
            FileStream fstemp;
            int readfile;
            byte[] bytes = new byte[512];
            fs = new FileStream(locaUrl, System.IO.FileMode.Create);
            for (int k = 0; k < thread; k++)
            {
                fstemp = new FileStream(filenamew[k], System.IO.FileMode.Open);
                while (true)
                {
                    readfile = fstemp.Read(bytes, 0, 512);
                    if (readfile > 0)
                    {
                        fs.Write(bytes, 0, readfile);
                    }
                    else
                    {
                        break;
                    }
                }
                fstemp.Close();
            }
            fs.Close();
            DateTime dt = DateTime.Now;
            textBox4.Text = dt.ToString();//结束时间
            //SetText(dt.ToString());
            MessageBox.Show("接收完毕!!!");
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;//UI上的控件不是线程安全的，用来屏蔽跨线程搞用控件时抛出的异常。
        }
    }

  
}


(HttpFile类)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.IO;
using System.Threading;
using System.Windows.Forms;

namespace HttpTransfer
{
    //此类用于管理线程
    public class HttpFile
    {
        public Form1 formm;
        public int threadh;//线程代号
        public string filename;//文件名
        public string strUrl;//接收文件的url
        public FileStream fs;
        public HttpWebRequest request;
        public System.IO.Stream ns;
        public byte[] nbytes;//接收缓冲区
        public int nreadsize;//接收字节数

        delegate void SetTextCallback(ListBox control, string text);

        public HttpFile(Form1 form, int thread)//构造方法
        {
            formm = form;
            threadh = thread;
        }

        ~HttpFile()//析构方法
        {
            formm.Dispose();
        }

        public void receive()//接收线程
        {
            //string strThreadinfo = string.Empty;//显示在listbox里的信息
            filename = formm.filenamew[threadh];
            strUrl = formm.strurl;
            ns = null;
            nbytes = new byte[512];
            nreadsize = 0;
            formm.listBox1.Items.Add("线程" + threadh.ToString() + "开始接收");
            //strThreadinfo = "线程" + threadh.ToString() + "开始接收";
            //UpdateListBox(formm.listBox1, strThreadinfo);
            fs = new FileStream(filename, System.IO.FileMode.Create);
            try
            {
                request = (HttpWebRequest)HttpWebRequest.Create(strUrl);
                //接收的起始位置及接收长度
                //request.AddRange(formm.filestartw[threadh], formm.filestartw[threadh] + formm.filesizew[threadh]);
                request.AddRange(formm.filestartw[threadh],formm.filestartw[threadh]+formm.filesizew[threadh]);
                ns = request.GetResponse().GetResponseStream();//获得接收流
                nreadsize = ns.Read(nbytes, 0, 512);
                while (nreadsize > 0)
                {
                    fs.Write(nbytes, 0, nreadsize);
                    nreadsize = ns.Read(nbytes, 0, 512);
                    formm.listBox1.Items.Add("线程" + threadh.ToString() + "正在接收");
                    //strThreadinfo = "线程" + threadh.ToString() + "开始接收";
                    //UpdateListBox(formm.listBox1, strThreadinfo);
                }
                fs.Close();
                ns.Close();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            formm.listBox1.Items.Add("进程" + threadh.ToString() + "接收完毕！");
            //strThreadinfo = "线程" + threadh.ToString() + "开始接收";
            //UpdateListBox(formm.listBox1, strThreadinfo);

            formm.threadw[threadh] = true;
        }

        //UI上的控件不是线程安全的,所以跨线程的操作UI控件需要通过Invoke的方式
        private void UpdateListBox(ListBox control, string text)
        {
            if (control.InvokeRequired)
            {
                SetTextCallback d = new SetTextCallback(UpdateListBox);
                control.Invoke(d, new object[] { control, text });
            }
            else
            {
                control.Items.Add(text);
            }
        }
    }
}

]]> http://www.ywqi.com/read.php/488.htm bgaidu <admin@yourname.com> Thu, 25 Feb 2010 02:25:10 +0000 http://www.ywqi.com/read.php/488.htm
　　可见，TcpClient 类基于 Socket 类构建，这是它能够以更高的抽象程度提供 TCP 服务的基础。正因为这样，许多应用层上的通讯协议，比如FTP(File Transfers Protocol)文件传输协议、HTTP(Hypertext Transfers Protocol)超文本传输协议等都直接创建在TcpClient等类之上。

　　TCPClient 类使用 TCP 从 Internet 资源请求数据。TCP 协议建立与远程终结点的连接，然后使用此连接发送和接收数据包。TCP 负责确保将数据包发送到终结点并在数据包到达时以正确的顺序对其进行组合。

　　从名字上就可以看出，TcpClient类专为客户端设计，它为 TCP 网络服务提供客户端连接。TcpClient 提供了通过网络连接、发送和接收数据的简单方法。

　　若要建立 TCP 连接，必须知道承载所需服务的网络设备的地址(IPAddress)以及该服务用于通讯的 TCP 端口 (Port)。Internet 分配号码机构 (Internet Assigned Numbers Authority, IANA) 定义公共服务的端口号（你可以访问 http://www.iana.org/assignments/port-numbers获得这方面更详细的资料）。IANA 列表中所没有的服务可使用 1,024 到 65,535 这一范围中的端口号。要创建这种连接，你可以选用TcpClient类的三种构造函数之一：

　　1、public TcpClient()当使用这种不带任何参数的构造函数时，将使用本机默认的ip地址并将使用默认的通信端口号0。这样情况下，如果本机不止一个ip地址，将无法选择使用。以下语句示例了如何使用默认构造函数来创建新的 TcpClient：

TcpClient tcpClientC = new TcpClient();

　　2、public TcpClient(IPEndPoint)使用本机IPEndPoint创建TcpClient的实例对象。上一篇介绍过了，IPEndPoint将网络端点表示为IP地址和端口号，在这里它用于指定在建立远程主机连接时所使用的本地网络接口（IP 地址）和端口号，这个构造方法为使用本机IPAddress和Port提供了选择余地。下面的语句示例了如何使用本地终结点创建 TcpClient 类的实例：

IPHostEntry ipInfo=Dns.GetHostByName("www.tuha.net");//主机信息
IPAddressList[] ipList=ipInfo.AddressList;//IP地址数组
IPAddress ip=ipList[0];//多IP地址时一般用第一个
IPEndPoint ipEP=new IPEndPoint(ip,4088);//得到网络终结点
try{
TcpClient tcpClientA = new TcpClient(ipLocalEndPoint);
}
catch (Exception e ) {
Console.WriteLine(e.ToString());
}

　　到这里，你可能会感到困惑，客户端要和服务端创建连接，所指定的IP地址及通信端口号应该是远程服务器的呀！事实上的确如此，使用以上两种构造函数，你所实现的只是TcpClient实例对象与IP地址和Port端口的绑定，要完成连接，你还需要显式指定与远程主机的连接，这可以通过TcpClient类的Connect方法来实现， Connet方法使用指定的主机名和端口号将客户端连接到 远程主机：

　　1)、public void Connect(IPEndPoint); 使用指定的远程网络终结点将客户端连接到远程 TCP 主机。

public void Connect(IPAddress, int); 使用指定的 IP 地址和端口号将客户端连接到 TCP 主机。

public void Connect(string, int); 将客户端连接到指定主机上的指定端口。

　　需要指出的是，Connect方法的所有重载形式中的参数IPEndPoint网络终结点、IPAddress以及表现为string的Dns主机名和int指出的Port端口均指的是远程服务器。

　　以下示例语句使用主机默认IP和Port端口号0与远程主机建立连接：

TcpClient tcpClient = new TcpClient();//创建TcpClient对象实例
try{
tcpClient.Connect("www.contoso.com",11002);//建立连接
}
catch (Exception e ){
Console.WriteLine(e.ToString());
}

3、public TcpClient(string, int);初始化 TcpClient 类的新实例并连接到指定主机上的指定端口。与前两个构造函数不一样，这个构造函数将自动建立连接，你不再需要额外调用Connect方法，其中string类型的参数表示远程主机的Dns名，如：www.tuha.net。

　　以下示例语句调用这一方法实现与指定主机名和端口号的主机相连：

try{
TcpClient tcpClientB = new TcpClient("www.tuha.net", 4088);
}
catch (Exception e ) {
Console.WriteLine(e.ToString());
}

　　前面我们说,TcpClient类创建在Socket之上，在Tcp服务方面提供了更高层次的抽象,体现在网络数据的发送和接受方面,是TcpClient使用标准的Stream流处理技术，使得它读写数据更加方便直观，同时，.Net框架负责提供更丰富的结构来处理流，贯穿于整个.Net框架中的流具有更广泛的兼容性，构建在更一般化的流操作上的通用方法使我们不再需要困惑于文件的实际内容（HTML、XML 或其他任何内容），应用程序都将使用一致的方法（Stream.Write、Stream.Read） 发送和接收数据。另外，流在数据从 Internet 下载的过程中提供对数据的即时访问，可以在部分数据到达时立即开始处理，而不需要等待应用程序下载完整个数据集。.Net中通过NetworkStream类实现了这些处理技术。

　　NetworkStream 类包含在.Net框架的System.Net.Sockets 命名空间里，该类专门提供用于网络访问的基础数据流。NetworkStream 实现通过网络套接字发送和接收数据的标准.Net 框架流机制。NetworkStream 支持对网络数据流的同步和异步访问。NetworkStream 从 Stream 继承，后者提供了一组丰富的用于方便网络通讯的方法和属性。

　　同其它继承自抽象基类Stream的所有流一样，NetworkStream网络流也可以被视为一个数据通道，架设在数据来源端(客户Client)和接收端（服务Server）之间，而后的数据读取及写入均针对这个通道来进行。

　　.Net框架中，NetworkStream流支持两方面的操作：

　　1、 写入流。写入是从数据结构到流的数据传输。

　　2、读取流。读取是从流到数据结构（如字节数组）的数据传输。

　　与普通流Stream不同的是，网络流没有当前位置的统一概念，因此不支持查找和对数据流的随机访问。相应属性CanSeek 始终返回 false，而 Seek 和 Position 方法也将引发 NotSupportedException。

　　基于Socket上的应用协议方面，你可以通过以下两种方式获取NetworkStream网络数据流：

　　1、使用NetworkStream构造函数：public NetworkStream(Socket, FileAccess, bool);（有重载方法）,它用指定的访问权限和指定的 Socket 所属权为指定的 Socket 创建 NetworkStream 类的新实例，使用前你需要创建Socket对象实例，并通过Socket.Connect方法建立与远程服务端的连接，而后才可以使用该方法得到网络传输流。示例如下：

Socket s=new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);//创建客户端Socket对象实例
try{
s.Connect("www.tuha.net",4088);//建立与远程主机的连接
}
catch(Exception e){
MessageBox.show("连接错误：" +e.Message);
}
try{
NetworkStream stream=new NetworkStream(s,FileAccess.ReadWrite,false);//取得网络传输流
}


　　2、通过TcpClient.GetStream方法：public NetworkStream etStream();它返回用于发送和接收数据的基础网络流NetworkStream。GetStream 通过将基础 Socket 用作它的构造函数参数来创建 NetworkStream 类的实例。使用前你需要先创TcpClient对象实例并建立与远程主机的连接，示例如下：

TcpClient tcpClient = new TcpClient();//创建TcpClient对象实例
Try{
tcpClient.Connect("www.tuha.net",4088);//尝试与远程主机相连
}
catch(Exception e){
MessageBox.Show("连接错误:"+e.Message);
}
try{
NetworkStream stream=tcpClient.GetStream();//获取网络传输流
}
catch(Exception e)
{
MessageBox.Show("TcpClient错误："+e.Message);
}

　　通过以上方法得到NetworkStream网络流之后,你就可以使用标准流读写方法Write和Read来发送和接受数据了。

　　以上是.Net下使用TcpClient类实现客户端编程的技术资料，为了向客户端提供这些服务，我们还需要编制相应的服务端程序，前一篇《Visual C#.Net网络程序开发-Socket篇》上曾经提到， Socket作为其他网络协议的基础，既可以面向客户端开发，也可以面向服务端开发，在传输层面上使用较多，而在应用协议层面上，客户端我们采用构建于Socket类之上的TcpClient取代Socket；相应地，构建于Socket之上的TcpListener提供了更高理念级别的 TCP 服务，使得我们能更方便地编写服务端应用程序。正是因为这样的原因，像FTP 和 HTTP 这样的应用层协议都是在 TcpListener 类的基础上建立的。

　　.Net中的TCPListener 用于监视TCP 端口上的传入请求，通过绑定本机IP地址和相应端口（这两者应与客户端的请求一致）创建TcpListener对象实例,并由Start方法启动侦听；当TcpListener侦听到用户端的连接后，视客户端的不同请求方式，通过AcceptTcpClient 方法接受传入的连接请求并创建 TcpClient 以处理请求，或者通过AcceptSocket 方法接受传入的连接请求并创建 Socket 以处理请求。最后，你需要使用 Stop 关闭用于侦听传入连接的 Socket，你必须也关闭从 AcceptSocket 或 AcceptTcpClient 返回的任何实例。这个过程详细解说如下：

　　首先，创建TcpListener对象实例，这通过TcpListener类的构造方法来实现：

public TcpListener(port);//指定本机端口
public TcpListener(IPEndPoint)//指定本机终结点
public TcpListener(IPAddress,port)//指定本机IP地址及端口

　　以上方法中的参数在前面多次提到，这里不再细述，唯一需要提醒的是，这些参数均针对服务端主机。下面的示例演示创建 TcpListener 类的实例：

IPHostEntry ipInfo=Dns.Resolve("127.0.0.1");//主机信息
IPAddressList[] ipList=ipInfo.IPAddressList;//IP数组
IPAddress ip=ipList[0];//IP
try{
TcpListener tcpListener = new TcpListener(ipAddress, 4088);//创建TcpListener对象实例以侦听用户端连接
}
catch ( Exception e){
MessageBox.Show("TcpListener错误："+e.Message);
}

　　随后，你需要调用Start方法启动侦听：

public void Start();

　　其次，当侦听到有用户端连接时，需要接受挂起的连接请求，这通过调用以下两方法之一来完成连接：

public Socket AcceptSocket();
public TcpClient AcceptTcpClient();

　　前一个方法返回代表客户端的Socket对象，随后可以通过Socket 类的 Send 和 Receive 方法与远程计算机通讯；后一个方法返回代表客户端的TcpClient对象，随后使用上面介绍的 TcpClient.GetStream 方法获取 TcpClient 的基础网络流 NetworkStream，并使用流读写Read/Write方法与远程计算机通讯。

　　最后，请记住关闭侦听器：public void Stop();

　　同时关闭其他连接实例：public void Close();

下面的示例完整体现了上面的过程：

bool done = false;
TcpListener listener = new TcpListener(13);// 创建TcpListener对象实例(13号端口提供时间服务)
listener.Start();//启动侦听
while (!done) {//进入无限循环以侦听用户连接
TcpClient client = listener.AcceptTcpClient();//侦听到连接后创建客户端连接TcpClient
NetworkStream ns = client.GetStream();//得到网络传输流
byte[] byteTime = Encoding.ASCII.GetBytes(DateTime.Now.ToString());//预发送的内容(此为服务端时间)转换为字节数组以便写入流
try {
ns.Write(byteTime, 0, byteTime.Length);//写入流
ns.Close();//关闭流
client.Close();//关闭客户端连接
}
catch (Exception e) {
MessageBox.Show("流错误:"+e.Message)
}


　　综合运用上面的知识，下面的实例实现了简单的网络通讯-双机互连，针对客户端和服务端分别编制了应用程序。客户端创建到服务端的连接，向远程主机发送连接请求连接信号，并发送交谈内容；远程主机端接收来自客户的连接，向客户端发回确认连接的信号，同时接收并显示客户端的交谈内容。在这个基础上，发挥你的创造力，你完全可以开发出一个基于程序语言(C#)级的聊天室！

　　客户端主要源代码：

public void SendMeg()//发送信息
{
try
{


int port=Int32.Parse(textBox3.Text.ToString());//远程主机端口
try
{
tcpClient=new TcpClient(textBox1.Text,port);//创建TcpClient对象实例 }
catch(Exception le)
{
MessageBox.Show("TcpClient Error:"+le.Message);
}
string strDateLine=DateTime.Now.ToShortDateString()+" "+DateTime.Now.ToLongTimeString();//得到发送时客户端时间
netStream=tcpClient.GetStream();//得到网络流
sw=new StreamWriter(netStream);//创建TextWriter,向流中写字符
string words=textBox4.Text;//待发送的话
string content=strDateLine+words;//待发送内容
sw.Write(content);//写入流
sw.Close();//关闭流写入器
netStream.Close();//关闭网络流
tcpClient.Close();//关闭客户端连接
}
catch(Exception ex)
{
MessageBox.Show("Sending Message Failed!"+ex.Message);
}
textBox4.Text="";//清空
}

　　服务器端主要源代码：

public void StartListen()//侦听特定端口的用户请求
{
//ReceiveMeg();
isLinked=false; //连接标志
try
{
int port=Int32.Parse(textBox1.Text.ToString());//本地待侦听端口
serverListener=new TcpListener(port);//创建TcpListener对象实例
serverListener.Start(); //启动侦听
}
catch(Exception ex)
{
MessageBox.Show("Can‘t Start Server"+ex.Message);
return;
}
isLinked=true;
while(true)//进入无限循环等待用户端连接
{
try
{
tcpClient=serverListener.AcceptTcpClient();//创建客户端连接对象
netStream=tcpClient.GetStream();//得到网络流
sr=new StreamReader(netStream);//流读写器
}
catch(Exception re)
{
MessageBox.Show(re.Message);
}
string buffer="";
string received="";
received+=sr.ReadLine();//读流中一行
while(received.Length!=0)
{
buffer+=received;
buffer+="\r\n";
//received="";
received=sr.ReadLine();
}
listBox1.Items.Add(buffer);//显示
//关闭
sr.Close();
netStream.Close();
tcpClient.Close();
}
}

注：此文来自网络

]]> http://www.ywqi.com/read.php/487.htm bgaidu <admin@yourname.com> Wed, 24 Feb 2010 08:39:45 +0000 http://www.ywqi.com/read.php/487.htm
server端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.IO;
using System.Net.Sockets;

namespace ConsoleSocketServer
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int port = 4000;
                string host = "127.0.0.1";
                IPAddress ipa = IPAddress.Parse(host);//将IP字符串转换为IP地址的实例
                IPEndPoint ipe = new IPEndPoint(ipa, port);//将网络端点表示为ip地址和端口号
                Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//创建一个socket类
                s.Bind(ipe);//绑定端口号
                s.Listen(0);//开始监听
                Console.WriteLine("wait for connect");
                Socket tmp = s.Accept();//为新连接创建新的socket
                Console.WriteLine("get a connect");
                string recvStr = "";
                byte[] recvBytes = new byte[1024];
                int bytes;
                bytes = tmp.Receive(recvBytes, recvBytes.Length, 0);//从客户端接收信息
                recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);
                Console.WriteLine("get message:{0}", recvStr);//把从客户端传来的信息显示出来
                string sendStr = "Yeah! Client send message sucessful";
                byte[] bs = Encoding.ASCII.GetBytes(sendStr);
                tmp.Send(bs, bs.Length, 0);//返回客户端成功信息
                tmp.Close();
                s.Close();

            }
            catch (ArgumentNullException ex)
            {
                Console.WriteLine(ex);

            }
            catch (SocketException ex)
            { Console.WriteLine(ex); }

            Console.WriteLine("press enter to exit");
            Console.ReadLine();
        }
    }
}


Client端：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace ConsoleSocketClient
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int port = 4000;
                string host = "127.0.0.1";
                IPAddress ipa = IPAddress.Parse(host);
                IPEndPoint ipe = new IPEndPoint(ipa, port);//把ip和端口转化为ipendpoint实例
                Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//创建一个socket
                Console.WriteLine("connecting.....");
                s.Connect(ipe);//连接到服务器
                string sendStr = "Hello! Socket Test";
                byte[] bs = Encoding.ASCII.GetBytes(sendStr);
                Console.WriteLine("SendMessage");
                s.Send(bs, bs.Length, 0);//发送测试信息
                string recvStr = "";
                byte[] recvBytes = new byte[1024];
                int bytes;
                bytes = s.Receive(recvBytes, recvBytes.Length, 0);//从服务器端接收返回信息
                recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);
                Console.WriteLine("ClientGetMessage:{0}", recvStr);//显示服务器返回信息
                s.Close();
            }
            catch (ArgumentNullException ex)
            { Console.WriteLine(ex); }
            catch (SocketException ex)
            { Console.WriteLine(ex); }
            Console.WriteLine("press enter to exit");
            Console.ReadLine();
        }
    }
}
启动server端，然后再启动客户端
]]> http://www.ywqi.com/read.php/486.htm bgaidu <admin@yourname.com> Wed, 24 Feb 2010 07:54:56 +0000 http://www.ywqi.com/read.php/486.htm
首先新建一个工程，然后完成对第三方库Utilities的引用。

然后开打Form1的代码编辑窗口，在窗体类中添加一个 后门类KeyboardIncantationMonitor
C# codeprivate KeyboardIncantationMonitor m_KeyBackDoor = new KeyboardIncantationMonitor();


新建一个私有成员函数，并添加两个后门
C# code
private void AddBackDoor()
{
    //! 第一个后门
    do
    {
        //! 申请一个后门暗号
        KeyboardIncantationMonitor.KeysIncantation tInc = m_KeyBackDoor.NewIncantation() as KeyboardIncantationMonitor.KeysIncantation;

        //! 初始化这个暗号为：依次按下 <Esc>HELLO<Enter>
        tInc.AddKey(Keys.Escape);
        tInc.AddKey(Keys.H);
        tInc.AddKey(Keys.E);
        tInc.AddKey(Keys.L);
        tInc.AddKey(Keys.L);
        tInc.AddKey(Keys.O);
        tInc.AddKey(Keys.Enter);

        //! 对上暗号以后的处理程序
        tInc.IncantationCantillatedReport += new IncantationReport(BackdoorHandler_A);

        //! 将这个暗号添加到后门监视器里面
        m_KeyBackDoor.AddIncantation(tInc);
    }
    while (false);

    //! 第二个后门
    do
    {
        //! 申请一个后门暗号
        KeyboardIncantationMonitor.KeysIncantation tInc = m_KeyBackDoor.NewIncantation() as KeyboardIncantationMonitor.KeysIncantation;

        //! 初始化这个暗号为：依次按下 <Esc>Bye<Enter>
        tInc.AddKey(Keys.Escape);
        tInc.AddKey(Keys.B);
        tInc.AddKey(Keys.Y);
        tInc.AddKey(Keys.E);
        tInc.AddKey(Keys.Enter);

        //! 对上暗号以后的处理程序
        tInc.IncantationCantillatedReport += new IncantationReport(BackdoorHandler_B);

        //! 将这个暗号添加到后门监视器里面
        m_KeyBackDoor.AddIncantation(tInc);
    }
    while (false);
}

//! 第一个后门的处理程序
void BackdoorHandler_A(IIncantation tInc)
{
    button1.Visible = true;
}

//! 第二个后门的处理程序
void BackdoorHandler_B(IIncantation tInc)
{
    button1.Visible = false;
}



在Form1的构造函数中增加对AddBackDoor方法的调用，这样我们就把后门加好了
C# code
public Form1()
{
     InitializeComponent();

     //! 加入后门
     AddBackDoor();
}




在什么地方安插后门呢？依照个人喜好了，不过既然是一个按键后门，肯定要选择一个能接收KeyDown或者KeyUp事件的地方。
比如我们在Form1上增加一个文本框，将其ReadOnly属性设置为True，并添加一段文字：“版权所有，翻版必究”。并在窗体上增加一个按钮，作为我们演示的对象：普通状况下，看不到这个按钮，开启后门以后，按钮的visible属性就变为true，我们就能看见了；我们也可以使用另外一个后门重新将按钮的visible属性设置为false，然后就可以交给客户了。^_^

选中刚才所说的文本框控件，在Property窗口中选择Event，双击KeyDown，进入代码编辑窗口，并在KeyDown处理程序中加入对后门监视器的处理：也就是把按下的键告诉监视器：
C# code
        private void textBox1_KeyDown(object sender, KeyEventArgs e)
        {
            //! 告诉后门监视器哪个键被按下了
            m_KeyBackDoor.Append(e.KeyCode);
        }

        //在后门处理程序A中将Button的Visible属性设置为True;
        //! 第一个后门的处理程序
        void BackdoorHandler_A(IIncantation tInc)
        {
            button1.Visible = true;
        }
        //在后门处理程序B中将Button的Visible属性设置为False;
        //! 第二个后门的处理程序
        void BackdoorHandler_B(IIncantation tInc)
        {
            button1.Visible = false;
        }



最后，别忘记把Button的visible属性设置为False，否则怎么向我们的客户隐藏这个按钮呢？


运行程序，果然看不到Button，他被隐藏了
选中写有“翻版必究”的文本框，依次按下： <Esc> <H> <E> <L> <L> <O> <Enter> 键, button1出现了
依次按下： <Esc> <B> <Y> <E> <Enter> 键, button1又消失了

大功告成。
无论任何时候你都可以从头开始输入后门，不必担心上次从什么地方开始的。当然，也不用考虑大小写。
Have a good time.

]]> http://www.ywqi.com/read.php/485.htm bgaidu <admin@yourname.com> Sat, 20 Feb 2010 03:09:28 +0000 http://www.ywqi.com/read.php/485.htm
用：

        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Control && e.KeyCode == Keys.A)
            {
                btnTest_Click(this, EventArgs.Empty);
            }
        }
方法固然简单有效！但是有没有发现一个问题？那就是当程序失去焦点的时候这个热键(快捷键)就不管用了！那怎么办呢？其实办法还

是有的！又要用到Win32API了这次用：RegisterHotKey 和 UnregisterHotKey这2个函数的意思不需要我解释吧！ 看表面意思

就知道了 注册热键和注销热键我们看看他们的生命方式

[DllImportAttribute("user32.dll", EntryPoint = "RegisterHotKey")]
        public static extern bool RegisterHotKey
            (
                IntPtr hWnd,        //要注册热键的窗口句柄
                int id,             //热键编号
                int fsModifiers,    //特殊键如：Ctrl，Alt，Shift，Window
                int vk              //一般键如：A B C F1，F2 等
            );


        [DllImportAttribute("user32.dll", EntryPoint = "UnregisterHotKey")]
        public static extern bool UnregisterHotKey
            (
                IntPtr hWnd,        //注册热键的窗口句柄
                int id              //热键编号上面注册热键的编号
            );
用RegisterHotKey注册的热键即时在失去焦点的情况下也可以有效！

所有实现代码如下：
using System;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using System.Runtime.InteropServices;

namespace HotKeyTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private enum MyKeys
        {
            None = 0,
            Alt = 1,
            Ctrl = 2,
            Shift = 4,
            Win = 8
        }

        const int WM_HOTKEY = 0x312;

        private void Form1_Load(object sender, EventArgs e)
        {
            RegisterHotKey(this.Handle, 200, (int)MyKeys.Alt, (int)Keys.A); //注册热键Alt+A
            //RegisterHotKey(this.Handle, 200,(int)MyKeys.Ctrl|(int)MyKeys.Alt, (int)Keys.A); 注册热键Ctrl+Alt+A
            //RegisterHotKey(this.Handle, 200, (int)MyKeys.None, (int)Keys.F2); 注册热键F2
        }

        private void Form1_FormClosing(object sender, FormClosingEventArgs e)
        {
            UnregisterHotKey(this.Handle, 200); //注销热键
        }

        private void btnTest_Click(object sender, EventArgs e)
        {
            MessageBox.Show("btnTest单击事件被触发！");
        }

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == WM_HOTKEY)
            {
                switch (m.WParam.ToInt32())
                {
                    case 200:
                        btnTest_Click(this, EventArgs.Empty);
                        break;
                }
            }

            base.WndProc(ref m);
        }

        [DllImportAttribute("user32.dll", EntryPoint = "RegisterHotKey")]
        public static extern bool RegisterHotKey
            (
                IntPtr hWnd,        //要注册热键的窗口句柄
                int id,             //热键编号
                int fsModifiers,    //特殊键如：Ctrl，Alt，Shift，Window
                int vk              //一般键如：A B C F1，F2 等
            );

        [DllImportAttribute("user32.dll", EntryPoint = "UnregisterHotKey")]
        public static extern bool UnregisterHotKey
            (
                IntPtr hWnd,        //注册热键的窗口句柄
                int id              //热键编号上面注册热键的编号
            );
    }
} ]]> http://www.ywqi.com/read.php/484.htm bgaidu <admin@yourname.com> Sat, 20 Feb 2010 03:05:26 +0000 http://www.ywqi.com/read.php/484.htm     首先用CE或者OD或者其他反汇编工具找出游戏的内存基址！
    游戏内存基址：base = 0x006A9EC0
    游戏阳光地址：[base+0x768]+0x5560
    游戏金钱地址：[base+0x82C]+0x28
    游戏关卡地址：[base+0x82C]+0x24  //关卡如：A-B 实际值为：（A-1）×10＋B
至于如何获取这些地址不在我们这论坛研究的范围中！
对了我是用工具vs2008编写的！
新建窗体：
C# code
using System;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace PlantsVsZombiesTool
{
    /// <summary>
    ///
    /// </summary>
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
          
        }

        //启动无线阳光
        private void btnGet_Click(object sender, EventArgs e)
        {
            if (Helper.GetPidByProcessName(processName) == 0)
            {
                MessageBox.Show("哥们启用之前游戏总该运行吧！");
                return;
            }
            if (btnGet.Text == "启用-阳光无限")
            {
                timer1.Enabled = true;
                btnGet.Text = "关闭-阳光无限";
            }
            else
            {
                timer1.Enabled = false;
                btnGet.Text = "启用-阳光无限";
            }
        }

        private void timer1_Tick(object sender, EventArgs e)
        {

            if (Helper.GetPidByProcessName(processName) == 0)
            {
                timer1.Enabled = false;
                btnGet.Text = "启用-阳光无限";
            }
            int address = ReadMemoryValue(baseAddress);             //读取基址(该地址不会改变)
            address = address + 0x768;                              //获取2级地址
            address = ReadMemoryValue(address);
            address = address + 0x5560;                             //获取存放阳光数值的地址
            WriteMemory(address, 0x1869F);                          //写入数据到地址（0x1869F表示99999）
            timer1.Interval = 1000;
        }

        //启动无线金钱
        private void btnMoney_Click(object sender, EventArgs e)
        {

            if (Helper.GetPidByProcessName(processName) == 0)
            {
                MessageBox.Show("哥们启用之前游戏总该运行吧！");
                return;
            }
            if (btnMoney.Text == "启用-金钱无限")
            {
                timer2.Enabled = true;
                btnMoney.Text = "关闭-金钱无限";
            }
            else
            {
                timer2.Enabled = false;
                btnMoney.Text = "启用-金钱无限";
            }
        }

        private void timer2_Tick(object sender, EventArgs e)
        {
            if (Helper.GetPidByProcessName(processName) == 0)
            {
                timer2.Enabled = false;
                btnMoney.Text = "启用-金钱无限";
            }
            int address = ReadMemoryValue(baseAddress);             //读取基址(该地址不会改变)
            address = address + 0x82C;                              //获取2级地址
            address = ReadMemoryValue(address);
            address = address + 0x28;                               //得到金钱地址
            WriteMemory(address, 0x1869F);                          //写入数据到地址（0x1869F表示99999）
            timer2.Interval = 1000;
        }

        private void btnGo_Click(object sender, EventArgs e)
        {
            if (Helper.GetPidByProcessName(processName) == 0)
            {
                MessageBox.Show("哥们启用之前游戏总该运行吧！");
                return;
            }
            int address = ReadMemoryValue(baseAddress);             //读取基址(该地址不会改变)
            address = address + 0x82C;                              //获取2级地址
            address = ReadMemoryValue(address);
            address = address + 0x24;
            int lev = 1;
            try
            {
                lev = int.Parse(txtLev.Text.Trim());
            }
            catch
            {
                MessageBox.Show("输入的关卡格式不真确！默认设置为1");
            }

            WriteMemory(address, lev);
            
        }

        //读取制定内存中的值
        public int ReadMemoryValue(int baseAdd)
        {
            return Helper.ReadMemoryValue(baseAdd, processName);  
        }

        //将值写入指定内存中
        public void WriteMemory(int baseAdd, int value)
        {
            Helper.WriteMemoryValue(baseAdd, processName, value);
        }

        private int baseAddress = 0x006A9EC0;           //游戏内存基址
        private string processName = "PlantsVsZombies"; //游戏进程名字
    }
}




下面这个类是整个工具的核心

C# code
using System;
using System.Text;

using System.Diagnostics;
using System.Runtime.InteropServices;

namespace PlantsVsZombiesTool
{
    
    public abstract class Helper
    {
        [DllImportAttribute("kernel32.dll", EntryPoint = "ReadProcessMemory")]
        public static extern bool ReadProcessMemory
            (
                IntPtr hProcess,
                IntPtr lpBaseAddress,
                IntPtr lpBuffer,
                int nSize,
                IntPtr lpNumberOfBytesRead
            );

        [DllImportAttribute("kernel32.dll", EntryPoint = "OpenProcess")]
        public static extern IntPtr OpenProcess
            (
                int dwDesiredAccess,
                bool bInheritHandle,
                int dwProcessId
            );

        [DllImport("kernel32.dll")]
        private static extern void CloseHandle
            (
                IntPtr hObject
            );

        //写内存
        [DllImportAttribute("kernel32.dll", EntryPoint = "WriteProcessMemory")]
        public static extern bool WriteProcessMemory
            (
                IntPtr hProcess,
                IntPtr lpBaseAddress,
                int[] lpBuffer,
                int nSize,
                IntPtr lpNumberOfBytesWritten
            );

        //获取窗体的进程标识ID
        public static int GetPid(string windowTitle)
        {
            int rs = 0;
            Process[] arrayProcess = Process.GetProcesses();
            foreach (Process p in arrayProcess)
            {
                if (p.MainWindowTitle.IndexOf(windowTitle) != -1)
                {
                    rs = p.Id;
                    break;
                }
            }

            return rs;
        }

        //根据进程名获取PID
        public static int GetPidByProcessName(string processName)
        {
            Process[] arrayProcess = Process.GetProcessesByName(processName);

            foreach (Process p in arrayProcess)
            {
                return p.Id;
            }
            return 0;
        }

        //根据窗体标题查找窗口句柄（支持模糊匹配）
        public static IntPtr FindWindow(string title)
        {
            Process[] ps = Process.GetProcesses();
            foreach (Process p in ps)
            {
                if (p.MainWindowTitle.IndexOf(title) != -1)
                {
                    return p.MainWindowHandle;
                }
            }
            return IntPtr.Zero;
        }

        //读取内存中的值
        public static int ReadMemoryValue(int baseAddress,string processName)
        {
            try
            {
                byte[] buffer = new byte[4];
                IntPtr byteAddress = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0); //获取缓冲区地址
                IntPtr hProcess = OpenProcess(0x1F0FFF, false, GetPidByProcessName(processName));
                ReadProcessMemory(hProcess, (IntPtr)baseAddress, byteAddress, 4, IntPtr.Zero); //将制定内存中的值读入缓冲区
                CloseHandle(hProcess);
                return Marshal.ReadInt32(byteAddress);
            }
            catch
            {
                return 0;
            }
        }

        //将值写入指定内存地址中
        public static void WriteMemoryValue(int baseAddress, string processName, int value)
        {
            IntPtr hProcess = OpenProcess(0x1F0FFF, false, GetPidByProcessName(processName)); //0x1F0FFF 最高权限
            WriteProcessMemory(hProcess, (IntPtr)baseAddress, new int[] { value }, 4, IntPtr.Zero);
            CloseHandle(hProcess);
        }
    }
}

]]> http://www.ywqi.com/read.php/483.htm bgaidu <admin@yourname.com> Fri, 19 Feb 2010 15:25:59 +0000 http://www.ywqi.com/read.php/483.htm
--------------------------------------------GridViewLinkButton.aspx---------------------------------------------------------------
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="GridViewLinkButton.aspx.cs" Inherits="GridViewLinkButton" %>

<!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>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <asp:GridView ID="gvPersonList" runat="server" AutoGenerateColumns="False">
            <Columns>
                <asp:BoundField DataField="Id" HeaderText="编号" />
                <asp:BoundField DataField="Name" HeaderText="姓名" />
                <asp:TemplateField HeaderText="性别">
                    <ItemTemplate>
                        <%# Eval("Sex").ToString()=="true"?"男":"女" %>
                    </ItemTemplate>
                </asp:TemplateField>
                <asp:BoundField DataField="Age" HeaderText="年龄" />
                <asp:TemplateField HeaderText="婚否">
                    <ItemTemplate>
                        <%# Boolean.Parse(Eval("Married").ToString())==true?"是":"否" %>
                    </ItemTemplate>
                </asp:TemplateField>
                <asp:TemplateField HeaderText="婚否">
                    <ItemTemplate>
                        <asp:LinkButton CommandArgument='<%# Eval("Id") %>' Enabled='<%# Boolean.Parse(Eval("Married").ToString())==true?false:true %>' Text="设为结婚" runat="server" OnCommand="SetMarried"></asp:LinkButton>
                    </ItemTemplate>
                </asp:TemplateField>
            </Columns>
        </asp:GridView>
    
    </div>
    </form>
</body>
</html>

--------------------------------------GridViewLinkButton.aspx.cs------------------------------------------------
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

public partial class GridViewLinkButton : System.Web.UI.Page
{
    private string firstName = "赵钱孙李周吴郑王冯陈诸卫蒋沈韩杨朱秦尤许何吕施张孔曹严华";
    private string lastName="猛勇刚强豹彪雁燕蓉菲";
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!Page.IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable myData = CreateDataTable();
        Session["MyData"] = myData;
        gvPersonList.DataSource = myData;
        gvPersonList.DataBind();
    }
    //手动生成DataTable
    private DataTable CreateDataTable()
    {
        DataTable data = new DataTable();
        DataColumn dcId = new DataColumn("ID", typeof(Int32));
        dcId.AutoIncrement = true;
        dcId.AutoIncrementSeed = 1;
        dcId.AutoIncrementStep = 1;
        data.Columns.Add(dcId);
        data.Columns.Add(new DataColumn("Name",typeof(string)));
        data.Columns.Add(new DataColumn("Age",typeof(int)));
        data.Columns.Add(new DataColumn("Sex",typeof(bool)));
        data.Columns.Add(new DataColumn("Married",typeof(bool)));
        DataRow dataRow = null;
        Random random = new Random();
        for (int i = 0; i < 20; i++)
        {
            dataRow = data.NewRow();
            //随机生成姓名
            dataRow["Name"] = firstName.Substring(random.Next(firstName.Length), 1) + lastName.Substring(random.Next(lastName.Length), 1);
            //随即生成介于20至100之间的年龄
            int age = random.Next(20, 100);
            dataRow["Age"] = age;
            //随即设置性别
            bool sex = (random.Next(100) % 2 == 0) ? true : false;
            dataRow["Sex"] = sex;
            if (((sex == true) && (age >= 22)) || ((sex == false) && (age >= 20)))//男性结婚年龄大于22周岁，女性结婚年龄大于20周岁
            {
                dataRow["Married"] = (random.Next(500) % 2 == 0) ? true : false;
            }
            else
            {
                dataRow["Married"] = false;
            }
            data.Rows.Add(dataRow);
        }
        return data;
    }
    //LinkButton的OnCommand事件的处理方法
    public void SetMarried(Object sender, CommandEventArgs e)
    {
        e.CommandArgument.ToString();
        DataTable data = Session["MyData"] as DataTable;
        for (int i = 0; i < data.Rows.Count; i++)
        {
            if (data.Rows[i]["Id"].ToString() == e.CommandArgument.ToString())
            {
                data.Rows[i]["Married"] = true;
                break;
            }
        }
        gvPersonList.DataSource = data;
        gvPersonList.DataBind();
    }
}



本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhoufoxcn/archive/2007/06/13/1650952.aspx ]]> http://www.ywqi.com/read.php/482.htm bgaidu <admin@yourname.com> Fri, 19 Feb 2010 15:22:53 +0000 http://www.ywqi.com/read.php/482.htm 窗体设计器产生的代码：


namespace RunCMD
{
    partial class CMDForm
    {
        /// <summary>
        /// 必需的设计器变量。
        /// </summary>
        private System.ComponentModel.IContainer components = null;

        /// <summary>
        /// 清理所有正在使用的资源。
        /// </summary>
        /// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }

        #region Windows 窗体设计器生成的代码

        /// <summary>
        /// 设计器支持所需的方法 - 不要
        /// 使用代码编辑器修改此方法的内容。
        /// </summary>
        private void InitializeComponent()
        {
            this.label1 = new System.Windows.Forms.Label();
            this.txtCommand = new System.Windows.Forms.TextBox();
            this.btnExecute = new System.Windows.Forms.Button();
            this.tbResult = new System.Windows.Forms.TextBox();
            this.SuspendLayout();
            //
            // label1
            //
            this.label1.AutoSize = true;
            this.label1.Location = new System.Drawing.Point(6, 11);
            this.label1.Name = "label1";
            this.label1.Size = new System.Drawing.Size(29, 12);
            this.label1.TabIndex = 0;
            this.label1.Text = "ping";
            //
            // txtCommand
            //
            this.txtCommand.Location = new System.Drawing.Point(41, 8);
            this.txtCommand.Name = "txtCommand";
            this.txtCommand.Size = new System.Drawing.Size(269, 21);
            this.txtCommand.TabIndex = 1;
            //
            // btnExecute
            //
            this.btnExecute.Location = new System.Drawing.Point(316, 6);
            this.btnExecute.Name = "btnExecute";
            this.btnExecute.Size = new System.Drawing.Size(75, 23);
            this.btnExecute.TabIndex = 2;
            this.btnExecute.Text = "执行";
            this.btnExecute.UseVisualStyleBackColor = true;
            this.btnExecute.Click += new System.EventHandler(this.btnExecute_Click);
            //
            // tbResult
            //
            this.tbResult.Location = new System.Drawing.Point(8, 47);
            this.tbResult.Multiline = true;
            this.tbResult.Name = "tbResult";
            this.tbResult.ScrollBars = System.Windows.Forms.ScrollBars.Both;
            this.tbResult.Size = new System.Drawing.Size(383, 292);
            this.tbResult.TabIndex = 3;
            //
            // CMDForm
            //
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
            this.ClientSize = new System.Drawing.Size(403, 364);
            this.Controls.Add(this.tbResult);
            this.Controls.Add(this.btnExecute);
            this.Controls.Add(this.txtCommand);
            this.Controls.Add(this.label1);
            this.Name = "CMDForm";
            this.Text = "运行Command的例子";
            this.ResumeLayout(false);
            this.PerformLayout();

        }

        #endregion

        private System.Windows.Forms.Label label1;
        private System.Windows.Forms.TextBox txtCommand;
        private System.Windows.Forms.Button btnExecute;
        private System.Windows.Forms.TextBox tbResult;
    }
}

关键部分代码：


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;
using System.IO;

namespace RunCMD
{
    /**
     * 作者：周公
     * blog:http://blog.csdn.net/zhoufoxcn
     * 日期：2007-07-07
     *
     * */
    public partial class CMDForm : Form
    {
        public CMDForm()
        {
            InitializeComponent();
        }

        private void btnExecute_Click(object sender, EventArgs e)
        {
            tbResult.Text = "";
            ProcessStartInfo start = new ProcessStartInfo("Ping.exe");//设置运行的命令行文件问ping.exe文件，这个文件系统会自己找到
            //如果是其它exe文件，则有可能需要指定详细路径，如运行winRar.exe
            start.Arguments = txtCommand.Text;//设置命令参数
            start.CreateNoWindow = true;//不显示dos命令行窗口
            start.RedirectStandardOutput = true;//
            start.RedirectStandardInput = true;//
            start.UseShellExecute = false;//是否指定操作系统外壳进程启动程序
            Process p=Process.Start(start);
            StreamReader reader = p.StandardOutput;//截取输出流
            string line = reader.ReadLine();//每次读取一行
            while (!reader.EndOfStream)
            {
                tbResult.AppendText(line+" ");
                line = reader.ReadLine();
            }
            p.WaitForExit();//等待程序执行完退出进程
            p.Close();//关闭进程
            reader.Close();//关闭流
        }
    }
}

]]>