基本原理就是先建立Socket连接，然后发请求命令和取回应答码。编码方式采用Encoding ASCII = Encoding.Default;来支持中文文件名。

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.IO;

namespace PMTSS.Common
{
 /// <summary>
 /// FTP 操作类
 /// </summary>
 public class FTP
 {
  private string strRemoteHost;
  private int strRemotePort;
  private string strRemotePath;
  private string strRemoteUser;
  private string strRemotePass;
  private Boolean bConnected;

  #region 内部变量
  /// <summary>
  /// 服务器返回的应答信息(包含应答码)
  /// </summary>
  private string strMsg;
  /// <summary>
  /// 服务器返回的应答信息(包含应答码)
  /// </summary>
  private string strReply;
  /// <summary>
  /// 服务器返回的应答码
  /// </summary>
  private int iReplyCode;
  /// <summary>
  /// 进行控制连接的socket
  /// </summary>
  private Socket socketControl;
  /// <summary>
  /// 传输模式
  /// </summary>
  private TransferType trType;
  /// <summary>
  /// 传输模式:二进制类型、ASCII类型
  /// </summary>
  public enum TransferType
  {
   /// <summary>
   /// Binary
   /// </summary>
   Binary,
   /// <summary>
   /// ASCII
   /// </summary>
   ASCII
  };

  /// <summary>
  /// 接收和发送数据的缓冲区
  /// </summary>
  private static int BLOCK_SIZE = 512;
  Byte[] buffer = new Byte[ BLOCK_SIZE];
  /// <summary>
  /// 编码方式
  /// </summary>
  Encoding ASCII = Encoding.Default;
  #endregion

  #region 内部函数

  #region 构造函数
  /// <summary>
  /// 缺省构造函数
  /// </summary>
  public FTP()
  {
   strRemoteHost  = "";
   strRemotePath  = "";
   strRemoteUser  = "";
   strRemotePass  = "";
   strRemotePort  = 21;
   bConnected     = false;
  }

  /// <summary>
  /// 构造函数
  /// </summary>
  /// <param name="remoteHost"></param>
  /// <param name="remotePath"></param>
  /// <param name="remoteUser"></param>
  /// <param name="remotePass"></param>
  /// <param name="remotePort"></param>
  public FTP( string remoteHost, string remotePath, string remoteUser, string remotePass, int remotePort )
  {
   strRemoteHost  = remoteHost;
   strRemotePath  = remotePath;
   strRemoteUser  = remoteUser;
   strRemotePass  = remotePass;
   strRemotePort  = remotePort;
   Connect();
  }
  public FTP( string remoteHost, string remotePath, string remoteUser, string remotePass)
  {
   strRemoteHost  = remoteHost;
   strRemotePath  = remotePath;
   strRemoteUser  = remoteUser;
   strRemotePass  = remotePass;
   strRemotePort  = 21;
   Connect();
  }
  #endregion

  #region 登陆
  /// <summary>
  /// FTP服务器IP地址
  /// </summary>
 
  public string RemoteHost
  {
   get
   {
    return strRemoteHost;
   }
   set
   {
    strRemoteHost = value;
   }
  }
  /// <summary>
  /// FTP服务器端口
  /// </summary>
  public int RemotePort
  {
   get
   {
    return strRemotePort;
   }
   set
   {
    strRemotePort = value;
   }
  }
  /// <summary>
  /// 当前服务器目录
  /// </summary>
  public string RemotePath
  {
   get
   {
    return strRemotePath;
   }
   set
   {
    strRemotePath = value;
   }
  }
  /// <summary>
  /// 登录用户账号
  /// </summary>
  public string RemoteUser
  {
   set
   {
    strRemoteUser = value;
   }
  }
  /// <summary>
  /// 用户登录密码
  /// </summary>
  public string RemotePass
  {
   set
   {
    strRemotePass = value;
   }
  }

  /// <summary>
  /// 是否登录
  /// </summary>
  public bool Connected
  {
   get
   {
    return bConnected;
   }
  }
  #endregion

  #region 链接
  /// <summary>
  /// 建立连接
  /// </summary>
  public void Connect()
  {
   socketControl = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
   IPEndPoint ep = new IPEndPoint(IPAddress.Parse(RemoteHost), strRemotePort);
   // 链接
   try
   {
    socketControl.Connect(ep);
   }
   catch(Exception)
   {
    throw new IOException("Couldn't connect to remote server");
   }

   // 获取应答码
   ReadReply();
   if(iReplyCode != 220)
   {
    DisConnect();
    throw new IOException(strReply.Substring(4));
   }

   // 登陆
   SendCommand("USER "+strRemoteUser);
   if( !(iReplyCode == 331 || iReplyCode == 230) )
   {
    CloseSocketConnect();//关闭连接
    throw new IOException(strReply.Substring(4));
   }
   if( iReplyCode != 230 )
   {
    SendCommand("PASS "+strRemotePass);
    if( !(iReplyCode == 230 || iReplyCode == 202) )
    {
     CloseSocketConnect();//关闭连接
     throw new IOException(strReply.Substring(4));
    }
   }
   bConnected = true;

   // 切换到目录
   ChDir(strRemotePath);
  }

  /// <summary>
  /// 关闭连接
  /// </summary>
  public void DisConnect()
  {
   if( socketControl != null )
   {
    SendCommand("QUIT");
   }
   CloseSocketConnect();
  }

  #endregion

  #region 传输模式

