系统类 

Type类，Object类，String类， Arrary类，Console类， Exception类，GC类， MarshalByRefObject类， Math类。

DateTime结构，Guid 结构，

     ICloneable接口，IComparable接口，IConvertible接口， IDisposable类， 

集合类

     ICollection接口，IComparer接口，IDictionary接口。IDictionaryEnumerator接口 ，IEnumerable接口，

      IEnumerator接口，IHashCodeProvider接口，IList接口，

     Stack 类，Queue类 ArraryList类，Hashtable类，SortedList类 CollectionBase类，DictionBase类

     DictionEntry结构。 

输入输出

 字节流

  Stream类，BufferedStream类，FileStream类，MemorStream类

二进制I/O流

BinaryReader类，BinaryWriter类。

字符I/O流

     TextReader类，TextWriter类，StreamReader类，StreamWriter类，StringReader类，StringReader类，StringWriter类。

I/O枚举

FileAccess枚举，FileAttributes枚举，FileMode枚举，FileShare枚举。

文件系统操作类

FileSystemInfo类 Directory类，Directoryinfo类 ，File类，Fileinfo类 

反射

        应用程序层次结构类

  Assembly类，Module类， 

成员信息类

      Memberinfo类，MethodBase类，ConstructorInfo类，EventInfo类

  MainifestResourceInfo类 Methodinfo类，ParameterInfo类，propertyInfo类 

       SystemReflection的其他成员， 

 Binder类，BindingFlags枚举 IReflect枚举 Pointer类 

文件操作

  Encoding类 ，AscIIEndoing类，UnicodeEncoding类，

 UTF7Encoding类 UTF8Encoding类，Decoder类

 StringBuilder类 

正则表达式

Capture类

CaptureCollection类

Group类

Match类 MatchCollection类

Regex类

RegexOptions枚举

多线程

Thread类，Monitor类，WaitHandle类，Mutex类 ReaderWriterLock类。ThreadPool类，Timeout类，

InterLocked类，

ThreadStart委托、

ThreadPriority枚举，ThreadState枚举，

类库是我们学习和开发的基本。 因为本人列举了一些常用的类，得到了很多网友的支持评论。为了更好的系统学习这些基础。

    本人打算写一系列的总结。希望对新手有所帮助，高手多多指点。
  

以下主要涉及是的system命名空间的常用类

     基本的Object和Type类，它构成了.NET FrameWork功能的基础。

    多用途的类。如Array、Console和String，它们被用于许多不同类型的应用程序。

     重要的基类，如EventArgs、Exception和MarshalByRefObject。这些类定义了很多派生类通用的属性可方法。

   Math类，他是一个只包含的数学函数和常量的库。

     Convert类，它提供了转换函数。

一般来通用的都会定义为静态的类。这样方面全句调用。

Type类

     Type它表示类型声明：类类型、接口类型、数组类型、值类型、枚举类型、类型参数、泛型类型定义，以及开放或封闭构造的泛型类型。

一个只包含的数学函数和常量的库。

 可以过通过两种方法来获得一个Type对象，一种使用GetType()方法，或是使用typeOf运算符。 下面语句都将提供一个代表String类的Type对象

 Type type1 = Type.GetType("System.String");
 Type type2=typeof(string);

下面是一个简单的事例代码

代码

using System;
using System.Reflection;

class Example
{
    static void Main()
    {
        Type t = typeof(String);

        MethodInfo substr = t.GetMethod("Substring", 
            new Type[] { typeof(int), typeof(int) });

   mp;nbsp;     Object result = 
            substr.Invoke("Hello, World!", new Object[] { 7, 5 });
        Console.WriteLine("{0} returned \"{1}\".", substr, result);
    }
}

/* This code example produces the following output:

System.String Substring(Int32, Int32) returned "World".
 */

Object类

   是.NET FrameWork中所有类的最终父类，它为所有其它的类提供了通用的方法。

   因为其它所有的类都要由Object派生而来，所以对Object的继承就不用再随声明。  

   在C#语言提供了关键字object，它可以作为Object类的实类的一个别名。可以在任何需要Object的表达式中使用它 

主要的方法

     Equals（）确定两个 Object 实例是否相等。

    Finalize() 允许 Object 在“垃圾回收”回收 Object 之前尝试释放资源并执行其他清理操作。

    GetHashCode() 用作特定类型的哈希函数。

    GetType() 获取当前实例的 Type。

    ReferenceEquals() 确定指定的 Object 实例是否是相同的实例。

    ToString() 返回表示当前 Object 的 String。

String类

    是一个非常重要，也非常特别的类。

     在.NET中String是不可改变对象，它封装了一串不能改变的字符。一旦创建了一个String对象并为它赋值，它就不可能再改变 

   这里大家可以参考:博客园 李会军的一篇 你真的了解.NET中的String吗？

