C# | LongSheng | Page 39

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

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

Page.ClientScript.RegisterStartupScript 与 Page.ClientScript.RegisterClientScriptBlock 之间的区别

Page.ClientScript.RegisterStartupScript 与 Page.ClientScript.RegisterClientScriptBlock 被用来注册脚本块。第一个是 RegisterStartupScript 方法。当您有一个想要在页面加载时启动的 JavaScript 函数时，最好使用该类。就此列举一例，在 Visual Studio 2005 中创建一个包含两个按钮的 ASP.NET 页面。Button1 和 Button2 分别为这两个按钮的 ID。然后，在 Page_Load 事件内部嵌入以下代码 C#：

1	Page.ClientScript.RegisterStartupScript(this.GetType(), "MyScript", "function AlertHello() { alert('你好，ASP.NET'); }", true);

1	Button1.Attributes["onclick"] = "AlertHello()";Button2.Attributes["onclick"] = "AlertHello()";

RegisterStartupScript 方法的两个可能结构如下： • RegisterStartupScript (type, key, script) • RegisterStartupScript (type, key, script, script tag specification) 在上例中，您指定了类型 Me.GetType()、关键字及包含的脚本，然后是一个值为 True 的布尔值（以便 .NET 自动使用 <script> 标记将脚本嵌入 ASP.NET 页面中）。Page.ClientScript.RegisterStartupScript 与 Page.ClientScript.RegisterClientScriptBlock 之间的区别主要区别在于:RegisterStartupScript 方法是将 JavaScript 嵌入到 ASP.NET 页面的底部，恰好位于关闭元素 </form> 的前面。RegisterClientScriptBlock方法是将 JavaScript 嵌入到页面中开启元素 <form> 的紧后面。那么，这有何不同呢？正如我们将要看到的，这有很大的不同。就此列举一例，以下是在页面加载到浏览器时，将焦点置于该页面上的一个文本框中的方法 – 使用利用了 RegisterStartupScript 方法：