  /// <summary>
  /// 设置传输模式
  /// </summary>
  /// <param name="ttType">传输模式</param>
  public void SetTransferType(TransferType ttType)
  {
   if(ttType == TransferType.Binary)
   {
    SendCommand("TYPE I");//binary类型传输
   }
   else
   {
    SendCommand("TYPE A");//ASCII类型传输
   }
   if (iReplyCode != 200)
   {
    throw new IOException(strReply.Substring(4));
   }
   else
   {
    trType = ttType;
   }
  }

  /// <summary>
  /// 获得传输模式
  /// </summary>
  /// <returns>传输模式</returns>
  public TransferType GetTransferType()
  {
   return trType;
  }

  #endregion

  #region 文件操作
  /// <summary>
  /// 获得文件列表
  /// </summary>
  /// <param name="strMask">文件名的匹配字符串</param>
  /// <returns></returns>
  public string[] Dir(string strMask)
  {
   // 建立链接
   if(!bConnected)
   {
    Connect();
   }

   //建立进行数据连接的socket
   Socket socketData = CreateDataSocket();

   //传送命令
   SendCommand("NLST " + strMask);

   //分析应答代码
   if(!(iReplyCode == 150 || iReplyCode == 125 || iReplyCode == 226))
   {
    throw new IOException(strReply.Substring(4));
   }

   //获得结果
   strMsg = "";
   while(true)
   {
    int iBytes = socketData.Receive(buffer, buffer.Length, 0);
    strMsg += ASCII.GetString(buffer, 0, iBytes);
    if(iBytes < buffer.Length)
    {
     break;
    }
   }
   char[] seperator = {'\n'};
   string[] strsFileList = strMsg.Split(seperator);
   socketData.Close();//数据socket关闭时也会有返回码
   if(iReplyCode != 226)
   {
    ReadReply();
    if(iReplyCode != 226)
    {
     throw new IOException(strReply.Substring(4));
    }
   }
   return strsFileList;
  }

  /// <summary>
  /// 获取文件大小
  /// </summary>
  /// <param name="strFileName">文件名</param>
  /// <returns>文件大小</returns>
  private long GetFileSize(string strFileName)
  {
   if(!bConnected)
   {
    Connect();
   }
   SendCommand("SIZE " + Path.GetFileName(strFileName));
   long lSize=0;
   if(iReplyCode == 213)
   {
    lSize = Int64.Parse(strReply.Substring(4));
   }
   else
   {
    throw new IOException(strReply.Substring(4));
   }
   return lSize;
  }

  /// <summary>
  /// 删除
  /// </summary>
  /// <param name="strFileName">待删除文件名</param>
  public void Delete(string strFileName)
  {
   if(!bConnected)
   {
    Connect();
   }
   SendCommand("DELE "+strFileName);
   if(iReplyCode != 250)
   {
    throw new IOException(strReply.Substring(4));
   }
  }

  /// <summary>
  /// 重命名(如果新文件名与已有文件重名,将覆盖已有文件)
  /// </summary>
  /// <param name="strOldFileName">旧文件名</param>
  /// <param name="strNewFileName">新文件名</param>
  public void Rename(string strOldFileName,string strNewFileName)
  {
   if(!bConnected)
   {
    Connect();
   }
   SendCommand("RNFR "+strOldFileName);
   if(iReplyCode != 350)
   {
    throw new IOException(strReply.Substring(4));
   }
   //  如果新文件名与原有文件重名,将覆盖原有文件
   SendCommand("RNTO "+strNewFileName);
   if(iReplyCode != 250)
   {
    throw new IOException(strReply.Substring(4));
   }
  }
  #endregion

  #region 上传和下载
  /// <summary>
  /// 下载一批文件
  /// </summary>
  /// <param name="strFileNameMask">文件名的匹配字符串</param>
  /// <param name="strFolder">本地目录(不得以\结束)</param>
  public void Get(string strFileNameMask,string strFolder)
  {
   if(!bConnected)
   {
    Connect();
   }
   string[] strFiles = Dir(strFileNameMask);
   foreach(string strFile in strFiles)
   {
    if(!strFile.Equals(""))//一般来说strFiles的最后一个元素可能是空字符串
    {
     Get(strFile,strFolder,strFile);
    }
   }
  }

  /// <summary>
  /// 下载一个文件
  /// </summary>
  /// <param name="strRemoteFileName">要下载的文件名</param>
  /// <param name="strFolder">本地目录(不得以\结束)</param>
  /// <param name="strLocalFileName">保存在本地时的文件名</param>
  public void Get(string strRemoteFileName,string strFolder,string strLocalFileName)
  {
   if(!bConnected)
   {
    Connect();
   }
   SetTransferType(TransferType.Binary);
   if (strLocalFileName.Equals(""))
   {
    strLocalFileName = strRemoteFileName;
   }
   if(!File.Exists(strLocalFileName))
   {
    Stream st = File.Create(strLocalFileName);
    st.Close();
   }
   FileStream output = new
    FileStream(strFolder + "\\" + strLocalFileName,FileMode.Create);
   Socket socketData = CreateDataSocket();
   SendCommand("RETR " + strRemoteFileName);
   if(!(iReplyCode == 150 || iReplyCode == 125
    || iReplyCode == 226 || iReplyCode == 250))
   {
    throw new IOException(strReply.Substring(4));
   }
   while(true)
   {
    int iBytes = socketData.Receive(buffer, buffer.Length, 0);
    output.Write(buffer,0,iBytes);
    if(iBytes <= 0)
    {
     break;
    }
   }
   output.Close();
   if (socketData.Connected)
   {
    socketData.Close();
   }
   if(!(iReplyCode == 226 || iReplyCode == 250))
   {
    ReadReply();
    if(!(iReplyCode == 226 || iReplyCode == 250))
    {
     throw new IOException(strReply.Substring(4));
    }
   }
  }

