public class Program
    {
        private const String item = "一(yi)個項目(mu)";
        private const String split = ";";

        static void Main(string[] args)
        {
            int number = 10000;
            // 使用(yong)StringBuilder
            CodeTimer.Time("使用StringBuilder: ", 1, () =>
            {
                UseStringBuilder(number);
            });
            // 不使用(yong)StringBuilder
            CodeTimer.Time("使(shi)用(yong)不(bu)使(shi)用(yong)StringBuilder: : ", 1, () =>
            {
                NotUseStringBuilder(number);
            });

            Console.ReadKey();
        }

        static String UseStringBuilder(int number)
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            for (int i = 0; i < number; i++)
            {
                sb.Append(item);
                sb.Append(split);
            }
            sb.Remove(sb.Length - 1, 1);
            return sb.ToString();
        }

        static String NotUseStringBuilder(int number)
        {
            String result = "";
            for (int i = 0; i < number; i++)
            {
                result += item;
                result += split;
            }
            return result;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string s = "我是(shi)字(zi)符串,I am a string!";
            // 字(zi)節數組 -> 字(zi)符串
            Byte[] utf8 = StringToByte(s, Encoding.UTF8);
            Byte[] gb2312 = StringToByte(s, Encoding.GetEncoding("GB2312"));
            Byte[] unicode = StringToByte(s, Encoding.Unicode);

            Console.WriteLine(utf8.Length);
            Console.WriteLine(gb2312.Length);
            Console.WriteLine(unicode.Length);
            // 字(zi)符串 -> 字(zi)符數組(zu)
            Console.WriteLine(ByteToString(utf8, Encoding.UTF8));
            Console.WriteLine(ByteToString(gb2312, Encoding.GetEncoding("GB2312")));
            Console.WriteLine(ByteToString(unicode, Encoding.Unicode));

            Console.ReadKey();
        }

        // 字符串 -> 字節數(shu)組
        static Byte[] StringToByte(string str, Encoding encoding)
        {
            if (string.IsNullOrEmpty(str))
            {
                return null;
            }
            return encoding.GetBytes(str);
        }

        // 字(zi)節數組 -> 字(zi)符(fu)串(chuan)
        static string ByteToString(Byte[] bytes, Encoding encoding)
        {
            if (bytes == null || bytes.Length <= 0)
            {
                return string.Empty;
            }

            return encoding.GetString(bytes);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            string test = "abcde ";
            // 生成UTF8字節數組(zu)
            byte[] bytes = Encoding.UTF8.GetBytes(test);
            // 轉換成Base64字符串
            string base64 = BytesToBase64(bytes);
            Console.WriteLine(base64);
            // 轉換(huan)回UTF8字(zi)節數組(zu)
            bytes = Base64ToBytes(base64);
            Console.WriteLine(Encoding.UTF8.GetString(bytes));

            Console.ReadKey();
        }

        // Bytes to Base64
        static string BytesToBase64(byte[] bytes)
        {
            try
            {
                return Convert.ToBase64String(bytes);
            }
            catch
            {
                return null;
            }
        }

        // Base64 to Bytes
        static Byte[] Base64ToBytes(string base64)
        {
            try
            {
                return Convert.FromBase64String(base64);
            }
            catch
            {
                return null;
            }
        }
    }

using System;
using System.Runtime.InteropServices;
using System.Security;

namespace UseSecureString
{
    class Program
    {
        static void Main(string[] args)
        {
            // 使用using語句(ju)保證Dispose方法被及時調用
            using (SecureString ss = new SecureString())
            {
                // 只能逐字符地操作SecureString對(dui)象(xiang)
                ss.AppendChar('e');
                ss.AppendChar('i');
                ss.AppendChar('s');
                ss.AppendChar('o');
                ss.AppendChar('n');
                ss.InsertAt(1, 'd');
                // 打印SecureStrign對(dui)象(xiang)
                PrintSecureString(ss);
            }

            Console.ReadKey();
        }