1	Page.ClientScript.RegisterStartupScript(this.GetType(), "Testing", "document.forms[0]['<strong style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; ">txtText</strong>'].focus();", True)

由于在浏览器运行到页面底部并执行此小段 JavaScript 时，就已生成了页面上的文本框，并已将其放到了页面中，因此，此方法运行正常。但是，如果不按照上述方法，而编写如下代码（使用 RegisterClientScriptBlock 方法）：

1	Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "Testing", "document.forms[0]['<strong style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; ">txtText'</strong>].focus();", True)

文本框控件将不会获得焦点，且会在页面上生成一个 JavaScript 错误（如图 1 所示）。图 1. 执行 JavaScript 时出错出错的原因在于，浏览器将先遇到 JavaScript，而后文本框才会出现在页面中。因此，JavaScript 将无法找到 txtText。原文出处：http://blog.csdn.net/jiahello/archive/2009/06/29/4305855.aspx

龙生 29 Mar 2012

View Details

c#中const与readonly区别

const 的概念就是一个包含不能修改的值的变量。

1

常数表达式是在编译时可被完全计算的表达式。因此不能从一个变量中提取的值来初始化常量。如果 const int a = b+1;b是一个变量，显然不能再编译时就计算出结果，所以常量是不可以用变量来初始化的。 readonly 允许把一个字段设置成常量，但可以执行一些运算，可以确定它的初始值。因为 readonly 是在计算时执行的，当然它可以用某些变量初始化。readonly 是实例成员，所以不同的实例可以有不同的常量值，这使readonly更灵活。readonly 关键字与 const 关键字不同。1. const 字段只能在该字段的声明中初始化。 readonly 字段可以在声明或构造函数中初始化。因此，根据所使用的构造函数，readonly 字段可能具有不同的值。2. const 字段是编译时常数，而 readonly 字段可用于运行时常数。3. const 默认就是静态的，而 readonly 如果设置成静态的就必须显示声明。4．const 对于引用类型的常数，可能的值只能是 string 和 null。 readonly可以是任何类型总结const只能在初期就使用常量初始化好。对于每一次编译后的结果，const的值是固定的，而readonly的值是可以在运行的时候才确定值的~~FROM URL:<a href="http://zhidao.baidu.com/question/286719961.html">http://zhidao.baidu.com/question/286719961.html</a>

龙生 29 Mar 2012

View Details

C#数据类型

C#的数据类型可以分为3类:数值类型,引用类型,指针类型.指针类型仅在不安全代码中使用. 值类型包括简单类型(如字符型,浮点型和整数型等),集合类型和结构型.引用类型包括类类型,接口类型,代表类型和数组类型.值类型和引用类型的不同之处是值类型的变量值直接包含数据,而引用类型的变量把它们的引用存储在对象中.对于引用类型的变量,完全有可能让两个不同的变量引用同一个对象,这样一来,对其中一个变量的操作就会影响到被另一个变量引用的对象.对于值类型的变量而言,每一个变量有它们自己的数值,因此对其中一个变量的操作不可能影响到另外一个变量.值类型所有的值类型都隐含地声明了一个公共的无参数的构造函数,这个构造函数叫做默认构造函数.默认构造函数返回一个初始为零的值类型的实例,称之为默认值.对于sbyte,byte,short,ushort,int,uint,long,ulong,默认值为0. 对于char,默认值是’"x0000′对于float,默认值是0.0F对于double,默认值是0.0D对于decimal,默认值是0.0M对于bool,默认值是false对于一个枚举类型,默认值是0对于一个结构类型,默认值的设置就是把所有值类型的域都设置为它们各自的默认值,把所有的引用类型的域赋为空简单类型C#提供一套预定义的结构类型叫做简单类型.简单类型用保留字定义,这些保留字仅仅是在System名字空间里预定义的结构类型的化名.比如int是保留字,System.Int32是在System名字空间中预定义类型.一个简单类型和它化名的结构类型是完全一样的,也就是说写int和写System.Int32是一样的.简单类型主要有整型,浮点类型,小数类型,布尔类型,字符型整型C#中支持9种整型:sbyte,byte,short,ushort,int,uint,long,ulong和char.Sbyte:代表有符号的8位整数,数值范围从-128 ～ 127Byte:代表无符号的8位整数,数值范围从0～255Short:代表有符号的16位整数,范围从-32768 ～ 32767ushort:代表有符号的16位整数,范围从-32768 ～ 32767Int:代表有符号的32位整数,范围从-2147483648 ～ 2147483648 uint:代表无符号的32位整数,范围从0 ～ 4294967295Long:代表有符号的64位整数,范围从-9223372036854775808 ～ 9223372036854775808 Ulong:代表无符号的64位整数,范围从0 ～ 18446744073709551615.char:代表无符号的16位整数,数值范围从0～65535.Char类型的可能值对应于统一字符编码标准(Unicode)的字符集.Char类型与其他整数类型相比有以下两点不同之处:1,没有其他类型到char类型的隐式转换.即使是对于sbyte,byte和ushort这样能完全使用char类型代表其值的类型, sbyte,byte和ushort到char的隐式转换也不存在.2,char类型的常量必须被写为字符形式,如果用整数形式,则必须带有类型转换前缀.比如(char)10赋值形式有三种:char chsomechar="A";char chsomechar=""x0065"; 十六进制char chsomechar=""u0065 ; unicode表示法字符型中有下列转义符:1,"’用来表示单引号2,""用来表示双引号3,"" 用来表示反斜杠4, "0 表示空字符5, "a 用来表示感叹号6, "b 用来表示退格7, "f 用来表示换页8, "n 用来表示换行9, "r 用来表示回车10, "t 用来表示水平tab11, "v 用来表示垂直tab浮点类型C#支持两种浮点类型:float和double.Float型所能表示的值的范围大约可以从1.5*10 -45～3.4* 10 38,精确到小数点后面7位.Double型所能表示的值的范围大约可以从5.0*10 -324～1.7* 10 308,精确到小数点后面15位或16位.如果二元操作中的其中一个操作数为浮点类型,那么另外一个操作数是整型或浮点类型,运算规则如下:1,如果其中一个操作数是整型,则操作数被转换为另一个操作数的浮点数类型;2,如果操作数之一为double,则另一操作数也被转换成double类型,运算以double类型的精度和取值范围进行,并且所得结果也为double类型;3,否则,运算至少将以float类型的取值范围和精度进行,并且所得结果也为float型.小数(decimal)类型小数类型非常适用于金融和货币运算.数值范围从1.0*10 -28～7.9* 10 28,精确到小数点后面28位.如果二元操作中的其中一个操作数是小数类型,那么另外一个从操作数是整型或小数类型.整型在运算前被转化为小数类型数.如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太小的值,操作的结果将会变成0.如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太大的值,就会触发溢出错误.小数类型较浮点类型而言,具有更大的精确度,但是数值范围相对小了很多.将浮点类型的数向小数类型的数转化时会产生溢出错误,将小数类型的数向浮点类型的数转化时会造成精确度的损失.因此,两种类型不存在隐式或显式转换.布尔型:值为true或false.没有标准能实现布尔类型和其他类型的转换.枚举类型:枚举类型的元素使用的类型只能是long,int,short,byte.默认类型是int.默认第一个元素的值是0,每一个连续的元素按1递增.可以给元素直接赋值.如:enum monthnames {January=1,February, march=31};可以强制定义其他类型,如:enum monthnames : byte{January ,February,March};结构类型结构类型也是一种值类型,使用它的目的是用于创建小型的对象,用以节省内存.下面的例子表示一个使用byte类型的4个字段的IP地址.using System;Struct IP //声明结构{ public byte b1,b2,b3,b4;}Class test{public static void Main(){IP myIP;myIP.b1=192;myIP.b2=168;myIP.b3=1;myIP.b4=101;Console.Write("{0}.{1}.", myIP.b1, myIP.b2);Console.Write("{0}.{1}", myIP.b3, myIP.b4);}}引用类型引用类型包括类类型,接口类型,代表类型和数组类型.1,类类型类类型定义了一种数据结构,这个数据结构中包含了数据成员(如常量,字段和事件等),函数成员(如方法,属性,索引,操作,构造函数和析构函数等)和嵌套类型.支持继承.2,对象类型对象类型是其他所有类型最终的基础类型.在C#中每一种类型都直接或者间接的源于object这个类类型.3,字符串类型字符串类型是直接从object中继承而来的密封类.String类型的值可以写成字符串文字的形式.4,接口类型一个接口声明一个只有抽象成员的引用类型,接口仅仅存在方法标志,但没有执行代码.当定义一个类时,如果类从接口派生,可以派生自多重接口;但是如果类从类派生,就只能从一个类派生.声明方法如例:interface iface{void showmyface();}5,代表类型代表引用一种静态的方法或者对象实例,引用该对象的实例方法.与其接近的是c/c++中的指针,但指针只能访问静态的函数,代表既能访问静态的方法,也能访问实例的方法.6,数组数组是包含一串变量的数据结构.数组变量也称做数组元素,它们具有相同的类型,这种类型也称做数组元素类型.数组的元素类型可以是任何类型,包括数组类型.数组用下标确定每一个数组元素的索引号.只有一个下标的数组称为一维数组,多于一个下标的数组称为多维数组.例:int[] a={0,2,4,6,8}; 等价于int[] a=new int[] {0,2,4,6,8};也可以这样初始化:a[0]=0; a[1]=2; a[2]=4; a[3]=6; a[4]=8;int[] a; //int型的一维数组int[,] […]

龙生 07 Mar 2012

View Details

C#列表所有IIS站点以及相关站点属性

using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Windows.Forms.Design; using System.DirectoryServices; using System.Reflection; using System.Text.RegularExpressions; int TotalServerCount=0; DirectoryEntry rootfolder = new DirectoryEntry("IIS://localhost/W3SVC"); //TotalServerCount=rootfolder.Children.SchemaFilter.Count; foreach (DirectoryEntry child in rootfolder.Children) { if (child.SchemaClassName == "IIsWebServer") { TotalServerCount+=1; } } //循环获取所有站点详细属性写入数组中 string [] arrayServerID = new string[TotalServerCount];//站点标识符 string [] arrayServerIP = new string[TotalServerCount];//站点主机头 string [] arrayServerPort = new string[TotalServerCount];//站点主机头 string [] arrayServerHeader = new string[TotalServerCount];//站点主机头 string [] arrayServerPath = new string[TotalServerCount];//站点主机头 string [] arrayServerComment = new string[TotalServerCount];//站点主机头 string [] arrayServerBinds = new string[TotalServerCount];//站点主机头 string currentServerBindings;//绑定主机头IP端口字符串 char[] a=":".ToCharArray(); string […]

龙生 12 Feb 2012

View Details

c#读取IIS中的站点相关属性代码

private void comboBox1_SelectedIndexChanged(object sender, System.EventArgs e) { string currentServerComment=comboBox1.SelectedItem.ToString(); string currentSiteNum = GetWebSiteNum(currentServerComment); string rootPath = "IIS://localhost/w3svc"; string currentSitePath =rootPath+"/"+currentSiteNum; DirectoryEntry siteEntry = new DirectoryEntry(currentSitePath); string currentServerBindings=siteEntry.Properties["ServerBindings"].Value.ToString(); char[] a=":".ToCharArray(); string [] currentBingdings = null; currentBingdings=currentServerBindings.Split(a); string currentServerIP=currentBingdings[0]; string currentServerPort=currentBingdings[1]; string currentServerHeader=currentBingdings[2]; string currentServerHost=""; string currentServerPath=""; foreach (DirectoryEntry child in siteEntry.Children) { if((child.SchemaClassName == "IIsWebVirtualDir")&&(child.Name=="root")) { currentServerPath = child.Properties["Path"].Value.ToString(); } } textBox2.Text=currentServerIP; textBox3.Text=currentServerPort; textBox4.Text=currentServerPath; textBox5.Text=currentServerHeader; textBox6.Text=currentServerHost; } /// <summary> /// 根据站点名称获取站点标识符 /// </summary> public string GetWebSiteNum(string siteName) { Regex […]

龙生 12 Feb 2012

View Details

使用Flash和C# WinForm配合打造界面漂亮的应用程序

(木野狐 2006-10-29) 由于之前一阵公司一个项目提出的需求，自己也想进行这方面的尝试，我对如何使用 Flash 来做 WinForm 程序的界面产生了兴趣，于是学习了一些资料，摘要于此。要在 WinForm 中使用 Flash，通常需要用到 Shockwave Flash Object 这个 COM 组件。 (http://www.codeproject.com/csharp/fscommand.asp) (http://www.codeproject.com/useritems/FlashDBInteract.asp) 具体步骤如下：首先添加对 COM 组件 Shockwave Flash Object 的引用，将该组件拖到窗体上之后，可以设置如下关键属性： Movie: Flash 的存放地址 EmbedMovie: 是否嵌入到程序的资源中。接下来你可以设置其他一些属性，使得 Flash 的窗口最大化，隐藏掉其宿主程序的 C# WinForm 窗体。在 Flash 的 ActionScript 中，可以通过 FSCommand 函数与 hosting app 通信，该函数有两个参数，分别是： command: 命令名称 parameters: 参数例子： on(press){ fscommand("Circule", "Green"); } 在 C# 中，处理 Flash 对象的 FSCommand 事件即可。如果该事件处理函数的 EventArgs 为 e, 则有如下对应关系： […]

龙生 12 Feb 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