  /// <summary>
  /// 上传一批文件
  /// </summary>
  /// <param name="strFolder">本地目录(不得以\结束)</param>
  /// <param name="strFileNameMask">文件名匹配字符(可以包含*和?)</param>
  public void Put(string strFolder,string strFileNameMask)
  {
   string[] strFiles = Directory.GetFiles(strFolder,strFileNameMask);
   foreach(string strFile in strFiles)
   {
    //strFile是完整的文件名(包含路径)
    Put(strFile);
   }
  }

  /// <summary>
  /// 上传一个文件
  /// </summary>
  /// <param name="strFileName">本地文件名</param>
  public void Put(string strFileName)
  {
   if(!bConnected)
   {
    Connect();
   }
   Socket socketData = CreateDataSocket();
   SendCommand("STOR "+Path.GetFileName(strFileName));
   if( !(iReplyCode == 125 || iReplyCode == 150) )
   {
    throw new IOException(strReply.Substring(4));
   }
   FileStream input = new
    FileStream(strFileName,FileMode.Open);
   int iBytes = 0;
   while ((iBytes = input.Read(buffer,0,buffer.Length)) > 0)
   {
    socketData.Send(buffer, iBytes, 0);
   }
   input.Close();
   if (socketData.Connected)
   {
    socketData.Close();
   }
   if(!(iReplyCode == 226 || iReplyCode == 250))
   {
    ReadReply();
    if(!(iReplyCode == 226 || iReplyCode == 250))
    {
     throw new IOException(strReply.Substring(4));
    }
   }
  }

  #endregion

  #region 目录操作
  /// <summary>
  /// 创建目录
  /// </summary>
  /// <param name="strDirName">目录名</param>
  public void MkDir(string strDirName)
  {
   if(!bConnected)
   {
    Connect();
   }
   SendCommand("MKD "+strDirName);
   if(iReplyCode != 257)
   {
    throw new IOException(strReply.Substring(4));
   }
  }

  /// <summary>
  /// 删除目录
  /// </summary>
  /// <param name="strDirName">目录名</param>
  public void RmDir(string strDirName)
  {
   if(!bConnected)
   {
    Connect();
   }
   SendCommand("RMD "+strDirName);
   if(iReplyCode != 250)
   {
    throw new IOException(strReply.Substring(4));
   }
  }

  /// <summary>
  /// 改变目录
  /// </summary>
  /// <param name="strDirName">新的工作目录名</param>
  public void ChDir(string strDirName)
  {
   if(strDirName.Equals(".") || strDirName.Equals(""))
   {
    return;
   }
   if(!bConnected)
   {
    Connect();
   }
   SendCommand("CWD "+strDirName);
   if(iReplyCode != 250)
   {
    throw new IOException(strReply.Substring(4));
   }
   this.strRemotePath = strDirName;
  }

  #endregion

  /// <summary>
  /// 将一行应答字符串记录在strReply和strMsg
  /// 应答码记录在iReplyCode
  /// </summary>
  private void ReadReply()
  {
   strMsg = "";
   strReply = ReadLine();
   iReplyCode = Int32.Parse(strReply.Substring(0,3));
  }

  /// <summary>
  /// 建立进行数据连接的socket
  /// </summary>
  /// <returns>数据连接socket</returns>
  private Socket CreateDataSocket()
  {
   SendCommand("PASV");
   if(iReplyCode != 227)
   {
    throw new IOException(strReply.Substring(4));
   }
   int index1 = strReply.IndexOf('(');
   int index2 = strReply.IndexOf(')');
   string ipData =
    strReply.Substring(index1+1,index2-index1-1);
   int[] parts = new int[6];
   int len = ipData.Length;
   int partCount = 0;
   string buf="";
   for (int i = 0; i < len && partCount <= 6; i++)
   {
    char ch = Char.Parse(ipData.Substring(i,1));
    if (Char.IsDigit(ch))
     buf+=ch;
    else if (ch != ',')
    {
     throw new IOException("Malformed PASV strReply: " +
      strReply);
    }
    if (ch == ',' || i+1 == len)
    {
     try
     {
      parts[partCount++] = Int32.Parse(buf);
      buf="";
     }
     catch (Exception)
     {
      throw new IOException("Malformed PASV strReply: " +
       strReply);
     }
    }
   }
   string ipAddress = parts[0] + "."+ parts[1]+ "." +
    parts[2] + "." + parts[3];
   int port = (parts[4] << 8) + parts[5];
   Socket s = new
    Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
   IPEndPoint ep = new
    IPEndPoint(IPAddress.Parse(ipAddress), port);
   try
   {
    s.Connect(ep);
   }
   catch(Exception)
   {
    throw new IOException("Can't connect to remote server");
   }
   return s;
  }

  /// <summary>
  /// 关闭socket连接(用于登录以前)
  /// </summary>
  private void CloseSocketConnect()
  {
   if(socketControl!=null)
   {
    socketControl.Close();
    socketControl = null;
   }
   bConnected = false;
  }