        // 打印SecureString對象
        public unsafe static void PrintSecureString(SecureString ss)
        {
            char* buffer = null;

            try
            {
                // 只(zhi)能逐(zhu)字(zi)符(fu)地訪問(wen)SecureString對象(xiang)
                buffer = (char*)Marshal.SecureStringToCoTaskMemUnicode(ss);
                for (int i = 0; *(buffer + i) != '\0'; i++)
                {
                    Console.Write(*(buffer + i));
                }
            }
            finally
            {
                // 釋放(fang)內(nei)存(cun)對象
                if (buffer != null)
                {
                    Marshal.ZeroFreeCoTaskMemUnicode((System.IntPtr)buffer);
                }
            }
        }
    }
}

    class Program
    {
        static void Main(string[] args)
        {
            // 01.兩個(ge)字(zi)符串對象，理論上引(yin)用(yong)應該不相等
            // 但是由(you)于字符(fu)串池機制(zhi)，二者指向了同一對象
            string a = "abcde";
            string b = "abcde";
            Console.WriteLine(object.ReferenceEquals(a, b));
            // 02.由于編譯器的優化，所以下(xia)面這個c仍(reng)然指向(xiang)了同一(yi)引(yin)用地址
            string c = "a" + "bc" + "de";
            Console.WriteLine(object.ReferenceEquals(a, c));
            // 03.顯示(shi)地使(shi)用new來分(fen)配內存(cun)，這時候字符(fu)串池不(bu)起(qi)作用
            char[] arr = { 'a', 'b', 'c', 'd', 'e' };
            string d = new string(arr);
            Console.WriteLine(object.ReferenceEquals(a, d));

            Console.ReadKey();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            String[] times ={"2008-1-1",
                            "2008-1-2",
                            "2008-1-3"};

            // 使用不(bu)同的方法轉換(huan)
            DateTime[] result1 = OneByOne(times);
            DateTime[] result2 = ConvertAll(times);

            // 結果是(shi)相同的
            Console.WriteLine("手動逐(zhu)個轉換的方法：");
            foreach (DateTime item in result1)
            {
                Console.WriteLine(item.ToString("yyyy-MM-dd"));
            }
            Console.WriteLine("使用Array.Convert方法：");
            foreach (DateTime item2 in result2)
            {
                Console.WriteLine(item2.ToString("yyyy-MM-dd"));
            }

            Console.ReadKey();
        }

        // 逐(zhu)個(ge)手動轉換(huan)
        private static DateTime[] OneByOne(String[] times)
        {
            List<DateTime> result = new List<DateTime>();
            foreach (String item in times)
            {
                result.Add(DateTime.Parse(item));
            }
            return result.ToArray();
        }

        // 使用Array.ConertAll方(fang)法
        private static DateTime[] ConvertAll(String[] times)
        {
            return Array.ConvertAll(times,
                new Converter<String, DateTime>
                (DateTimeToString));
        }

        private static DateTime DateTimeToString(String time)
        {
            return DateTime.Parse(time);
        }
    }

    public class ClassT1<T> where T : Exception
    {
        private T myException;
        public ClassT1(T t)
        {
            myException = t;
        }
        public override string ToString()
        {
            // 主要約束(shu)保(bao)證了myException擁有source成員
            return myException.Source;
        }
    }

    public class ClassT2<T> where T : class
    {
        private T myT;
        public void Clear()
        {
            // T是引用類型，可以置null
            myT = null;
        }
    }

    public class ClassT3<T> where T : struct
    {
        private T myT;
        public override string ToString()
        {
            // T是(shi)值類型，不會(hui)發生NullReferenceException異(yi)常
            return myT.ToString();
        }
    }

    public class ClassT3<T> where T : struct, IComparable
    {
        ......      
    }

    class Program
    {
        private const int bufferlength = 1024;

        static void Main(string[] args)
        {
            //創建一個文件，并寫入(ru)內容
            string filename = @"C:\TestStream.txt";
            string filecontent = GetTestString();

            try
            {
                if (File.Exists(filename))
                {
                    File.Delete(filename);
                }

                // 創(chuang)建文件(jian)并寫入內容
                using (FileStream fs = new FileStream(filename, FileMode.Create))
                {
                    Byte[] bytes = Encoding.UTF8.GetBytes(filecontent);
                    fs.Write(bytes, 0, bytes.Length);
                }

                // 讀取文件并打(da)印出來(lai)
                using (FileStream fs = new FileStream(filename, FileMode.Open))
                {
                    Byte[] bytes = new Byte[bufferlength];
                    UTF8Encoding encoding = new UTF8Encoding(true);
                    while (fs.Read(bytes, 0, bytes.Length) > 0)
                    {
                        Console.WriteLine(encoding.GetString(bytes));
                    }
                }
                // 循環(huan)分(fen)批(pi)讀取打印
                //using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
                //{
                //    Byte[] bytes = new Byte[bufferlength];
                //    int bytesRead;
                //    do
                //    {
                //        bytesRead = fs.Read(bytes, 0, bufferlength);
                //        Console.WriteLine(Encoding.UTF8.GetString(bytes, 0, bytesRead));
                //    } while (bytesRead > 0);
                //}
            }
            catch (IOException ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }

        // 01.取(qu)得(de)測試(shi)數據
        static string GetTestString()
        {
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < 10; i++)
            {
                builder.Append("我是測試數據\r\n");
                builder.Append("我是長江(jiang)" + (i + 1) + "號(hao)\r\n");
            }
            return builder.ToString();
        }
    }

    class Program
    {
        private const int BufferSize = 10240; // 10 KB
        public static void Main(string[] args)
        {
            string fileName = @"G:\My Musics\BlueMoves.mp3"; // Source 4.4 MB
            string copyName = @"C:\BlueMoves-Copy.mp3"; // Destination 4.4 MB
            using (Stream source = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                using (Stream target = new FileStream(copyName, FileMode.Create, FileAccess.Write))
                {
                    byte[] buffer = new byte[BufferSize];
                    int bytesRead;
                    do
                    {
                        // 從(cong)源文件中讀取指定的10K長度(du)到緩存中
                        bytesRead = source.Read(buffer, 0, BufferSize);
                        // 從緩存中寫(xie)入(ru)已讀取到的長(chang)度(du)到目標文件中
                        target.Write(buffer, 0, bytesRead);
                    } while (bytesRead > 0);
                }
            }
            Console.ReadKey();
        }
    }

    class Program
    {
        // 緩存數組的長度
        private const int bufferSize = 1024;

        static void Main(string[] args)
        {
            string test = GetTestString();
            byte[] original = Encoding.UTF8.GetBytes(test);
            byte[] compressed = null;
            byte[] decompressed = null;
            Console.WriteLine("數據的原始長度是:{0}", original.LongLength);
            // 1.進(jin)行壓縮(suo)
            // 1.1 壓縮進(jin)入內存流
            using (MemoryStream target = new MemoryStream())
            {
                using (GZipStream gzs = new GZipStream(target, CompressionMode.Compress, true))
                {
                    // 1.2 將(jiang)數據寫入壓縮流
                    WriteAllBytes(gzs, original, bufferSize);
                }
                compressed = target.ToArray();
                Console.WriteLine("壓縮后(hou)的數據長(chang)度:{0}", compressed.LongLength);
            }
            // 2.進行解壓縮
            // 2.1 將解壓(ya)后的數據寫入(ru)內存流(liu)
            using (MemoryStream source = new MemoryStream(compressed))
            {
                using (GZipStream gzs = new GZipStream(source, CompressionMode.Decompress, true))
                {
                    // 2.2 從壓縮流中讀取所有數據
                    decompressed = ReadAllBytes(gzs, bufferSize);
                }
                Console.WriteLine("解壓后的數據(ju)長度:{0}", decompressed.LongLength);
                Console.WriteLine("解壓前后是否相等:{0}", test.Equals(Encoding.UTF8.GetString(decompressed)));
            }
            Console.ReadKey();
        }

        // 01.取得測(ce)試(shi)數據(ju)
        static string GetTestString()
        {
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < 10; i++)
            {
                builder.Append("我是(shi)測試數據\r\n");
                builder.Append("我(wo)是(shi)長江" + (i + 1) + "號\r\n");
            }
            return builder.ToString();
        }

        // 02.從一個(ge)流總讀取所有字節(jie)
        static Byte[] ReadAllBytes(Stream stream, int bufferlength)
        {
            Byte[] buffer = new Byte[bufferlength];
            List<Byte> result = new List<Byte>();
            int read;
            while ((read = stream.Read(buffer, 0, bufferlength)) > 0)
            {
                if (read < bufferlength)
                {
                    Byte[] temp = new Byte[read];
                    Array.Copy(buffer, temp, read);
                    result.AddRange(temp);
                }
                else
                {
                    result.AddRange(buffer);
                }
            }
            return result.ToArray();
        }

        // 03.把字節寫(xie)入一個流(liu)中(zhong)
        static void WriteAllBytes(Stream stream, Byte[] data, int bufferlength)
        {
            Byte[] buffer = new Byte[bufferlength];
            for (long i = 0; i < data.LongLength; i += bufferlength)
            {
                int length = bufferlength;
                if (i + bufferlength > data.LongLength)
                {
                    length = (int)(data.LongLength - i);
                }
                Array.Copy(data, i, buffer, 0, length);
                stream.Write(buffer, 0, length);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Person obj = new Person(26, "Edison Chou");
            Console.WriteLine("初始狀(zhuang)態(tai)：");
            Console.WriteLine(obj);

            // 序列(lie)化對象
            byte[] data = Serialize(obj);
            // 反序列化對(dui)象
            Person newObj = DeSerialize(data);

            Console.WriteLine("經過序(xu)列化(hua)和反(fan)序(xu)列化(hua)后(hou)：");
            Console.WriteLine(newObj);

            Console.ReadKey();
        }

        // 序列化(hua)對象
        static byte[] Serialize(Person p)
        {
            // 使(shi)用二進制序列化
            IFormatter formatter = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                formatter.Serialize(ms, p);
                return ms.ToArray();
            }
        }

        // 反序列(lie)化對象
        static Person DeSerialize(byte[] data)
        {
            // 使用二進制反序列化
            IFormatter formatter = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream(data))
            {
                Person p = formatter.Deserialize(ms) as Person;
                return p;
            }
        }
    }

    [Serializable]
    public class Person
    {
        // 私(si)有成員無法被XmlSerializer序(xu)列化
        private int _number;
        // 使用(yong)NonSerialized特性標(biao)記此成員不可被BinaryFormatter和(he)SoapFormatter序列化
        [NonSerialized]
        public string _name;
        // 使用XmlIgnore特性標記此(ci)成員不可悲XmlSerializer序(xu)列化(hua)
        [XmlIgnore]
        public string _univeristy;

        public Person()
        {
        }

        public Person(int i, string s, string u)
        {
            this._number = i;
            this._name = s;
            this._univeristy = u;
        }

        public override string ToString()
        {
            string result = string.Format("學號是：{0}，姓名是：{1}，大學是：{2}", _number, _name, _univeristy);
            return result;
        }
    }

    #region 01.SoapFormatter
    // 序列化對(dui)象(xiang)-SoapFormatter
    static byte[] SoapFormatterSerialize(Person p)
    {
        // 使用(yong)Soap協議序列(lie)化(hua)
        IFormatter formatter = new SoapFormatter();
        using (MemoryStream ms = new MemoryStream())
        {
            formatter.Serialize(ms, p);
            return ms.ToArray();
        }
    }

    // 反序列化對象-SoapFormatter
    static Person SoapFormatterDeSerialize(byte[] data)
    {
        // 使用Soap協(xie)議(yi)反序(xu)列化
        IFormatter formatter = new SoapFormatter();
        using (MemoryStream ms = new MemoryStream(data))
        {
            Person p = formatter.Deserialize(ms) as Person;
            return p;
        }
    } 
    #endregion

    #region 02.XmlSerializer
    // 序列化對象(xiang)-XmlSerializer
    static byte[] XmlSerializerSerialize(Person p)
    {
        // 使用XML規(gui)范(fan)序列化
        XmlSerializer serializer = new XmlSerializer(typeof(Person));
        using (MemoryStream ms = new MemoryStream())
        {
            serializer.Serialize(ms, p);
            return ms.ToArray();
        }
    }

    // 反序列(lie)化對象-XmlSerializer
    static Person XmlSerializerDeSerialize(byte[] data)
    {
        // 使(shi)用(yong)XML規范反序列化
        XmlSerializer serializer = new XmlSerializer(typeof(Person));
        using (MemoryStream ms = new MemoryStream(data))
        {
            Person p = serializer.Deserialize(ms) as Person;
            return p;
        }
    } 
    #endregion

    static void Main(string[] args)
    {
        Person obj = new Person(26, "Edison Chou", "CUIT");
        Console.WriteLine("原(yuan)始對象為：");
        Console.WriteLine(obj.ToString());

        // 使(shi)用(yong)SoapFormatter序列化對象
        byte[] data1 = SoapFormatterSerialize(obj);
        Console.WriteLine("SoapFormatter序列(lie)化后(hou)：");
        Console.WriteLine(Encoding.UTF8.GetString(data1));
        Console.WriteLine();
        // 使用XmlSerializer序列化對(dui)象
        byte[] data2 = XmlSerializerSerialize(obj);
        Console.WriteLine("XmlSerializer序列化后：");
        Console.WriteLine(Encoding.UTF8.GetString(data2));

        Console.ReadKey();
    }

    [Serializable]
    public class MyObject : ISerializable
    {
        private int _number;
        [NonSerialized]
        private string _name;

        public MyObject(int num, string name)
        {
            this._number = num;
            this._name = name;
        }

        public override string ToString()
        {
            return string.Format("整數是：{0}\r\n字符(fu)串(chuan)是：{1}", _number, _name);
        }

        // 實現自定義的序(xu)列化(hua)
        protected MyObject(SerializationInfo info, StreamingContext context)
        {
            // 從(cong)SerializationInfo對象（類似于一個HashTable）中讀取內容
            this._number = info.GetInt32("MyObjectInt");
            this._name = info.GetString("MyObjectString");
        }

        // 實現自(zi)定義的反序(xu)列化
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            // 將成(cheng)員對象寫(xie)入SerializationInfo對象中
            info.AddValue("MyObjectInt", this._number);
            info.AddValue("MyObjectString", this._name);
        }
    }

    [Serializable]
    public class MyObjectSon : MyObject
    {
        // 自己添加的成(cheng)員
        private string _sonName;

        public MyObjectSon(int num, string name)
            : base(num, name)
        {
            this._sonName = name;
        }

        public override string ToString()
        {
            return string.Format("{0}\r\n之類字符串是：{1}", base.ToString(), this._sonName);
        }

        // 實(shi)現自定義反序列化，只負責子類添加的(de)成(cheng)員
        protected MyObjectSon(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            this._sonName = info.GetString("MyObjectSonString");
        }

        // 實現自定義序列(lie)化(hua)，只負責子類添加的成員(yuan)
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            base.GetObjectData(info, context);
            info.AddValue("MyObjectSonString", this._sonName);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyObjectSon obj = new MyObjectSon(10086, "Edison Chou");
            Console.WriteLine("初始對象為：");
            Console.WriteLine(obj.ToString());
            // 序列(lie)化
            byte[] data = Serialize(obj);
            Console.WriteLine("經過序(xu)列(lie)(lie)化(hua)與(yu)反序(xu)列(lie)(lie)化(hua)之后(hou)：");
            Console.WriteLine(DeSerialize(data));

            Console.ReadKey();
        }

        // 序(xu)列(lie)化對象(xiang)-BinaryFormatter
        static byte[] Serialize(MyObject p)
        {
            // 使用(yong)二(er)進(jin)制序(xu)列化(hua)
            IFormatter formatter = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream())
            {
                formatter.Serialize(ms, p);
                return ms.ToArray();
            }
        }

        // 反序列化對象-BinaryFormatter
        static MyObject DeSerialize(byte[] data)
        {
            // 使用二進制反(fan)序列化
            IFormatter formatter = new BinaryFormatter();
            using (MemoryStream ms = new MemoryStream(data))
            {
                MyObject p = formatter.Deserialize(ms) as MyObject;
                return p;
            }
        }
    }