Array类 

它类是公共语言运行时中所以数组的父类。是一个抽象的基类

它定义了对数组创建、查找、排序可修改操作的方法。

Console类

    它为控制台应用程序提供了访问标准的输入输出和错误流的方法和属性。

以下是一个控制台应用程序

    class Program
    {       static void Main(string[] args)
        {
            System.Console.WriteLine("hell World");
        }
    }

控制台应用程序也可以有返回值。 按照惯例，返回值为O表示程序正常结束，其它值（如-1）则表示有错误发生。

代码

 class Program
    {
        static int Main(string[] args)
        {
            int value = 0;
            if (args[0] == "a")
                value = 1;
            else if (args[0] == "b")
                value =2;
            return value;           
           
        }
    }

得到控制台的值

代码

 try
        {
            Process pro = new Process();
            //不显示窗口
            pro.StartInfo.CreateNoWindow = true ;
            pro.StartInfo.UseShellExecute = false;
            //要调用的控制台程序
            pro.StartInfo.FileName=@"C:\Documents and Settings\Administrator\My Documents\Visual Studio 2005\Projects\ConsoleApplication1\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe";
            //给控制台程序的参数传递值
            pro.StartInfo.Arguments = this.txtValue.Text.Trim();
            pro.Start();
            //调用控制台程序的返回值
            int i = pro.ExitCode;
           
            Response.Write(i.ToString());
        }
        catch (Exception ex)
        {
            Response.Write(ex.Message);
        }

Environment类

    提供有关当前环境和平台的信息以及操作它们的方法。无法继承此类。

  方法 

比较重要的属性

ommandLine  获取该进程的命令行。

   CurrentDirectory  获取或设置当前工作目录的完全限定路径。

   ExitCode  获取或设置进程的退出代码。

   HasShutdownStarted  获取一个值，该值指示是否公共语言运行库正在关闭或者当前的应用程序域正在卸载。

   MachineName  获取此本地计算机的 NetBIOS 名称。

     NewLine  获取为此环境定义的换行字符串。

     OSVersion  获取包含当前平台标识符和版本号的 OperatingSystem 对象。

    ProcessorCount  获取当前计算机上的处理器数。

   StackTrace  获取当前的堆栈跟踪信息。

   SystemDirectory  获取系统目录的完全限定路径。

     TickCount  获取系统启动后经过的毫秒数。

   UserDomainName  获取与当前用户关联的网络域名。

   UserInteractive  获取一个值，用以指示当前进程是否在用户交互模式中运行。

   UserName  获取当前已登录到 Windows 操作系统的人员的用户名。

     Version  获取一个 Version 对象，该对象描述公共语言运行库的主版本、次版本、内部版本和修订号。

   WorkingSet  获取映射到进程上下文的物理内存量。

GC类

        它可以通过编程使用一个静态的成员集合与垃圾回收器进行交互。 一般只有使用那托管代码是才需要用到System.GC类

     垃圾回收由以下步骤组成：

        1.  垃圾回收器搜索托管代码中引用的托管对象。

        2.  垃圾回收器尝试完成没有被引用的对象。

        3.  垃圾回收器释放没有被引用的对象并回收它们的内存。

Guid类

   表示全局唯一标识符 (GUID)。 这个类园子里讨论比较火热。

   大家可以看看以下面几篇文章

          关于GUID 

        使用Guid做主键和int做主键性能比较

ICloneable 接口

   支持克隆，即用与现有实例相同的值创建类的新实例。

柚子实现接口:

view source

print?

调用接口

view source

print?

Idisposable接口

      定义一种释放分配的资源的方法。

         1、 Finalize只释放非托管资源；

         2、 Dispose释放托管和非托管资源；

        3、 重复调用Finalize和Dispose是没有问题的；

        4、  GC.Collect();   强制对所有代进行即时垃圾回收。

        5、 Finalize和Dispose共享相同的资源释放策略，因此他们之间也是没有冲突的。

MSDN中关于这个接口的说明：

[ComVisible(true)]

public interface IDisposable{  

  // Methods    void Dispose();

}

1.[ComVisible(true)]：指示该托管类型对 COM 是可见的.

代码