  /// <summary>
  /// 读取Socket返回的所有字符串
  /// </summary>
  /// <returns>包含应答码的字符串行</returns>
  private string ReadLine()
  {
   while(true)
   {
    int iBytes = socketControl.Receive(buffer, buffer.Length, 0);
    strMsg += ASCII.GetString(buffer, 0, iBytes);
    if(iBytes < buffer.Length)
    {
     break;
    }
   }
   char[] seperator = {'\n'};
   string[] mess = strMsg.Split(seperator);
   if(strMsg.Length > 2)
   {
    strMsg = mess[mess.Length-2];
    //seperator[0]是10,换行符是由13和0组成的,分隔后10后面虽没有字符串,
    //但也会分配为空字符串给后面(也是最后一个)字符串数组,
    //所以最后一个mess是没用的空字符串
    //但为什么不直接取mess[0],因为只有最后一行字符串应答码与信息之间有空格
   }
   else
   {
    strMsg = mess[0];
   }
   if(!strMsg.Substring(3,1).Equals(" "))//返回字符串正确的是以应答码(如220开头,后面接一空格,再接问候字符串)
   {
    return ReadLine();
   }
   return strMsg;
  }

  /// <summary>
  /// 发送命令并获取应答码和最后一行应答字符串
  /// </summary>
  /// <param name="strCommand">命令</param>
  private void SendCommand(string strCommand)
  {
   Byte[] cmdBytes = ASCII.GetBytes((strCommand + "\r\n").ToCharArray());
   socketControl.Send(cmdBytes, cmdBytes.Length, 0);
   ReadReply();
  }

  #endregion
 }
}

public delegate void MyDelegate(string str);
注
1.委托的定义和方法的定义类似，只是在前面加了一个delegate,但委托不是方法，它是一种类型。是一种特殊的类型,看成是一种新的对象类型比较好理解。用于对与该委托有相

同签名的方法调用。
2.委托相当于C++中的函数指针，但它是类型安全的。
3.委托是从System.Delegate派生，但不能象定义常规类型一样直接从System.Delegate派生，对委托的声明只能通过上面的声明格式进行定义。关键字delegate通知编译器这是一

个委托类型，从而在编译的时候对该类进行封装,对这一过程C#定义了专门的语法来处理这一过程。
4.不能从一个委托类型进行派生，因为它也是默认sealed的
5.委托即可以对静态方法进行调用也可以对实例方法进行调用。
6.每个委托类型包含一个自己的调用列表，当组合一个委托或从一个委托中删除一个委托时都将产生个新的调用列表。
7.两个不同类型的委托即使它们有相同的签名和返回值，但还是两个不同类型的委托。但其实在使用中可看作是相同的。

委托的比较

C#中对委托定义了两个操作符 == 和 !=
在以下情况下两个委托是相等的：
1.当两个委托都同时为null的时候
2.当两个委托都不为null时,下列情况下是相等的。
a.当两个委托的各自的调用列表只含有一个入口点的时候
   在下列情况下是相等的
   (1) 调用同一对象的同一静态方法
   (2) 调用同一对象的同一实例方法
b.当两个委托具有多个入口点时
   在下列情况下是相等的
   (1)只有当它们调用列表中的调用的方法按顺序都一一对应相同的对象及对象的同一方法的时候

如上所述的两个不同类型的委托但是它们具有相同的签名和返回值时，只要满足上述条件的，即使它们类型不同，但比较的结果也是相同的。

委托的异常处理

当调用该委托的方法中发生了异常时，首先在调用该委托的方法中搜寻catch语句块。如果没有，则去该委托调用的方法中去寻找有没有catch语句块，这和调用方法发生异常的处

理是一样的。

当调用一个为null的委托即委托中列表中不存在调用方法时，将发生NullRefrenceException

委托的注意点:
当一个委托有多个入口点的时候,调用委托将依该委托的调用列表中的方法的顺序依次调用.这些方法共享一个参数集合,所以当委托有返回值的时候调用完这个委托后的返回值是最

后一个方法的返回值或是有out参数.如果该委托的参数为ref(引用类型),那么在招待第一个方法的时候如果对这个参数的值有所改变,那么这个改变将会影响到后面的方法调用.

委托的一个例子

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建一个委托实例，封装C类的静态方法M1
            MyDelegate d1 = new MyDelegate(C.M1);
            d1("D1"); // M1

            // 创建一个委托实例，封装C类的静态方法M2
            MyDelegate d2 = new MyDelegate(C.M2);
            d2("D2"); // M2

            // 创建一个委托实例，封装C类的实例方法M3
            MyDelegate d3 = new MyDelegate(new C().M3);
            d3("D3"); // M3

            // 从一个委托d3创建一个委托实例
            MyDelegate d4 = new MyDelegate(d3);
            d4("D4"); // M3

            // 组合两个委托
            MyDelegate d5 = d1 + d2;
            d5 += d3;
            d5("D5"); // M1,M2,M3

            // 从组合委托中删除d3
            MyDelegate d6 = d5 - d3;
            d6("D6"); // M1,M2
            d6 -= d3; // 虽然d6调用列表中已经没有d3了，但这样只是不可能的移除没有错误发生
            d6("D6"); // M1,M2
            d6 -= d6;
            //d6("D6"); 此时d6的调用列表为空，d6为null,所以引发System.NullReferenceException

            MyDelegate d7 = new MyDelegate(C1.P1);
            d7("D7"); // C1.P1

            MyDelegate d8 = new MyDelegate(new C2().P1);
            d8("D8"); // C2.P1

        }
    }

    // 声明一个委托MyDelegate
    public delegate void MyDelegate(string str);

    public class C
    {
        public static void M1(string str)
        {
            Console.WriteLine("From:C.M1:   {0}", str);
        }

        public static void M2(string str)
        {
            Console.WriteLine("From:C.M2:   {0}", str);
        }

        public void M3(string str)
        {
            Console.WriteLine("From:C.M3:   {0}", str);
        }
    }

    public class C1
    {
        public static void P1(string str)
        {
            Console.WriteLine("From:C1.P1:   {0}", str);
        }
    }

    public class C2
    {
        public void P1(string str)
        {
            Console.WriteLine("From:C2.P1:   {0}", str);
        }
    }   
}

