.net程序员应该掌握的常用类库 (三)

 .net程序员应该掌握的常用类库

.net程序员应该掌握的常用类库 (一)

.net程序员应该掌握的常用类库 (二)

 

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;
            }
        }
    }
}