//1.下面代码对Dispose方法做了封装，说明如何在使用托管和本机资源的类中实现 Dispose(bool) 的常规示例：
public class BaseResource : IDisposable
    {
        // 非托管资源
        private IntPtr handle;
        //托管资源
        private Component Components;
        // Dispose是否被调用
        private bool disposed = false;

        public BaseResource()
        {           
        }
      
        public void Dispose()
        {
            Dispose(true);           
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
          
            if (!this.disposed)         
            {              
                if (disposing)
                {
                    // 释放托管资源
                    Components.Dispose();
                }
                // 释放非托管资源，如果disposing为false,
                // 只有托管资源被释放
                CloseHandle(handle);
                handle = IntPtr.Zero;
                // 注意这里不是线程安全的
            }
            disposed = true;
        }

        // 析构函数只会在我们没有直接调用Dispose方法的时候调用
        // 派生类中不用在次提供析构函数
        ~BaseResource()
        {
            Dispose(false);
        }

        // 如果你已经调用了Dispose方法后在调用其他方法会抛出ObjectDisposedException
        public void DoSomething()
        {
            if (this.disposed)
            {
                throw new ObjectDisposedException();
            }
        }
    }

   
    public class MyResourceWrapper : BaseResource
    {
        // 托管资源
        private ManagedResource addedManaged;
        // 非托管资源
        private NativeResource addedNative;
        private bool disposed = false;
      
        public MyResourceWrapper()
        {          
        }

        protected override void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                try
                {
                    if (disposing)
                    {                       
                        addedManaged.Dispose();
                    }
                    
                    CloseHandle(addedNative);
                    this<;/span>.disposed = true;
                }
                finally
                {                  
                    base.Dispose(disposing);
                }
            }
        }
    }

DateTime结构

     表示时间上的一刻，通常以日期和当天的时间表示。 它有很多比较重要的方法和属性这里我就的列举了。

    它不能直接被赋值成 null，

     在SqlServer 2000中datetime 的空值即默认值为1900-01-01 00：00：00，

     C#中DateTime的空值是最小值0001-01-01 00：00：00，

    我建议是赋值成以下的方法
          DateTime s = default( DateTime );
       或是
         DateTime s = DateTime.MinValue;
      比较的时候直接
         if(s == DateTime.MinValue;)// 到了显示的时候，判断一下，如果是s == DateTime.MinValue 你就把这个字段赋值为空

Math

   为三角函数、对数函数和其他通用数学函数提供常数和静态方法。

MarshalByRefObject 类  

     允许在支持远程处理的应用程序中跨应用程序域边界访问对象。 

       Marshal 单词意思：vt. 整理；引领；编列 vi.排列,  

            应用程序域是一个操作系统进程中一个或多个应用程序所驻留的分区。

           同一应用程序域中的对象直接通信。不同应用程序域中的对象的通信方式有两种：  

               一种是跨应用程序域边界传输对象副本， 

                一种是使用代理交换消息。 

   下面的代码示例演示在另一个应用程序域中执行代码的最简单方法。该示例定义一个继承 MarshalByRefObject 的 Worker 类，该类的某个方法可用来显示在其中执行代码的应用程序域的名称。该示例在默认应用程序域和新的应用程序域中创建 Worker 的实例。

代码

using System;
using System.Reflection;
/// <summary>
/// 示例演示如何在另一个应用程序域中创建类的实例
/// </summary>
public class Worker : MarshalByRefObject
{
    public void PrintDomain()
    {
        Console.WriteLine("Object is executing in AppDomain \"{0}\"",
            AppDomain.CurrentDomain.FriendlyName);
    }
}

class Example
{
    public static void Main()
    {
        // Create an ordinary instance in the current AppDomain
        Worker localWorker = new Worker();
        localWorker.PrintDomain();

        // Create a new application domain, create an instance
        // of Worker in the application domain, and execute code
        // there.
        AppDomain ad = AppDomain.CreateDomain("New domain");
        Worker remoteWorker = (Worker) ad.CreateInstanceAndUnwrap(
            Assembly.GetExecutingAssembly().FullName,
            "Worker");
        remoteWorker.PrintDomain();
        Console.Read();
    }
}

/* This code produces output similar to the following:

Object is executing in AppDomain "source.exe"
Object is executing in AppDomain "New domain"
 */

下面的示例演示从 MarshalByRefObject 派生的、随后将在远程处理中使用的类。  

代码

using System;
using System.Runtime.Remoting;
using System.Security.Permissions;

public class SetObjectUriForMarshalTest  {

    class TestClass : MarshalByRefObject {
    }

    [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.RemotingConfiguration)]
    public static void Main()  {

        TestClass obj = new TestClass();   

        RemotingServices.SetObjectUriForMarshal(obj, "testUri");
        RemotingServices.Marshal(obj);

        Console.WriteLine(RemotingServices.GetObjectUri(obj));
    }
}

   Icomparable接口

      定义通用的比较方法，由值类型或类实现以创建类型特定的比较方法。

 CompareTo方法  比较当前实例与同一类型的另一对象。

代码

using System;

public class Temperature : IComparable
{
    // The temperature value
    protected double temperatureF;