事件委托

事件概述

事件就是当对象或类状态发生改变时，对象或类发出的信息或通知。发出信息的对象或类称为"事件源",对事件进行处理的方法称为"接收者",通常事件源在发出状态改变信息时,它

并不知道由哪个事件接收者来处理.这就需要一种管理机制来协调事件源和接收者,C++中通过函数指针来完成的.在C#中事件使用委托来为触发时将调用的方法提供类型安全的封装

事件的声明

1.声明一个委托
public delegate void EventHandler(object sender, System.EventArgs e);

2.声明一个事件
public event EventHandler Changed;

3.引发一个事件
public OnChanged(EnventArgs e)
{
 if ( Changed != null)
 {
  Changed(this,e);
 }
}

4.定义事件处理程序
public MyText_OnChanged(Object sender,EventArgs e)
{
 ...
}

5.订阅事件(将事件处理程序添加到事件的调用列表中)

myText.Changed += EventHandler(MyText_OnChanged);

下面的一个小例子说明了怎样定义一个完整的事件机制:

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

namespace ConsoleApplication1
{
    class Program
    {       
        static void Main(string[] args)
        {             
            MyText myText = new MyText();

            // 将事件处理程序添加到事件的调用列表中(即事件布线)
            myText.Changed += new MyText.ChangedEventHandler(myText_Changed);        
           
            string str = "";
            while (str != "quit")
            {
                Console.WriteLine("please enter a string:");
                str = Console.ReadLine();
                myText.Text = str;
            }
        }

        // 对Change事件处理的程序
        private static void myText_Changed(object sender, EventArgs e)
        {
            Console.WriteLine("text has been changed  :{0}\n" ,((MyText)sender).Text);
        }       
    } 

    public class MyText
    {
        private string _text = "";

        // 定义事件的委托
        public delegate void ChangedEventHandler(object sender, EventArgs e);

        // 定义一个事件
        public event ChangedEventHandler Changed;

        // 用以触发Change事件
        protected virtual void OnChanged(EventArgs e)
        {
            if (this.Changed != null)
                this.Changed(this, e);
        }

