LongSheng | Page 378

.net连接MYSQL字符串

龙生 22 Apr 2012

View Details

public string Hello{ Response.Write("test"); Response.End9() } 客户端:2 1 using System; 2 using System.Net; 3 using System.Net.Sockets; 4 using System.Text; 5 6 public class SynchronousSocketClient { 7 8 public static void StartClient() { 9 // Data buffer for incoming data. 10 byte[] bytes = new byte[1024]; 11 12 // Connect to a remote device. 13 try { 14 // Establish the remote endpoint for the socket. 15 // This example uses port 11000 on the local computer. 16 IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName()) 17 IPAddress ipAddress = ipHostInfo.AddressList[0]; 18 IPEndPoint remoteEP = […]

龙生 21 Apr 2012

View Details

c#进制转换

/// <summary>/// 十进制转换为二进制/// </summary>/// <param name="x"></param>/// <returns></returns> public static string DecToBin(string x){string z = null;int X = Convert.ToInt32(x);int i = 0;long a, b = 0;while (X > 0){a = X%2;X = X/2;b = b + a*Pow(10, i);i++;}z = Convert.ToString(b);return z;} /// <summary>/// 16进制转ASCII码/// </summary>/// <param name="hexString"></param>/// <returns></returns> public static string HexToAscii(string hexString){StringBuilder sb = new StringBuilder();for (int i = 0; i <= hexString.Length – 2; i += 2){sb.Append(Convert.ToString(Convert.ToChar(Int32.Parse(hexString.Substring(i, 2),System.Globalization.NumberStyles.HexNumber))));}return sb.ToString();} /// <summary>/// 十进制转换为八进制/// </summary>/// <param name="x"></param>/// <returns></returns> public static string DecToOtc(string x){string z = null;int X = Convert.ToInt32(x);int […]

龙生 21 Apr 2012

View Details

深入探析c# Socket

　　最近浏览了几篇有关Socket发送消息的文章，发现大家对Socket Send方法理解有所偏差，现将自己在开发过程中对Socket的领悟写出来，以供大家参考。　　（一）架构　　基于TCP协议的Socket通信，架构类似于B/S架构，一个Socket通信服务器，多个Socket通信客户端。Socket通信服务器启动时，会建立一个侦听Socket，侦听Socket将侦听到的Socket连接传给接受Socket，然后由接受Socket完成接受、发送消息，当Socket存在异常时，断开连接。在实际开发项目中，往往要求Socket通信服务器能提供高效、稳定的服务，一般会用到以下技术：双工通信、完成端口、SAEA、池、多线程、异步等。特别是池，用的比较多，池一般包括一下几种： 1）Buffer池，用于集中管控Socket缓冲区，防止内存碎片。 2）SAEA池，用于集中管控Socket，重复利用Socket。 3）SQL池，用于分离网络服务层与数据访问层（SQL的执行效率远远低于网络层执行效率）。 4）线程池，用于从线程池中调用空闲线程执行业务逻辑，进一步提高网络层运行效率。（二）Send 　　主服务器接受Socket为一端口，客户端Socket为一端口，这两个端口通过TCP协议建立连接，通信基础系统负责管理此连接，它有两个功能：　　1）发送消息　　2）接受消息　　Socket的Send方法，并非大家想象中的从一个端口发送消息到另一个端口，它仅仅是拷贝数据到基础系统的发送缓冲区，然后由基础系统将发送缓冲区的数据到连接的另一端口。值得一说的是，这里的拷贝数据与异步发送消息的拷贝是不一样的，同步发送的拷贝，是直接拷贝数据到基础系统缓冲区，拷贝完成后返回，在拷贝的过程中，执行线程会IO等待, 此种拷贝与Socket自带的Buffer空间无关，但异步发送消息的拷贝，是将Socket自带的Buffer空间内的所有数据，拷贝到基础系统发送缓冲区，并立即返回，执行线程无需IO等待，所以异步发送在发送前必须执行SetBuffer方法，拷贝完成后，会触发你自定义回调函数ProcessSend，在ProcessSend方法中，调用SetBuffer方法，重新初始化Buffer空间。　　口说无凭，下面给个例子：　　服务器端：客户端：解释：客户端第一次发送数据：1234567890。客户端第一个接受数据：1234567890，该数据由服务端用Send同步方法发送返回。客户端第二个接受数据：1234567890，该数据由服务端用Send异步方法发送返回。以上似乎没什么异常，好，接下来，我只发送abc。客户端第一个接受数据：abc，理所当然，没什么问题。客户端第二个接受数据：abc4567890！为什么呢？应该是abc才对呀！好，现在为大家解释一下：异步发送是将其Buffer空间中所有数据拷贝到基础系统发送缓冲区，第一次拷贝1234567890到发送缓冲区，所以收到1234567890，第二次拷贝abc到发送缓冲区，替换了先前的123，所以收到abc4567890，大家明白的？源码： BufferManager

1

<div>using System.Collections.Generic; using System.Net.Sockets; // This class creates a single large buffer which can be divided up // and assigned to SocketAsyncEventArgs objects for use with each // socket I/O operation. // This enables bufffers to be easily reused and guards against // fragmenting heap memory. // // The operations exposed on the BufferManager class are not thread safe. class BufferManager { int m_numBytes; // the total number of bytes controlled by the buffer pool byte[] m_buffer; // the underlying byte array maintained by the Buffer Manager Stack<int> m_freeIndexPool; // int m_currentIndex; int m_bufferSize; public BufferManager(int totalBytes, int bufferSize) { m_numBytes = totalBytes; m_currentIndex = 0; m_bufferSize = bufferSize; m_freeIndexPool = new Stack<int>(); } // Allocates buffer space used by the buffer pool public void InitBuffer() { // create one big large buffer and divide that // out to each SocketAsyncEventArg object m_buffer = new byte[m_numBytes]; } // Assigns a buffer from the buffer pool to the // specified SocketAsyncEventArgs object // // <returns>true if the buffer was successfully set, else false</returns> public bool SetBuffer(SocketAsyncEventArgs args) { if (m_freeIndexPool.Count > 0) { args.SetBuffer(m_buffer, m_freeIndexPool.Pop(), m_bufferSize); } else { if ((m_numBytes - m_bufferSize) < m_currentIndex) { return false; } args.SetBuffer(m_buffer, m_currentIndex, m_bufferSize); m_currentIndex += m_bufferSize; } return true; } // Removes the buffer from a SocketAsyncEventArg object. // This frees the buffer back to the buffer pool public void FreeBuffer(SocketAsyncEventArgs args) { m_freeIndexPool.Push(args.Offset); args.SetBuffer(null, 0, 0); } } </div>

SocketAsyncEventArgsPool

1

<div>using System; using System.Collections.Generic; using System.Net.Sockets; // Represents a collection of reusable SocketAsyncEventArgs objects. class SocketAsyncEventArgsPool { Stack<SocketAsyncEventArgs> m_pool; // Initializes the object pool to the specified size // // The "capacity" parameter is the maximum number of // SocketAsyncEventArgs objects the pool can hold public SocketAsyncEventArgsPool(int capacity) { m_pool = new Stack<SocketAsyncEventArgs>(capacity); } // Add a SocketAsyncEventArg instance to the pool // //The "item" parameter is the SocketAsyncEventArgs instance // to add to the pool public void Push(SocketAsyncEventArgs item) { if (item == null) { throw new ArgumentNullException("Items added to a SocketAsyncEventArgsPool cannot be null"); } lock (m_pool) { m_pool.Push(item); } } // Removes a SocketAsyncEventArgs instance from the pool // and returns the object removed from the pool public SocketAsyncEventArgs Pop() { lock (m_pool) { return m_pool.Pop(); } } // The number of SocketAsyncEventArgs instances in the pool public int Count { get { return m_pool.Count; } } }</div>

1

<div>using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; class AsyncUserToken { public Socket Socket; } </div>

Server

1

<div>using System; using System.Threading; using System.Net.Sockets; using System.Net; using System.Text; // Implements the connection logic for the socket server. // After accepting a connection, all data read from the client // is sent back to the client. The read and echo back to the client pattern // is continued until the client disconnects. class Server { private int m_numConnections; // the maximum number of connections the sample is designed to handle simultaneously private int m_receiveBufferSize;// buffer size to use for each socket I/O operation BufferManager m_bufferManager; // represents a large reusable set of buffers for all socket operations const int opsToPreAlloc = 2; // read, write (don't alloc buffer space for accepts) Socket listenSocket; // the socket used to listen for incoming connection requests // pool of reusable SocketAsyncEventArgs objects for write, read and accept socket operations SocketAsyncEventArgsPool m_readWritePool; int m_totalBytesRead; // counter of the total # bytes received by the server int m_numConnectedSockets; // the total number of clients connected to the server Semaphore m_maxNumberAcceptedClients; // Create an uninitialized server instance. // To start the server listening for connection requests // call the Init method followed by Start method // // <param name="numConnections">the maximum number of connections the sample is designed to handle simultaneously</param> // <param name="receiveBufferSize">buffer size to use for each socket I/O operation</param> public Server(int numConnections, int receiveBufferSize) { m_totalBytesRead = 0; m_numConnectedSockets = 0; m_numConnections = numConnections; m_receiveBufferSize = receiveBufferSize; // allocate buffers such that the maximum number of sockets can have one outstanding read and //write posted to the socket simultaneously m_bufferManager = new BufferManager(receiveBufferSize * numConnections * opsToPreAlloc, receiveBufferSize); m_readWritePool = new SocketAsyncEventArgsPool(numConnections); m_maxNumberAcceptedClients = new Semaphore(numConnections, numConnections); } // Initializes the server by preallocating reusable buffers and // context objects. These objects do not need to be preallocated // or reused, but it is done this way to illustrate how the API can // easily be used to create reusable objects to increase server performance. // public void Init() { // Allocates one large byte buffer which all I/O operations use a piece of. This gaurds // against memory fragmentation m_bufferManager.InitBuffer(); // preallocate pool of SocketAsyncEventArgs objects SocketAsyncEventArgs readWriteEventArg; for (int i = 0; i < m_numConnections; i++) { //Pre-allocate a set of reusable SocketAsyncEventArgs readWriteEventArg = new SocketAsyncEventArgs(); readWriteEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed); readWriteEventArg.UserToken = new AsyncUserToken(); // assign a byte buffer from the buffer pool to the SocketAsyncEventArg object m_bufferManager.SetBuffer(readWriteEventArg); // add SocketAsyncEventArg to the pool m_readWritePool.Push(readWriteEventArg); } } // Starts the server such that it is listening for // incoming connection requests. // // <param name="localEndPoint">The endpoint which the server will listening // for connection requests on</param> public void Start(IPEndPoint localEndPoint) { // create the socket which listens for incoming connections listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); listenSocket.Bind(localEndPoint); // start the server with a listen backlog of 100 connections listenSocket.Listen(100); // post accepts on the listening socket StartAccept(null); //Console.WriteLine("{0} connected sockets with one outstanding receive posted to each....press any key", m_outstandingReadCount); Console.WriteLine("Press any key to terminate the server process...."); Console.ReadKey(); } // Begins an operation to accept a connection request from the client // // <param name="acceptEventArg">The context object to use when issuing // the accept operation on the server's listening socket</param> public void StartAccept(SocketAsyncEventArgs acceptEventArg) { if (acceptEventArg == null) { acceptEventArg = new SocketAsyncEventArgs(); acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed); } else { // socket must be cleared since the context object is being reused acceptEventArg.AcceptSocket = null; } m_maxNumberAcceptedClients.WaitOne(); bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg); if (!willRaiseEvent) { ProcessAccept(acceptEventArg); } } // This method is the callback method associated with Socket.AcceptAsync // operations and is invoked when an accept operation is complete // void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e) { ProcessAccept(e); } private void ProcessAccept(SocketAsyncEventArgs e) { Interlocked.Increment(ref m_numConnectedSockets); Console.WriteLine("Client connection accepted. There are {0} clients connected to the server", m_numConnectedSockets); // Get the socket for the accepted client connection and put it into the //ReadEventArg object user token SocketAsyncEventArgs readEventArgs = m_readWritePool.Pop(); ((AsyncUserToken)readEventArgs.UserToken).Socket = e.AcceptSocket; // As soon as the client is connected, post a receive to the connection bool willRaiseEvent = e.AcceptSocket.ReceiveAsync(readEventArgs); if (!willRaiseEvent) { ProcessReceive(readEventArgs); } // Accept the next connection request StartAccept(e); } // This method is called whenever a receive or send operation is completed on a socket // // <param name="e">SocketAsyncEventArg associated with the completed receive operation</param> void IO_Completed(object sender, SocketAsyncEventArgs e) { // determine which type of operation just completed and call the associated handler switch (e.LastOperation) { case SocketAsyncOperation.Receive: ProcessReceive(e); break; case SocketAsyncOperation.Send: ProcessSend(e); break; default: throw new ArgumentException("The last operation completed on the socket was not a receive or send"); } } // This method is invoked when an asynchronous receive operation completes. // If the remote host closed the connection, then the socket is closed. // If data was received then the data is echoed back to the client. // private void ProcessReceive(SocketAsyncEventArgs e) { // check if the remote host closed the connection AsyncUserToken token = (AsyncUserToken)e.UserToken; if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success) { //increment the count of the total bytes receive by the server Interlocked.Add(ref m_totalBytesRead, e.BytesTransferred); Console.WriteLine("The server has read a total of {0} bytes", m_totalBytesRead); Int32 BytesToProcess = e.BytesTransferred; Byte[] bt = new Byte[BytesToProcess]; Buffer.BlockCopy(e.Buffer, e.Offset, bt, 0, BytesToProcess); string strReceive = Encoding.Default.GetString(bt); Send(token.Socket, bt, 0, bt.Length, 1000); Thread.Sleep(1000); //echo the data received back to the client //e.SetBuffer(e.Offset, e.BytesTransferred); bool willRaiseEvent = token.Socket.SendAsync(e); if (!willRaiseEvent) { ProcessSend(e); } } else { CloseClientSocket(e); } } public static void Send(Socket socket, byte[] buffer, int offset, int size, int timeout) { socket.SendTimeout = 0; int startTickCount = Environment.TickCount; int sent = 0; // how many bytes is already sent do { if (Environment.TickCount > startTickCount + timeout) //throw new Exception("Timeout."); try { sent += socket.Send(buffer, offset + sent, size - sent, SocketFlags.None); } catch (SocketException ex) { if (ex.SocketErrorCode == SocketError.WouldBlock || ex.SocketErrorCode == SocketError.IOPending || ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable) { // socket buffer is probably full, wait and try again Thread.Sleep(30); } else throw ex; // any serious error occurr } } while (sent < size); } // This method is invoked when an asynchronous send operation completes. // The method issues another receive on the socket to read any additional // data sent from the client // // <param name="e"></param> private void ProcessSend(SocketAsyncEventArgs e) { if (e.SocketError == SocketError.Success) { //e.SetBuffer(e.Offset, 10); // done echoing data back to the client AsyncUserToken token = (AsyncUserToken)e.UserToken; // read the next block of data send from the client bool willRaiseEvent = token.Socket.ReceiveAsync(e); if (!willRaiseEvent) { ProcessReceive(e); } } else { CloseClientSocket(e); } } private void CloseClientSocket(SocketAsyncEventArgs e) { AsyncUserToken token = e.UserToken as AsyncUserToken; // close the socket associated with the client try { token.Socket.Shutdown(SocketShutdown.Send); } // throws if client process has already closed catch (Exception) { } token.Socket.Close(); // decrement the counter keeping track of the total number of clients connected to the server Interlocked.Decrement(ref m_numConnectedSockets); m_maxNumberAcceptedClients.Release(); Console.WriteLine("A client has been disconnected from the server. There are {0} clients connected to the server", m_numConnectedSockets); // Free the SocketAsyncEventArg so they can be reused by another client m_readWritePool.Push(e); } }</div>

Program

1

<div>using System; using System.Net; using System.Collections.Generic; using System.IO; class Program { static void Main(string[] args) { IPEndPoint iep = new IPEndPoint(IPAddress.Parse("10.1.20.6"), 1333); Server objServer = new Server(1000, 10); objServer.Init(); objServer.Start(iep); } } </div>

http://www.cnblogs.com/tianzhiliang/archive/2010/09/08/1821623.html

龙生 21 Apr 2012

View Details

C#的Socket程序（TCP）

其实只要用到Socket联接，基本上就得使用Thread，是交叉使用的。C#封装的Socket用法基本上不算很复杂，只是不知道托管之后的Socket有没有其他性能或者安全上的问题。在C#里面能找到的最底层的操作也就是socket了，概念不做解释。程序模型如下：WinForm程序：启动端口侦听；监视Socket联接情况；定期关闭不活动的联接；Listener：处理Socket的Accept函数，侦听新链接，建立新Thread来处理这些联接（Connection）。Connection：处理具体的每一个联接的会话。 1：WinForm如何启动一个新的线程来启动Listener：//start the serverprivate void btn_startServer_Click(object sender, EventArgs e){//this.btn_startServer.Enabled = false;Thread _createServer = new Thread(new ThreadStart(WaitForConnect));_createServer.Start();}//wait all connectionsprivate void WaitForConnect(){SocketListener listener = new SocketListener(Convert.ToInt32(this.txt_port.Text));listener.StartListening();}因为侦听联接是一个循环等待的函数，所以不可能在WinForm的线程里面直接执行，不然Winform也就是无法继续任何操作了，所以才指定一个新的线程来执行这个函数，启动侦听循环。这一个新的线程是比较简单的，基本上没有启动的参数，直接指定处理函数就可以了。2：Listener如何启动循环侦听，并且启动新的带有参数的线程来处理Socket联接会话。先看如何建立侦听：（StartListening函数）IPEndPoint localEndPoint = new IPEndPoint(_ipAddress, _port);// Create a TCP/IP socket. Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);// Bind the socket to the local endpoint and listen for incoming connections. try{listener.Bind(localEndPoint);listener.Listen(20);//20 trucks // Start listening for connections. while (true){// here will be suspended while waiting for a new connection. Socket connection = listener.Accept();Logger.Log("Connect", connection.RemoteEndPoint.ToString());//log it, new connection……}}……基本步骤比较简单：建立本机的IPEndPoint对象，表示以本机为服务器，在指定端口侦听；然后绑定到一个侦听Socket上；进入while循环，等待新的联接；如果有新的联接，那么建立新的socket来对应这个联接的会话。值得注意的就是这一句联接代码：listener.Accept()。执行这一句的时候，程序就在这个地方等待，直到有新的联检请求的时候程序才会执行下一句。这是同步执行，当然也可以异步执行。新的联接Socket建立了（Accept之后），对于这些新的socket该怎么办呢？他们依然是一个循环等待，所以依然需要建立新的Thread给这些Socket去处理会话（接收/发送消息），而这个Thread就要接收参数了。Thread本身是不能接收参数的，为了让它可以接收参数，可以采用定义新类，添加参数作为属性的方法来解决。因为每一个Socket是一个Connection周期，所以我定义了这么一个类public class Connection。这个类至少有这样一个构造函数public Connection(Socket socket); 之所以这么做，就是为了把Socket参数传给这个Connection对象，然后好让Listener启动这个Thread的时候，Thread可以知道他正在处理哪一个Socket。具体处理的方法：（在Listener的StartListening函数，ocket connection […]

龙生 21 Apr 2012

View Details

TCP与UDP区别

TCP与UDP区别 TCP—传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。 UDP—用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快 Overview TCP (Transmission Control Protocol) is the most commonly used protocol on the Internet. The reason for this is because TCP offers error correction. When the TCP protocol is used there is a "guaranteed delivery." This is due largely in part to a method called "flow control." Flow control determines when data needs to be re-sent, and stops the flow of data until previous packets are successfully transferred. This works because if a packet of data is sent, a collision may occur. When this […]

龙生 21 Apr 2012

View Details

Win2003 iis6.0网站服务器性能优化指南

Windows Server自带的互联网信息服务器IIS是架设网站服务器的常用工具，它是一个既简单而又麻烦的东西，新手都可以使用IIS架设一个像模像样的Web站点来，但配置、优化IIS的性能，使得网站访问性能达到最优状态却不是一件简单的事情，这里我就介绍一下如何一步一步的优化你的IIS服务器。　　服务器端环境，我们以Windows Server 2003的IIS6.0为例，客户端环境为Mozilla Firefox 3.0，同时安装Yahoo的YSlow扩展。　　YSlow是Yahoo开发者团队发布的一款基于Firebug的插件。用于分析网页，并根据一些高性能网站的规则进行相应的评级打分，对于网页性能优化有很好的帮助作用，告诉你那些部分影响了你的网页速度，并告诉你如何基于某些规则而进行优化。我们对于IIS的优化策略就是基于YSlow的。　　使用安装了YSlow的Firefox打开目标网站，然后点击YSlow图标，点击Performance，如下图所示。　　其中Performance Grade为YSlow对你网站的评级，A（100分）为最高，F为最低，后面列出如何进行修改，下面我以IIS 6.0为例介绍一下如何进行优化网站性能。　　1、减少HTTP请求数量　　这主要是修改网站代码，减少外部图片、CSS、JS等文件数量，手动合并多个CSS/JavaScript文件。IIS那里不用设置。　　2、使用CDN 　　对于小网站来说，这个就免了吧。当然有钱人可以试试，可以从技术上解决用户访问网站响应速度慢的问题。　　3、启用内容过期　　对于静态文件启用内容过期可以提高访问性能。首先网站的目录要划分合理，图片、CSS、JavaScript均放在单独目录下，然后在IIS中选择目录，点属性-HTTP头，启用内容过期，可以选择30天后过去，这样，用户浏览器将比较当前日期和截止日期，以便决定是显示缓存页还是从服务器请求更新的页，由于图片、CSS、JS通常变化较少，因此基本上都从本地缓存读取，从而加快显示速度。　　4、启用Gzip压缩　　HTTP压缩是在Web服务器和浏览器间传输压缩文本内容的方法。HTTP压缩采用通用的压缩算法如Gzip等压缩HTML、JavaScript或 CSS文件。压缩的最大好处就是降低了网络传输的数据量，从而提高客户端浏览器的访问速度。　　使用方法是，右击“网站”->“属性”，选择“服务”。在“HTTP压缩”框中选中“压缩静态文件”，“临时目录”建议单独设置另一个盘的目录下。　　之后，IIS管理器中，右击“Web服务扩展”->“增加一个新的Web服务扩展”，在“扩展名”中输入“HTTPCompression”，添加“要求的文件”为C:\WINDOWS\system32\inetsrv\gzip.dll，其中Windows系统目录根据您的安装可能有所不同，选中“设置扩展状态为允许”。　　最后，使用文本编辑器打开C:\Windows\System32\inetsrv\MetaBase.xml，在HcFileExtensions中增加需要压缩的静态文件后缀名，默认为HTML和TXT文件，建议再添加上js、css等，不要添加图片或ZIP等已经被压缩的文件。　　5、将样式文件放在头部　　这是基本的HTML代码风格，将所有的CSS文件都放在HTML页面的头部。　　6、将脚本文件放在尾部　　这也是基本的HTML代码风格，将所有的JavaScript文件都放在HTML页面的尾部。　　7、避免CSS表达式　　这点很简单，因为大多数人从来不用CSS表达式。　　8、使用外部的JavaScript和CSS 　　将所有的JavaScript和CSS都做成外部文件的形式进行引用，这主要是为了让这些文件可以被浏览器缓存起来，参见第三点的介绍。　　9、减少DNS查询　　域名的DNS查询会带来额外的访问开销，减少页面内文件的主机域名数量，一个页面的主机域名保持在2-4个以内，这样就不会降低页面的装入速度。　　10、压缩JavaScript文件　　压缩脚本文件，删除不必要的字符，可以改善加载时间，目前有很多JavaScript文件的压缩工具，我这里有一个GUI界面的JS压缩工具供下载。　　11、避免重定向　　网页的重定向会带来额外的运行开销，因此要避免页面进行重定向跳转操作。　　12、删除重复脚本　　一个页面两次包含同一个JavaScript文件会影响加载的性能，因此需要将重复的脚本文件删除。　　13、配置ETag 　　这是一个令人迷惑的问题。理论上说将服务器的ETag删除会提高HTTP请求的性能，但是按照微软官方提供的修改方法配置IIS 6.0，并没有实际效果，最终我使用了一个第三方的DLL文件，以ISAPI的方式实现了删除ETag的功能。　　经过上面这些网站前端重构和WEB服务器的配置修改，我们的页面结构就变得更加规范，重构的页面大多都会取得不错的YSlow的评分，总体来说性能提升了不少。对于最终用户来说，也会明显感受到访问网站速度变快了很多，网站的浏览体验得到了较好的提升。 from http://www.w-link.org.cn/post/46.html

龙生 20 Apr 2012

View Details

Win2003 IIS6.0性能优化指南

　　1、禁止多余的Web服务扩展　　IIS6.0支持多种服务扩展，有些管理员偷懒或者不求甚解，担心Web运行中出现解析错误，索性在建站时开启了所有的Web服务扩展。殊不知，这其中的有些扩展比如“所有未知CGI扩展”、“在服务器端的包含文件”等是Web运行中根本用不到的，况且还占用IIS资源影响性能拖垮Web，甚至某些扩展存在漏洞容易被攻击者利用。因此，科学的原则是，用到什么扩展就启用什么扩展。　　如果企业站点是静态页面，那什么扩展都不要开启。不过现在的企业站点都是交互的动态页面比如asp、php、jsp等。如果是asp页面，那只需开启“Active Server Pages”即可。对于php、jsp等动态页面IIS6.0默认是不支持的需要进行安装相应组件实现对这些扩展的支持。不过，此时用不到的扩展完全可以禁用。　　禁止Web服务扩展的操作非常简单，打开“IIS管理器”，在左窗格中点击“Web服务扩展”，在右侧选择相应的扩展，然后点击“禁用”即可。(图1) 2、删除不必要的IIS扩展名映射　　IIS默认支持.asp、.cdx等8种扩展名的映射，这其中除了.asp之外其他的扩展几乎用不到。这些用不着的扩展会加重web服务器的负担，而且带来一定的安全隐患。比如.asa，.cer等扩展名，就可以被攻击者利用来获得webshell。因为一般的asp系统都会限制asp文件的上传，但如果没有限制.asa或者.cer等扩展名，攻击者就可以更改文件后缀突破上传限制，运行.asa或者.cer的文件获得webshell。(图 2) 删除IIS扩展名的操作是：打开IIS管理器，右键单击“默认Web站点”选择“属性”，点击“主目录”选项卡，然后点击“配置”打开应用程序窗口，最后根据自己的需要选择不必要的应用程序映射比如.shtml, .shtm, .stm等，然后点击“删除”即可。(图3) 3、取消访问记录　　IIS6.0默认开启对于web的访问记录。当开启记录功能后，IIS会事无巨细地忠实记录所有的web访问记录。这些记录文件的内容是非常庞杂的，比如访问时间、客户端IP、从哪个链接访问、 Cookies等，另外还包括 Method(方法), UserAgent(用户代理)等。这些记录不但占用大量的磁盘空间还大大地影响了web服务器的性能。有人做过评测，停止访问记录可以提升5%到8%的 web性能。而且这些记录对于一般用户，特别是中小型的Web站点没有什么用途，简直太耗费系统性能了，因此建议关闭它。　　取消访问记录的操作是：打开IIS管理器，定位到具体的web站点，右键点击选择“属性”，在“主目录”选项卡下取消对“记录访问”的勾选即可。(图4) 4、对访问流量进行限制　　默认情况下IIS 6.0对于访问量是没有限制的，如果并发连接过大超过了Web的负载轻则发生网络拥塞，重则导致服务器宕机。因此需要对用户的访问进行限制，控制Web访问的流量。　　打开“Internet信息服务”管理器，在其窗口右侧点击主机名前面的“+”号，依次定位到某个Web站点上。选中该Web站点右键单击选择 “属性”，在打开的属性设置窗口中选中“性能”标签，将“启用带宽限制”复选框选中，在随后被激活的“最大网络使用”设置框中，指定你的网络站点带宽的具体数值。大家可以根据服务器的性能及其访问量综合考虑继续设置。对于一般的企业站点将带宽流量设置为1500kb/s就差不多了。同时在“网站连接”下可以进行连接限制的设置，大家可以根据情况设置一个数值。完成以上设置后，IIS就只能使用其被授予的资源进行Web服务，杜绝了异常情况造成的服务器过载，为Web减负。(图5) 5、让Web负载自由伸缩　　默认情况下IIS是全负荷地为Web提供服务的，这在一定程度上加重了Web负担。如何能够自动地根据负载变化自动调节工作进程呢? 　　利用IIS 6.0的Web园，我们只需指定用于某个应用程序池的工作进程的数量就可以了实现各个Web站点之间的隔离。具体的配置步骤是：在“Internet信息服务”管理器中打开应用程序池的“属性”对话框，转到“性能”页，在“Web园”下面的“最大工作进程数”输入框中输入进程数量。当服务器的负载较小，不需要额外的工作进程时，IIS 6.0在一定的时间后(默认20分钟，可配置)自动缩减实际的工作进程数量;如果负载变大，需要额外的工作进程，IIS 6.0再次增加工作进程数量。另外，还可以“启用CUP监视”，设置“最大CPU使用率”，“刷新CUP使用率值”以及“CPU使用率超过最大使用率是执行的操作”，这些设置可以根据需要进行设置。当一切设置完成后这一切就交给IIS自动进行，不需要管理员干预。 (图6) 6、配置应用呈现池　　IIS可以支持多个Web服务，特别是虚拟主机一台服务器上有非常多的Web站点。如何才能做到各个站点之间相互独立，不因某些Web站点出现故障而影响其他站点呢?为不同工作进程指定应用程序池是个很好的解决办法。　　(1)、创建　　打开“IIS 管理器”中，展开本地计算机，右键单击“应用程序池”，选择“新建→应用程序池”。在“应用程序池名称”框中，输入新的应用程序池名称。如果点选选“将现有应用程序池作为模板”，可以在“应用程序池名称”下来列表中选择相应的应用程序池，最后单击“确定”即可。 (图7) (2)、指派　　在“IIS 管理器中”，右键单击你要为其指派应用程序池的站点然后单击“属性”。在该站点的属性面板中“主目录”选项卡，在“应用程序池”下拉列表中选择刚才创建的应用程序池即可。如果所有的选项为灰色，单击“创建”按钮就可以输入“应用程序名”，然后在“应用程序池”列表框中，选择并指派网站的应用程序池了。(图 8) (3)、回收　　利用“回收”功能，可是设置如何恢复系统资源进行IIS资源使用的灵活定制。打开“IIS 管理控制台”，单击“+”号依次“展开本地计算机→应用程序池”。选择你要回收的应用程序池右键单击选择“属性”，出现应用程序池的属性对话框，单击“回收”选项卡在其下可以设置“进程回收”、“内存回收”等，所有这些设置大家根据实际需要进行设置。(图9) 总结：通过上述IIS优化措施，Web服务器就能轻装上阵其性能将会有较大的提升。当然，要从根本上改善Web性能，仅仅进行软设置是不够的。另外，还需要进行硬件改造，软硬结合才是最完美的解决方案。管理互联网信息服务器（Internet Information Server，IIS）大家都知道，它是一个既简单而又麻烦的东西，简单的是安装它几乎不需要费什么脑筋，选择一下路径，然后一路按“下一步”就可以完成；配置也比较简单，只要有一定的NT和网络知识，照着说明书就可以架设一个像模像样的Web站点出来。然而管理IIS却没有想像的那样简单。使用一段时间以后，管理员往往会遇上服务器性能不良的情况。这时候，IIS的性能优化，就尤为重要了。　　导致IIS服务性能不良的原因有两个方面。一个是人为的，也就是说管理员在安装、配置IIS的时候没有进行优化或者配置错误。另一个则是客观上的，随着运行的服务种类，以及访问人数的增加，服务器原有的硬件配置已不能满足要求了，这就需要提高硬件配置。　　在服务器配置上优化IIS性能　　1.IIS高速缓存是对IIS进行优化时要考虑的最重要的项目之一。服务器保留了一部分内存空间用作IIS高速缓存，为将来的请求存储对象，这样IIS就可从高速缓存中检索对象而不用从硬盘中检索。　　调整IIS高速缓存的容量需要修改注册表，表项如下：　　\HKEY_LOCAL_MACHINE 　　\System 　　\CurrentControlSet 　　\Services 　　\InetInfo 　　\Parameters 　　\MemoryCacheSize 　　MemoryCacheSize的范围是从0道4GB，缺省值为3072000（3MB）。　　IIS通过高速缓存系统句柄、目录列表以及其他常用数据的值来提高系统的性能。这个参数指明了分配给高速缓存的内存大小。如果该值为0，那就意味着 “不进行任何高速缓存”。在这种情况下系统的性能可能会降低。如果你的服务器网络通讯繁忙，并且有足够的内存空间，可以考虑增大该值。必须注意的是修改注册表后，需要重新启动才能使新值生效。　　2.使IIS使用处理器时间最长。服务器的CPU处理器能力总是有限的。哪一个应用程序占用处理器的时间最长，谁的性能就能得到最大的提高。　　（1）在NT的控制面板中，双击系统图标。　　（2）单击性能标签。　　（3）在应用程序性能下将游标拖到None的位置，这样就可以使所有正在运行的服务，包括IIS，使用处理器的时间达到最大值。　　3．服务器属性设置。在服务器属性里有一项可以使网络应用程序的总处理能力最大的选项，你当然应该选择它。　　(1)在桌面上右键单击网络邻居图标，然后选择属性选项。　　(2)单击“服务标签”。　　(3)单击“服务器”，然后按“属性”。　　(4)选择最大化网络应用程序的总处理能力。然后单击“OK。” 　　提高硬件配置来优化IIS性能 […]

龙生 20 Apr 2012

View Details

可恶的毒胶囊，我也吃了不少

红色的是我吃过了的……大爷的~

龙生 20 Apr 2012

View Details

LINQ&EF任我行（二）--LinQ to Object (转)

LinQ to Objects是LinQ家庭的核心，其它的LinQ也使用了与LinQ to Objects相同的查询句法。最终编译器都是把LinQ句法翻译成扩展方法的链式表达式，同时把扩展方法中的lambda表达式转换成匿名类中的匿名方法，然后再把查询表达式编译成MSIL。 LinQ to SQL、LinQ to DataSets、LinQ to Entities和LinQ to XML则不是把查询表达式转换成MSIL，而是把查询表达式树转换成相应的特定查询语言。LinQ to SQL会生成T-SQL，LinQ to Entities会生成eSQL，LinQ to XML会生成XPath语句等。 LinQ标准查询操作符列表《图1》在VS2008及以后的版本中提供了LinQ的查询样例程序。 \Programe Files\Microsoft Visual Studio 2008(10.0 VS2010)\Samples\1033文件夹下有个压缩包CSharpSamples.zip，解压它，继续打开其中的文件夹 .\LinqSamples\SampleQueries\SampleQueries.sln，打开此解决方案，运行该项目，界面如下《图2》在左边选择示例，右侧上方会出现相应的LinQ代码，右侧下方会出现代码的运行结果。通过这个样例程序，我们可以学习LinQ的各种用法。下面我们来学习LinQ常用操作符一、筛选操作符Where 根据谓词对源序列的内容进行筛选，类似于SQL中的where子句。 1.简单where表达式使用扩展方法 var query1 = CustomerList.Where(c => c.Country == “USA”); 使用查询表达式语法 query1 = from c in CustomerList where c.Country == “USA” select c; 使用扩展方法需要向where方法中传入lambda表达式。 2.复合where表达式所谓的复合where表达式就是使用&&或||操作符对数据进行筛选使用扩展方法 var query2 = CustomerList.Where(c => c.Country == “USA” && c.Orders.Any()); 使用查询表达式语法 query2 = from c in CustomerList where c.Country == “USA” […]

龙生 18 Apr 2012

View Details

November 2024
M	T	W	T	F	S	S
« Oct
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30