    public int CompareTo(object obj) {
        if(obj is Temperature)
        {
            Temperature otherTemperature = (Temperature) obj;
            return this.temperatureF.CompareTo(otherTemperature.temperatureF);
        }
        else
        {
           throw new ArgumentException("object is not a Temperature");
        }   
    }

    public double Fahrenheit
    {
        get
        {
            return this.temperatureF;
        }
        set {
            this.temperatureF = value;
        }
    }

    public double Celsius
    {
        get
        {
            return (this.temperatureF - 32) * (5/9);
        }
        set
        {
            this.temperatureF = (value * 9/5) + 32;
        }
    }
}

public class CompareTemperatures
{
   public static void Main()
   {
      Temperature currentTemperature = new Temperature();
      currentTemperature.Fahrenheit = 55;

      Temperature yesterdayTemperature = new Temperature();
      yesterdayTemperature.Celsius = 14;

      // The following statement produces the output:
      //     Comparing 55 and 57.2: -1
      Console.WriteLine("Comparing {0} and {1}: {2}",
                        currentTemperature.Fahrenheit,
                        yesterdayTemperature.Fahrenheit,
                        currentTemperature.CompareTo(yesterdayTemperature));  
   }
}

IConvertible 接口 

   定义特定的方法，这些方法将实现引用或值类型的值转换为具有等效值的公共语言运行库类型。  

代码

using System;

namespace ConsoleApplication2
{

    /// Class that implements IConvertible
    class Complex : IConvertible
    {
        double    x;
        double    y;

        public Complex(double x, double y)
        {
            this.x = x;
            this.y = y;
        }

        public TypeCode GetTypeCode()
        {
            return TypeCode.Object;
        }

        bool IConvertible.ToBoolean(IFormatProvider provider)
        {
            if(    (x != 0.0) || (y != 0.0) )
                return true;
            else
                return false;
        }

        double GetDoubleValue()
        {
            return Math.Sqrt(x*x + y*y);
        }

        byte IConvertible.ToByte(IFormatProvider provider)
        {
            return Convert.ToByte(GetDoubleValue());
        }

        char IConvertible.ToChar(IFormatProvider provider)
        {
            return Convert.ToChar(GetDoubleValue());
        }

        DateTime IConvertible.ToDateTime(IFormatProvider provider)
        {
            return Convert.ToDateTime(GetDoubleValue());
        }

        decimal IConvertible.ToDecimal(IFormatProvider provider)
        {
            return Convert.ToDecimal(GetDoubleValue());
        }

        double IConvertible.ToDouble(IFormatProvider provider)
        {
            return GetDoubleValue();
        }

        short IConvertible.ToInt16(IFormatProvider provider)
        {
            return Convert.ToInt16(GetDoubleValue());
        }

        int IConvertible.ToInt32(IFormatProvider provider)
        {
            return Convert.ToInt32(GetDoubleValue());
        }

        long IConvertible.ToInt64(IFormatProvider provider)
        {
            return Convert.ToInt64(GetDoubleValue());
        }

        sbyte IConvertible.ToSByte(IFormatProvider provider)
        {
            return Convert.ToSByte(GetDoubleValue());
        }

        float IConvertible.ToSingle(IFormatProvider provider)
        {
            return Convert.ToSingle(GetDoubleValue());
        }

        string IConvertible.ToString(IFormatProvider provider)
        {
            return "( " + x.ToString() + " , " + y.ToString() + " )";
        }

        object IConvertible.ToType(Type conversionType, IFormatProvider provider)
        {
            return Convert.ChangeType(GetDoubleValue(),conversionType);
        }

        ushort IConvertible.ToUInt16(IFormatProvider provider)
        {
            return Convert.ToUInt16(GetDoubleValue());
        }

        uint IConvertible.ToUInt32(IFormatProvider provider)
        {
            return Convert.ToUInt32(GetDoubleValue());
        }

        ulong IConvertible.ToUInt64(IFormatProvider provider)
        {
            return Convert.ToUInt64(GetDoubleValue());
        }

    }

    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        static void Main(string[] args)
        {

            Complex        testComplex = new Complex(4,7);

            WriteObjectInfo(testComplex);
            WriteObjectInfo(Convert.ToBoolean(testComplex));
            WriteObjectInfo(Convert.ToDecimal(testComplex));
            WriteObjectInfo(Convert.ToString(testComplex));

        }

        static void WriteObjectInfo(object testObject)
        {
            TypeCode    typeCode = Type.GetTypeCode( testObject.GetType() );

            switch( typeCode )
            {
                case TypeCode.Boolean:
                    Console.WriteLine("Boolean: {0}", testObject);
                    break;

                case TypeCode.Double:
                    Console.WriteLine("Double: {0}", testObject);
                    break;
                               
                default:
                    Console.WriteLine("{0}: {1}", typeCode.ToString(), testObject);
                    break;
            }
        }
    }
}