        // Text属性
        public string Text
        {
            get { return this._text; }
            set
            {
                this._text = value;
                // 文本改变时触发Change事件
                this.OnChanged(new EventArgs());
            }
        }
    }
}  

              1.面向对象的思想主要包括什么？
              2.什么是ASP.net中的用户控件
              3.什么叫应用程序域？什么是受管制的代码？什么是强类型系统？什么是装箱和拆箱？什么是重载？CTS、CLS和CLR分别作何解释？
              4.列举一下你所了解的XML技术及其应用
              5.值类型和引用类型的区别？写出C#的样例代码。
              6.ADO.net中常用的对象有哪些？分别描述一下。
              7.如何理解委托？
              8.C#中的接口和类有什么异同。
              9.。net中读写数据库需要用到哪些类？他们的作用
              10.UDP连接和TCP连接的异同。
              11.ASP.net的身份验证方式有哪些？分别是什么原理？
              12.进程和线程分别怎么理解？
              13.什么是code-Behind技术。
              14.活动目录的作用。
              15..net中读写XML的类都归属于哪些命名空间？
              16.解释一下UDDI、WSDL的意义及其作用。
              17.什么是SOAP,有哪些应用。
              18.如何部署一个ASP.net页面。
              19.如何理解.net中的垃圾回收机制。
              20.常用的调用webservice方法有哪些？
              1 继承 多态 封装
              2 用户控件. 不会说懂得做
              3 装箱和拆箱发生 值类型向引用类型转换,和引用类型向值类型转  重载:同一个函数参数不同
              4.xml可以用来做网页(xslt) xml可以当作数据库 xml可以用来保存对象的系列化
              5值类型,没有什么好说的.引用类型用处是返回两个以上参数的时候比较好用 ref out 我常用的是out不要先赋值
              6  ado.net 我直接用 sqlhelper了 有connection command 还有参数
              7 回调机制比较有用的.在net中采用了委托.
              8 接口,是可以多继承,类只有单继承.接口强调了你必须实现,而没有具本实现的方法和虚类有点相似
              9 datareader dataset 还有一个不太常用
              10 udp不要实现什么三次握手.
              11 asp.net身份验证最常用还是以前的session方法. form验证没有用过. 微软的哪个也没有用过
              12 进程简单理解为单个程序吧(按ctrl+alt+del)可以看到的.它至少有一个主线程 .
              13 代码后置..不懂得讲
              14 活动目录.. 完全不会
              15 system.xml (system.io创建目录的时候用)
              16 这个也是web服务里的东西.
              17 soap简单协议.我只知道.web服务是基于它之上的
              18 部置一个页面. 也就是说没有代码是直接写在aspx中的了.只接放在IIS的虚拟目录下就行了.当然要asp.net支持
              19 垃圾回收..一般的只要掌握.非托管对象要记得释放资源就行了吧.
              20 直接在vs.net里面引用就OK了.它会自己生成一个代理类

              1.      填空: (1)面向对象的语言具有___继承性、_封装___性、___多态性。
                      (2)能用foreach遍历访问的对象需要实现 IEnumerable接口或声明GetEnumerable
              方法的类型。
                     
              (3)列举ADO.net中的五个主要对象Command、Connection、DataSet、DataSetCommand、DataReader。
              2. 不定项选择：
              (1) 以下叙述正确的是：
                    A. 接口中可以有虚方法。     B. 一个类可以实现多个接口。
                    C. 接口不能被实例化。       D. 接口中可以包含已实现的方法。
                 (2) 从数据库读取记录，你可能用到的方法有：
                    A. ExecuteNonQuery            B. ExecuteScalar
                    C. Fill                        D. ExecuteReader
              3. 简述 private、 protected、 public、 internal 修饰符的访问权限。

              4. 写出一条Sql语句： 取出表A中第31到第40记录（SQLServer, 以自动增长的ID作为主键, 
              注意：ID可能不是连续的。）

              5 .列举ASP.NET 页面之间传递值的几种方式。

              6. 写出程序的输出结果
              class Class1  {
                     private string str = "Class1.str";
                     private int i = 0;
                     static void StringConvert(string str)  {
                         str = "string being converted.";
                     }
                     static void StringConvert(Class1 c)  {
                         c.str = "string being converted.";
                     }
                     static void Add(int i)  {
                         i++;
                     }
                     static void AddWithRef(ref int i)  {
                         i++;
                     }
                     static void Main()  {
                         int i1 = 10;
                         int i2 = 20;
                         string str = "str";
                         Class1 c = new Class1();
                         Add(i1);
                         AddWithRef(ref i2);
                         Add(c.i);
                         StringConvert(str);        
                         StringConvert(c);
                         Console.WriteLine(i1);
                         Console.WriteLine(i2);
                         Console.WriteLine(c.i);
                         Console.WriteLine(str);
                         Console.WriteLine(c.str);
                     } 
                  }

  在.NET Framework中，Hashtable是System.Collections命名空间提供的一个容器，用于处理和表现类似keyvalue的键值对，其中key通常可用来快速查找，同时key是区分大小写；value用于存储对应于key的值。Hashtable中keyvalue键值对均为object类型，所以Hashtable可以支持任何类型的keyvalue键值对.

二,哈希表的简单操作

 在哈希表中添加一个keyvalue键值对：HashtableObject.Add(key,value);
 在哈希表中去除某个keyvalue键值对：HashtableObject.Remove(key);
 从哈希表中移除所有元素：           HashtableObject.Clear();
 判断哈希表是否包含特定键key：      HashtableObject.Contains(key);
 下面控制台程序将包含以上所有操作：
using System;
using System.Collections; file使用Hashtable时，必须引入这个命名空间
class hashtable
{
  public static void Main()
  {
  Hashtable ht=new Hashtable(); file创建一个Hashtable实例
  ht.Add(E,e);添加keyvalue键值对
  ht.Add(A,a);
  ht.Add(C,c);
  ht.Add(B,b);

注意：key值必须唯一。
  string s=(string)ht[A];
  if(ht.Contains(E)) file判断哈希表是否包含特定键,其返回值为true或false
    Console.WriteLine(the E keyexist);
  ht.Remove(C);移除一个keyvalue键值对
  Console.WriteLine(ht[A]);此处输出a
  ht.Clear();移除所有元素
  Console.WriteLine(ht[A]); file此处将不会有任何输出
  }
}

三,遍历哈希表

 遍历哈希表需要用到DictionaryEntry Object，代码如下：
 for(DictionaryEntry de in ht) fileht为一个Hashtable实例
 {
   Console.WriteLine(de.Key);de.Key对应于keyvalue键值对key
   Console.WriteLine(de.Value);de.Key对应于keyvalue键值对value
 }

四,对哈希表进行排序

  对哈希表进行排序在这里的定义是对keyvalue键值对中的key按一定规则重新排列，但是实际上这个定义是不能实现的，因为我们无法直接在Hashtable进行对key进行重新排列，如果需要Hashtable提供某种规则的输出，可以采用一种变通的做法：
 ArrayList akeys=new ArrayList(ht.Keys); file别忘了导入System.Collections
 akeys.Sort(); file按字母顺序进行排序
 for(string skey in akeys)
 {
   Console.Write(skey + );
   Console.WriteLine(ht[skey]);排序后输出
 }

  protected static WindowsIdentity CreateIdentity(string User, string Domain, string Password)
  {
   // The Windows NT user token.
   IntPtr tokenHandle = new IntPtr(0);

   const int LOGON32_PROVIDER_DEFAULT = 0;
   const int LOGON32_LOGON_NETWORK = 3;

   tokenHandle = IntPtr.Zero;

   // Call LogonUser to obtain a handle to an access token.
   bool returnValue = LogonUser(User, Domain, Password,
    LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT,
    ref tokenHandle);

   if (false == returnValue)
   {
    int ret = Marshal.GetLastWin32Error();
    throw new Exception("LogonUser failed with error code: " +  ret);
   }

   System.Diagnostics.Debug.WriteLine("Created user token: " + tokenHandle);

   //The WindowsIdentity class makes a new copy of the token.
   //It also handles calling CloseHandle for the copy.
   WindowsIdentity id = new WindowsIdentity(tokenHandle);
   CloseHandle(tokenHandle);
   return id;
  }

  [DllImport("advapi32.dll", SetLastError=true)]
  private static extern bool LogonUser(String lpszUsername, String lpszDomain, String lpszPassword,
   int dwLogonType, int dwLogonProvider, ref IntPtr phToken);

  [DllImport("kernel32.dll", CharSet=CharSet.Auto)]
  private extern static bool CloseHandle(IntPtr handle);
 }

using System;
using System.Data;
using System.Configuration;
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;
using System.Xml;
using System.Xml.XPath;

public partial class _Default : System.Web.UI.Page
{
    public string[] x = new string[4];
    protected void Page_Load(object sender, EventArgs e)
    {

        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(Server.MapPath("table.xml"));//你的xml文件
        XmlNodeList xmlList = xmlDoc.SelectSingleNode("MapSheet").ChildNodes;
        foreach (XmlNode xmlNo in xmlList)
        {
            //XmlNodeList xe = (XmlNodeList)xmlNo;
            XmlElement xe = (XmlElement)xmlNo;
            {
                if (xe.Name == "TableName")
                {
                    y[0] = xe.InnerText;
                }

                if (xe.Name == "DataSource")
                {
                    y[1] = xe.InnerText;
                }

                if (xe.Name == "UserName")
                {
                    y[2] = xe.InnerText;
                }

                if (xe.Name == "Password")
                {
                    y[3] = xe.InnerText;
                }
            }
        }
        TextBox1.Text=y[0];
        TextBox2.Text = y[1];
        TextBox3.Text = y[2];
        TextBox4.Text = y[3];
    }

}该程序已经过测试，没有问题。

　　◇在xml的文档的最头部加入xml的声明段落： 
　　利用"xmldocument"类中的 "createnode" 方法可以创建一个指定类型的xml节点，"createnode" 方法的调用方法总共有三种，在本文中使用的其一般的方法，具体语法如下： 

　　然后在利用"xmldocument"类中的"appendchild"方法在xml文档中加入此节点，用c＃在xml文档中加入声明段落实现的语句如下： 

　　◇为xml文档加入元素（element）： 
　　加入数据内容是通过元素，在"xmldocument"类中提供了二个方法："createelement"和"createtextnode"。其中第一个方法是在xml中创建一个元素，另外一个方法是为创建的元素指定文本值。下面是为上面创建的xml文档加入一个根元素。 

　　注释：其中"xmlelem"是创建的"xmlelement"对象，"xmltext"是"xmltext"对象 
　　有了创建一个xml元素的例子，就可以根据xml文档中数据的不同的结构来创建其他的数据了。 

    2.c＃创建xml文档的第一种方法的源程序代码（no1.cs）： 

    3.c＃创建xml文档的第二种方法： 
    在介绍完第一种方法以后，我想每一个读者都感觉到用c＃创建xml文档是一项比较烦杂的工作了，因为不仅要了解创建的知识，还要了解文档的结构，这样创建的过程就是一步一步的了。下面就来介绍一种比较容易的创建方法，这种创建方法是直接定义xml文档，然后把他保存到文件中就可以了。 
    ◇创建一个xml文档： 
    这一点和第一种方法一样，在这里就不介绍了。 

　　◇通过"xmldocument"类中的"loadxml"方法，直接在文档中加入想要加入的xml数据。当然你加入的xml应该符合xml的语法，不然产生的文件也没有什么意义了。下面是加入xml的具体代码： 

　　把保存xml文档到文件中： 
　　保存xml文档是通过"xmldocument"类中的"save"方法来实现的。具体如下： 

　　◇c＃创建xml文档的第二种方法的源程序代码（no2.cs）： 

    用c＃创建xml文档的方法其实有很多，在这里只是选取了二种比较典型的方法加以介绍。但无论那一种方法，c＃在创建xml的时候都需要用到.net framework sdk。所以了解并掌握这个类库中的内容对于c＃编程是十分必要的，在下面我们将来介绍一下用c＃读取xml中的数据，通过这你会发现，c＃又是利用这个类库实现这个功能的。 

    三.c＃读取xml文件： 
　　本节将用c＃来读取本文中用第二种方法创建的xml文件，编译no2.cs后，执行将产生"data.xml"文件，其中"data.xml"文件的数据结构如下： 

　　 在下面的内容中，我们利用c＃读取此文件，并用listview组件按照数据结构给显示出来。下图是读取此xml后的运行界面： 
　　图01：c＃读取xml后的运行界面 
　　　　　　　　　　　　

　　要正确读取xml数据，首先要了解xml的结构。根据上面的xml文件，可以知道此xml包含三个数据，下面就来看如何读取这三条数据： 

　　◇装入xml文件，形成数据流： 
　　通过创建一个"xmldocument"对象，然后利用"load"方法，可以把xml文件装入，具体如下： 

　　◇读取xml文件，并显示出来： 
　　读取xml是通过创建"xmlnodereader"对象来实现的，"xmlnodereader"对象主要是用来可以读取xml的节点数据。在本文的程序中使用到了一些"xmlnodereader"的属性，譬如"nodetype"属性，用来判断读取得节点是什么类型。"value"是节点的值。下面是读取xml文件并显示在listview中的实现代码，其中listview1是已经创建listview组件： 

　　四.c＃读取xml的文件的源程序代码（read.cs）： 
　　在了解了上面的内容以后，可以得到用c＃读取指定xml文件的完整代码，具体如下： 

　　五．总结： 
　　c＃和xml的渊源是很深的，本文只是从一个侧面反映了二者关系的密切程度。在.net framework sdk中存在许多可以直接操作xml的类库，掌握这些类库的使用方法，对用c＃开发和xml相关程序是十分必要的。 

在 C# 中，类可以包含字段、方法、属性和索引器。 在本文中，您将学习如何在 C# 中新建一个表示棒球队 (Baseball Team) 的类。 将给该类定义字段、方法和属性。接着将创建此类类型的一个对象并利用其方法和属性。

新建类
1. 从项目菜单上，单击添加类。 
2. 在添加新项对话框的类名中，键入 BaseballTeam，然后单击打开。 
3. 在“代码视图”窗口中检查该新类的代码。 

定义字段和构造函数
1. 在视图菜单上，单击类视图。 在“类视图”窗口中，展开 ClassesAndObjects 项目，然后展开 ClassesAndObjects 名称空间。 右键单击 BaseballTeam 类，选择添加，然后单击添加字段。 
2. 在 C# 字段向导中，将字段访问设置为 private，并将字段类型设置为 string。 在字段名中，键入 name。单击完成。 此时，就会将以下字段添加到该类中：
private string name;
 
3. 重复步骤 1 和 2（或手动键入代码）以添加另一个字段，如下所示：
private string stadium;
 
4. 再添加两个字段，并提供初始字段值，如下所示：
 private int wins = 0;
private int defeats = 0;
 
5. 修改该类的构造函数，以初始化球队和体育场 (stadium) 的名称：
public BaseballTeam(string n, string s)
{
   this.name = n;
   this.stadium = s;
}

定义方法
1. 在类视图中，右键单击 BaseballTeam 类。 选择添加，然后单击添加方法。 
2. 将方法访问设置为 public，并将返回类型设置为 void。 在方法名称中，键入 PlayGame。 添加两个名为 runsFor 和 runsAgainst 的 int 参数。单击完成。 此时，就会将以下方法添加到该类中：
public void PlayGame(int runsFor, int runsAgainst)
{
}
3. 定义方法体，如下所示：
public void PlayGame(int runsFor, int runsAgainst)
{
   if (runsFor > runsAgainst)
      this.wins++;
else
      this.defeats++;
}
4. C# 中的所有类最终都是从名为 Object 的基类继承而来的。此类定义了所有类的通用功能。以 ToString 方法为例，它返回一个字符串形式的类状态。 在您的 BaseballTeam 类中重写此方法，如下所示： public override string ToString()
{
   return this.name + ", play at " + this.stadium + ": " +
          " W" + this.wins + " L" + this.defeats;
}

定义重载方法
C# 支持重载方法，它是指名称相同但签名不同的方法。 在下面的步骤 2 中，将定义 PlayGame 方法的一个重载版本，该方法将比赛结果作为参数。
1. 首先，在 BaseballTeam 类中定义一个 enum，如下所示： public enum Result {Win, Lose}
2. 另创建一个 PlayGame 方法，如下所示： public void PlayGame(Result r)
{
   if (r == Result.Win)
      this.wins++;
   else if (r == Result.Lose)
      this.defeats++;
}

定义属性
1. 在类视图中，右键单击 BaseballTeam 类。 选择添加，然后单击添加属性。 
2. 将属性访问设置为 public，并将属性类型设置为 double。 在属性名中，键入 Record。 单击 get 单选按钮，然后单击完成。 此时，就会将以下属性添加到该类中： public double Record
{
   get
   {
      return 0;
   }
}
3. 按以下方式修改该属性，使其返回棒球队的比赛记录（例如，如果本队赢得 10 场比赛，输掉 10 场比赛，则该队的记录为 0.5）： public double Record
{
   get
   {
      int played = this.wins + this.defeats;
      return (double)this.wins / played;
   }
}
4. 添加一个名为 Ballpark 的获取/设置属性，如下所示。 该属性允许读取或更改棒球队的 stadium 字段： public string Ballpark
{
   get
   {
      return this.stadium;
   }
   set
   {
      this.stadium = value;  // value is an implicit parameter
   }
}

创建并使用一个对象
1. 在“代码视图”窗口中显示 Class1.cs 的代码。 
2. 在 Main 方法中，使用 new 运算符创建一个 BaseballTeam 对象。 将对该对象的引用赋值给 BaseballTeam 局部变量，如下所示：
BaseballTeam sf = new BaseballTeam("San Francisco Giants",
                                   "Candlestick Park");
3. 添加下列代码以便在对象上测试公用方法：
sf.PlayGame(7, 2);
sf.PlayGame(BaseballTeam.Result.Lose);
4. 添加下列语句以检验对象的属性：
Console.Out.WriteLine("Record: " + sf.Record);
sf.Ballpark = "3Com Park";
5. 显示对象的当前状态，如下所示：
Console.Out.WriteLine(sf.ToString());
6. 将对该对象的引用设置为 null，表明您不再需要 BaseballTeam 对象。 这样，就可以将该对象作为垃圾回收（注意，C# 没有 delete 运算符）：
sf = null;