[attribute(positional_parameters, name_parameter = value, ...)]  
element

[AttributeUsage(validon, AllowMultiple=allowmultiple, Inherited=inherited)]

[AttributeUsage(AttributeTargets.Class | ttributeTargets.Constructor | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = true)]

[Conditional(conditionalSymbol)]

[Conditional("DEBUG")]

[Conditional("Conditional")]
private void TestOne()
{
    //需要设置项目 属性 -> 生成 -> 条件编译符号 为：Conditional
    Console.WriteLine("this is test function one.");
}
private void TestTwo()
{
    //需要设置项目 属性 -> 生成 -> 条件编译符号 为：Conditional
    #if Conditional
    Console.WriteLine("this is test function two.");
    #endif
}

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = true)]
public class DeveloperInfoAttribute : Attribute { }

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Constructor | AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = true)]
public class DeveloperInfoAttribute : Attribute
{
    public DeveloperInfoAttribute(string name, string date)
    {
        DeveloperName = name;
        DeveloperDate = date;
    }
    public string DeveloperName { get; set; }
    public string DeveloperDate { get; set; }
    public string Describe { get; set; }
}

[DeveloperInfo("John", "2018-06-23", Describe = "this is a test class.")]
public class Business
{
    [DeveloperInfo("John", "2018-06-23", Describe = "this is a test property.")]
    public int TestProperty { get; set; }
    [DeveloperInfo("John", "2018-06-23", Describe = "this is a test method.")]
    public void TestMethod() { }
}

{
    object[] attr = typeof(Business).GetCustomAttributes(false);
    for (int i = 0; i < attr.Length; i++)
    {
        if (attr[i] is DeveloperInfoAttribute)
        {
            DeveloperInfoAttribute developer = attr[i] as DeveloperInfoAttribute;
            Console.WriteLine($"Name:{developer.DeveloperName} Date:{developer.DeveloperDate} Describe:{developer.Describe}");
        }
    }
}
{
    MethodInfo[] method = typeof(Business).GetMethods();
    for (int i = 0; i < method.Length; i++)
    {
        object[] attr = method[i].GetCustomAttributes(false);
        for (int j = 0; j < attr.Length; j++)
        {
            if (attr[j] is DeveloperInfoAttribute)
            {
                DeveloperInfoAttribute developer = attr[j] as DeveloperInfoAttribute;
                Console.WriteLine($"Name:{developer.DeveloperName} Date:{developer.DeveloperDate} Describe:{developer.Describe}");
            }
        }
    }
}
{
    PropertyInfo[] property = typeof(Business).GetProperties();
    for (int i = 0; i < property.Length; i++)
    {
        object[] attr = property[i].GetCustomAttributes(false);
        for (int j = 0; j < attr.Length; j++)
        {
            if (attr[j] is DeveloperInfoAttribute)
            {
                DeveloperInfoAttribute developer = attr[j] as DeveloperInfoAttribute;
                Console.WriteLine($"Name:{developer.DeveloperName} Date:{developer.DeveloperDate} Describe:{developer.Describe}");
            }
        }
    }
}

/// <summary>
/// 验证用户名是否合法：6-32位字母数字组成，首字母非数字
/// </summary>
/// <param name="name">用户名</param>
/// <returns>用户名是否符合系统设计规则要求</returns>
public static bool CheckUserName(string name)
{
    //验证长度限制
    if (name.Length < 6 || name.Length > 32)
        return false;

    for (int i = 0; i < name.Length; i++)
    {
        char ch = name[i];

        //必须是数字或大小写字母
        if (ch < 48 || ch > 57 && ch < 65 || ch > 95 && ch < 97)
            return false;

        //首字母不能是数字
        if (i == 0 && ch >= 48 && ch <= 57)
            return false;
    }
    return true;
}

/// <summary>
/// 验证用户名是否合法：6-32位字母数字组成，首字母非数字
/// </summary>
/// <param name="name">用户名</param>
/// <returns>用户名是否符合系统设计规则要求</returns>
public static bool CheckUserName(string name)
{
    return System.Text.RegularExpressions.Regex.IsMatch(name, "^[a-zA-Z][a-zA-Z0-9]{5,31}$");
}

/// <summary>
/// 验证邮箱并提取邮箱中的用户名
/// </summary>
/// <param name="email">邮箱</param>
/// <param name="name">用户名</param>
/// <returns>邮箱内容是否合法</returns>
public static bool CheckEmail(string email, out string name)
{
    name = null;
    System.Text.RegularExpressions.Match match 
        = System.Text.RegularExpressions.Regex.Match(email, @"^(\w+([-+.]\w+)*)@\w+([-.]\w+)*\.\w+([-.]\w+)*$");

    if (match.Success)
    {
        name = match.Groups[1].Value;
    }

    return match.Success;
}

string email = "hd2y@outlook.com";
if (CheckEmail(email, out string name))
{
    Console.WriteLine($"用户{name}邮箱验证合法：{email}");
}

public static IEnumerable<Title> FetchTitle(string title)
{
    foreach (System.Text.RegularExpressions.Match item
        in System.Text.RegularExpressions.Regex.Matches(title, @"<(?'TN'H[1-6])\s*(?'TP'[^<>]*)>(?'TC'.*?)</\k'TN'>"
           , System.Text.RegularExpressions.RegexOptions.IgnoreCase))
    {
        yield return new Title()
        {
            Name = item.Groups["TN"].Value,
            Property = item.Groups["TP"].Value,
            Content = item.Groups["TC"].Value
        };
    }
}

public class Title
{
    public string Name { get; set; }
    public string Property { get; set; }
    public string Content { get; set; }
}

string html = "<h1>h1</h1><h2>h2</h2><h3>h3</h3><h4>h4</h4><h5 style=\"color:red;\">h5</h5><h6>h6</h6>";
foreach (Title title in FetchTitle(html))
{
    Console.WriteLine($"获取到标题{title.Name} 内容：{title.Content} 属性：{title.Property}");
}

string[] dateInfo = Regex.Split("2019-04-01 00:00:00", @"\W");

string[] words = Regex.Split("ILoveYou", "(?!^)(?=[A-Z])");

string content = "";//内容略
content = Regex.Replace(content, @"(\u0002[0-7]{1})|((\u0003|\u0017)[0-9A-F]{2}\r\n)", "");

string content = "I love you very very very much.";//内容略
content = Regex.Replace(content, @"(?<word>[a-zA-Z]+)( \k<word>)+", "${word}");

string str = SecurityHelper.EncryptByMD5("测试");

string encryptStr = SecurityHelper.EncryptByDES("测试");
string str = SecurityHelper.DecryptByDES(encryptStr);

string encryptStr = SecurityHelper.EncryptByTDES("测试");
string str = SecurityHelper.DecryptByTDES(encryptStr);

// 生成公钥与私钥
var kv = SecurityHelper.GeneralRSAKeys();

string encryptStr = SecurityHelper.EncryptByRSAFromXmlString("测试", kv.Key);
string str = SecurityHelper.DecryptByRSAFromXmlString(encryptStr, kv.Value);

string encryptStr = SecurityHelper.MixUp("测试");
string str = SecurityHelper.ClearUp(encryptStr);

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace System
{
    /// <summary>
    /// 加密安全帮助类
    /// </summary>
    public class SecurityHelper
    {
        /// <summary>
        /// MD5加密字符串 (不可逆)
        /// </summary>
        /// <param name="text">需要加密的内容</param>
        /// <param name="key">加密密钥，防止简单密码被破解</param>
        /// <param name="binaryStyle">加密后结果内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>加密结果</returns>
        public static string EncryptByMD5(string text, string key = default(string), bool binaryStyle = true)
        {
            MD5 md5 = MD5.Create();
            byte[] bytes = md5.ComputeHash(Encoding.UTF8.GetBytes(text + key));
            return binaryStyle ? BitConverter.ToString(bytes) : Convert.ToBase64String(bytes);
        }

        /// <summary>
        /// DES加密字符串 (可逆)
        /// </summary>
        /// <param name="text">待加密的字符串</param>
        /// <param name="key">DES加密的私钥，必须是字节长度8位的字符串，否则会补0。</param>
        /// <param name="iv">DES加密偏移量，必须是>=8位长的字符串，否则会补0。</param>
        /// <param name="binaryStyle">加密后结果内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>加密后的字符串</returns>
        public static string EncryptByDES(string text, string key = "", string iv = "", bool binaryStyle = true)
        {
            List<byte> bKey = Encoding.UTF8.GetBytes(key).ToList();
            for (int i = bKey.Count; i < 8; i++)
            {
                bKey.Add((byte)i);
            }
            bKey = bKey.GetRange(0, 8);
            List<byte> bIV = Encoding.UTF8.GetBytes(iv).ToList();
            for (int i = bIV.Count; i < 8; i++)
            {
                bIV.Add((byte)i);
            }
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            using (MemoryStream ms = new MemoryStream())
            {
                byte[] inData = Encoding.UTF8.GetBytes(text);
                using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(bKey.ToArray(), bIV.ToArray()), CryptoStreamMode.Write))
                {
                    cs.Write(inData, 0, inData.Length);
                    cs.FlushFinalBlock();
                }
                return binaryStyle ? BitConverter.ToString(ms.ToArray()) : Convert.ToBase64String(ms.ToArray());
            }
        }

        /// <summary>
        /// DES解密字符串
        /// </summary>
        /// <param name="text">待解密的字符串</param>
        /// <param name="key">DES加密的私钥，必须是字节长度8位的字符串，否则会补0。</param>
        /// <param name="iv">DES加密偏移量，必须是>=8位长的字符串，否则会补0。</param>
        /// <param name="binaryStyle">解密内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>解密后的字符串</returns>
        public static string DecryptByDES(string text, string key = "", string iv = "", bool binaryStyle = true)
        {
            List<byte> bKey = Encoding.UTF8.GetBytes(key).ToList();
            for (int i = bKey.Count; i < 8; i++)
            {
                bKey.Add((byte)i);
            }
            bKey = bKey.GetRange(0, 8);
            List<byte> bIV = Encoding.UTF8.GetBytes(iv).ToList();
            for (int i = bIV.Count; i < 8; i++)
            {
                bIV.Add((byte)i);
            }
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            using (MemoryStream ms = new MemoryStream())
            {
                byte[] inData = binaryStyle ? text.GetBytesFromBitConverter() : Convert.FromBase64String(text);
                using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(bKey.ToArray(), bIV.ToArray()), CryptoStreamMode.Write))
                {
                    cs.Write(inData, 0, inData.Length);
                    cs.FlushFinalBlock();
                }
                return Encoding.UTF8.GetString(ms.ToArray());
            }
        }

        /// <summary>
        /// TDES加密字符串 (可逆)
        /// </summary>
        /// <param name="text">待加密的字符串</param>
        /// <param name="key">TDES加密的私钥，必须是字节长度24位的字符串，否则会自动补位。</param>
        /// <param name="iv">TDES加密偏移量，必须是字节长度>=8位的字符串，否则会自动补位。</param>
        /// <param name="binaryStyle">加密后结果内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>加密后的字符串</returns>
        public static string EncryptByTDES(string text, string key = "", string iv = "", bool binaryStyle = true)
        {
            List<byte> bKey = Encoding.UTF8.GetBytes(key).ToList();
            for (int i = bKey.Count; i < 24; i++)
            {
                bKey.Add((byte)i);
            }
            bKey = bKey.GetRange(0, 24);
            List<byte> bIV = Encoding.UTF8.GetBytes(iv).ToList();
            for (int i = bIV.Count; i < 8; i++)
            {
                bIV.Add((byte)i);
            }
            using (TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider())
            using (MemoryStream ms = new MemoryStream())
            {
                byte[] inData = Encoding.UTF8.GetBytes(text);
                using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(bKey.ToArray(), bIV.ToArray()), CryptoStreamMode.Write))
                {
                    cs.Write(inData, 0, inData.Length);
                    cs.FlushFinalBlock();
                }
                return binaryStyle ? BitConverter.ToString(ms.ToArray()) : Convert.ToBase64String(ms.ToArray());
            }
        }

        /// <summary>
        /// TDES解密字符串
        /// </summary>
        /// <param name="text">待解密的字符串</param>
        /// <param name="key">TDES加密的私钥，必须是字节长度24位的字符串，否则会自动补位。</param>
        /// <param name="iv">TDES加密偏移量，必须是字节长度>=8位的字符串，否则会自动补位。</param>
        /// <param name="binaryStyle">解密内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>解密后的字符串</returns>
        public static string DecryptByTDES(string text, string key = "", string iv = "", bool binaryStyle = true)
        {
            List<byte> bKey = Encoding.UTF8.GetBytes(key).ToList();
            for (int i = bKey.Count; i < 24; i++)
            {
                bKey.Add((byte)i);
            }
            bKey = bKey.GetRange(0, 24);
            List<byte> bIV = Encoding.UTF8.GetBytes(iv).ToList();
            for (int i = bIV.Count; i < 8; i++)
            {
                bIV.Add((byte)i);
            }
            using (TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider())
            using (MemoryStream ms = new MemoryStream())
            {
                byte[] inData = binaryStyle ? text.GetBytesFromBitConverter() : Convert.FromBase64String(text);
                using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(bKey.ToArray(), bIV.ToArray()), CryptoStreamMode.Write))
                {
                    cs.Write(inData, 0, inData.Length);
                    cs.FlushFinalBlock();
                }
                return Encoding.UTF8.GetString(ms.ToArray());
            }
        }

        /// <summary>
        /// 获取RSA加密公钥和私钥
        /// </summary>
        /// <returns>key:公钥 value:公钥和私钥</returns>
        public static KeyValuePair<string, string> GeneralRSAKeys()
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                return new KeyValuePair<string, string>(rsa.ToXmlString(false), rsa.ToXmlString(true));
            }
        }

        /// <summary>
        /// RSA加密字符串 (可逆)
        /// </summary>
        /// <param name="text">待加密的字符串</param>
        /// <param name="name">密钥容器的名称。</param>
        /// <param name="binaryStyle">加密后结果内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>加密后的字符串</returns>
        public static string EncryptByRSA(string text, string name, bool binaryStyle = true)
        {
            CspParameters param = new CspParameters() { KeyContainerName = name };
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(param))
            {
                byte[] plaindata = Encoding.UTF8.GetBytes(text);
                byte[] encryptdata = rsa.Encrypt(plaindata, false);
                return binaryStyle ? BitConverter.ToString(encryptdata) : Convert.ToBase64String(encryptdata);
            }
        }

        /// <summary>
        /// RSA解密字符串
        /// </summary>
        /// <param name="text">待解密的字符串</param>
        /// <param name="name">密钥容器的名称。</param>
        /// <param name="binaryStyle">解密内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>解密后的字符串</returns>
        public static string DecryptByRSA(string text, string name, bool binaryStyle = true)
        {
            CspParameters param = new CspParameters() { KeyContainerName = name };
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(param))
            {
                byte[] encryptdata = binaryStyle ? text.GetBytesFromBitConverter() : Convert.FromBase64String(text);
                byte[] decryptdata = rsa.Decrypt(encryptdata, false);
                return Encoding.UTF8.GetString(decryptdata);
            }
        }

        /// <summary>
        /// RSA加密字符串 (可逆)
        /// </summary>
        /// <param name="text">待加密的字符串</param>
        /// <param name="xml">含有密钥信息的xml字符串。</param>
        /// <param name="binaryStyle">加密后结果内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>加密后的字符串</returns>
        public static string EncryptByRSAFromXmlString(string text, string xml, bool binaryStyle = true)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(xml);
                byte[] plaindata = Encoding.UTF8.GetBytes(text);
                byte[] encryptdata = rsa.Encrypt(plaindata, false);
                return binaryStyle ? BitConverter.ToString(encryptdata) : Convert.ToBase64String(encryptdata);
            }
        }

        /// <summary>
        /// RSA解密字符串
        /// </summary>
        /// <param name="text">待解密的字符串</param>
        /// <param name="xml">含有密钥信息的xml字符串。</param>
        /// <param name="binaryStyle">解密内容样式。true:HEX格式加密结果，含“-”;Base64格式加密结果。</param>
        /// <returns>解密后的字符串</returns>
        public static string DecryptByRSAFromXmlString(string text, string xml, bool binaryStyle = true)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                rsa.FromXmlString(xml);
                byte[] encryptdata = binaryStyle ? text.GetBytesFromBitConverter() : Convert.FromBase64String(text);
                byte[] decryptdata = rsa.Decrypt(encryptdata, false);
                return Encoding.UTF8.GetString(decryptdata);
            }
        }

        /// <summary>
        /// 用时间简单混淆
        /// </summary>
        /// <param name="text">原始文本</param>
        /// <param name="timestampLength">混淆用时间戳长度</param>
        /// <returns>混淆后文本</returns>
        public static string MixUp(string text,int timestampLength = 36)
        {
            var timestamp = Guid.NewGuid().ToString();
            var count = text.Length + timestampLength;
            var sbd = new StringBuilder(count);
            int j = 0;
            int k = 0;
            for (int i = 0; i < count; i++)
            {
                if (j < timestampLength && k < text.Length)
                {
                    if (i % 2 == 0)
                    {
                        sbd.Append(text[k]);
                        k++;
                    }
                    else
                    {
                        sbd.Append(timestamp[j]);
                        j++;
                    }
                }
                else if (j >= timestampLength)
                {
                    sbd.Append(text[k]);
                    k++;
                }
                else if (k >= text.Length)
                {
                    break;
                }
            }

            return sbd.ToString();
        }

        /// <summary>
        /// 简单反混淆
        /// </summary>
        /// <param name="text">需要执行反混淆的文本</param>
        /// <param name="timestampLength">混淆用时间戳长度</param>
        /// <returns>原始文本</returns>
        public static string ClearUp(string text, int timestampLength = 36)
        {
            var sbd = new StringBuilder();
            int j = 0;
            for (int i = 0; i < text.Length; i++)
            {
                if (i % 2 == 0)
                {
                    sbd.Append(text[i]);
                }
                else
                {
                    j++;
                }

                if (j > timestampLength)
                {
                    sbd.Append(text.Substring(i));
                    break;
                }
            }

            return sbd.ToString();
        }
    }
}

public class MyClass
{
    static void Main()
    {
#if NET40
        WebClient _client = new WebClient();
#else
        HttpClient _client = new HttpClient();
#endif
    }
    //...
}

public class MyClass
{
#if !NET20
    public async void OpenAsync()
    {
        //...
    }
#endif
    //...
}

ThreadPool.QueueUserWorkItem(waitCallback);
ThreadPool.QueueUserWorkItem(waitCallback,Object);

Func<string, int, string> func = (name, age) =>
{
    Thread.Sleep(20000);
    return $"My name is {name}, I'm {age} years old.";
};
IAsyncResult asyncResult = func.BeginInvoke("Jane", 12, null, null);
//IAsyncResult.IsCompleted属性
while (!asyncResult.IsCompleted)
{
    Thread.Sleep(500);
    Console.WriteLine("*************WAITING*************");
}
////AsyncWaitHandle.WaitOne()方法
//while (!asyncResult.AsyncWaitHandle.WaitOne(200))
//{
//    Console.WriteLine("*************WAITING*************");
//}
////WaitHandle.WaitAny()方法
//WaitHandle[] waitHandleList1 = new WaitHandle[] { asyncResult.AsyncWaitHandle };
//while (WaitHandle.WaitAny(waitHandleList1, 200) > 0)
//{
//    Console.WriteLine("*************WAITING*************");
//}
////WaitHandle.WaitAll()方法
//WaitHandle[] waitHandleList2 = new WaitHandle[] { asyncResult.AsyncWaitHandle };
//while (WaitHandle.WaitAll(waitHandleList2, 200))
//{
//    Console.WriteLine("*************WAITING*************");
//}
Console.WriteLine(func.EndInvoke(asyncResult));

Func<string, int, string> func = (name, age) =>
{
    Thread.Sleep(2000);
    return $"My name is {name}, I'm {age} years old.";
};
IAsyncResult asyncResult = null;
AsyncCallback callback = (t) => 
{
    Console.WriteLine(func.EndInvoke(asyncResult));
};
asyncResult = func.BeginInvoke("Jane", 12, callback, null);

Thread thread=new Thread(new ThreadStart(method));//创建线程
thread.Start();                                   //启动线程

Thread thread=new Thread(new ParameterizedThreadStart(method));//创建线程
thread.Start(3);                                               //启动线程

Lock(expression)
{
    statement_block
}

private void btn_Test_Click(object sender, EventArgs e)
{
    //创建一个线程去执行这个方法:创建的线程默认是前台线程
    Thread thread = new Thread(new ThreadStart(Test));
    //Start方法标记这个线程就绪了，可以随时被执行，具体什么时候执行这个线程，由CPU决定
    //将线程设置为后台线程
    thread.IsBackground = true;
    thread.Start();
}
private void Test()
{
    for (int i = 0; i < 10000; i++)
    {               
        this.textBox1.Text = i.ToString();
    }
}

private void Form1_Load(object sender, EventArgs e)
{
       //取消跨线程的访问
       Control.CheckForIllegalCrossThreadCalls = false;
}

//定义回调
private delegate void DoSomeCallBack(Type para);
//声明回调
DoSomeCallBack doSomaCallBack;

doSomeCallBack = new DoSomeCallBack(DoSomeMethod);

Opt obj.Invoke(doSomeCallBack, arg);

object Control.Invoke(Delegate method, params object[] args);

private void DoSomeMethod(type para)
{
    //方法体
    Opt obj.someMethod(para);
}

namespace MultiThreadDemo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        //定义回调
        private delegate void setTextValueCallBack(int value);
        //声明回调
        private setTextValueCallBack setCallBack;
        private void btn_Test_Click(object sender, EventArgs e)
        {
            //实例化回调
            setCallBack = new setTextValueCallBack(SetValue);
            //创建一个线程去执行这个方法:创建的线程默认是前台线程
            Thread thread = new Thread(new ThreadStart(Test));
            //Start方法标记这个线程就绪了，可以随时被执行，具体什么时候执行这个线程，由CPU决定
            //将线程设置为后台线程
            thread.IsBackground = true;
            thread.Start();
        }
        private void Test()
        {
            for (int i = 0; i < 10000; i++)
            {               
                //使用回调
                textBox1.Invoke(setCallBack, i);
            }
        }
        /// <summary>
        /// 定义回调使用的方法
        /// </summary>
        /// <param name="value"></param>
        private void SetValue(int value)
        {
            this.textBox1.Text = value.ToString();
        }
    }
}

//序列化
using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.ReadWrite))
{
    BinaryFormatter binaryFormatter = new BinaryFormatter();//创建二进制序列化器
    binaryFormatter.Serialize(fileStream, ListPersons);
}
//反序列化
using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.ReadWrite))
{
    BinaryFormatter binaryFormatter = new BinaryFormatter();//创建二进制序列化器
    fileStream.Position = 0;//重置流位置
    List<Human> list = (List<Human>)binaryFormatter.Deserialize(fileStream);
    foreach (var item in list)
    {
        item.Action();
    }
}

//序列化
using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.ReadWrite))
{
    SoapFormatter soapFormatter = new SoapFormatter();//创建Soap序列化器
    soapFormatter.Serialize(fileStream, ListPersons.ToArray());//不支持泛型
}
//反序列化
using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.ReadWrite))
{
    SoapFormatter soapFormatter = new SoapFormatter();//创建Soap序列化器
    fileStream.Position = 0;//重置流位置
    List<Human> list = ((Human[])soapFormatter.Deserialize(fileStream)).ToList();//不支持泛型
    foreach (var item in list)
    {
        item.Action();
    }
}

//序列化
using (FileStream fileStream = new FileStream(path, FileMode.Create, FileAccess.ReadWrite))
{
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(List<Human>));//创建Xml序列化器 需要指定对象的类型
    xmlSerializer.Serialize(fileStream, ListPersons);
}
//反序列化
using (FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.ReadWrite))
{
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(List<Human>));//创建Xml序列化器 需要指定对象的类型
    fileStream.Position = 0;//重置流位置
    List<Human> list = (List<Human>)xmlSerializer.Deserialize(fileStream);
    foreach (var item in list)
    {
        item.Action();
    }
}

//JavaScriptSerializer序列化
{//内置
    JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();//创建Json序列化器
    string sJson = javaScriptSerializer.Serialize(ListPersons);
    File.WriteAllText(path1, sJson);
}
//JavaScriptSerializer反序列化
{
    string sText = File.ReadAllText(path1);
    JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();//创建Json序列化器
    List<Human> list = javaScriptSerializer.Deserialize<List<Human>>(sText);
    foreach (var item in list)
    {
        item.Action();
    }
}
//Newtonsoft.Json序列化
{//nuget
    string sJson = JsonConvert.SerializeObject(ListPersons);
    File.WriteAllText(path2, sJson);
}
//Newtonsoft.Json反序列化
{
    string sText = File.ReadAllText(path1);
    List<Human> list = JsonConvert.DeserializeObject<List<Human>>(sText);
    foreach (var item in list)
    {
        item.Action();
    }
}

Directory.CreateDirectory(path);//新增
File.Create(path);//新增或覆盖
File.AppendText(path);//新增或追加

//文件夹无法复制
File.Copy(path1, path2);

Directory.Move(path1, path2);
File.Move(path1, path2);

Directory.Delete(path, true);//第二个参数是指定是否删除目录内文件夹与文件 若不指定默认false 当为false文件夹内存在文件或文件夹会报错
File.Delete(path);

//新增或覆盖
using (FileStream fileStream = File.Create(path))
{
    string sText = "My name is Li Lei.";
    byte[] bytes = Encoding.Default.GetBytes(sText);
    fileStream.Write(bytes, 0, bytes.Length);
}
//新增或覆盖
using (FileStream fileStream = File.Create(path))
{
    using (StreamWriter streamWriter = new StreamWriter(fileStream))
    {
        string sText = "My name is Han Meimei.";
        streamWriter.Write(sText);
    }
}
//新增或追加
using (StreamWriter streamWriter = File.AppendText(path))
{
    string sText = "Nice to meet you.";
    byte[] bytes = Encoding.Default.GetBytes(sText);
    streamWriter.BaseStream.Write(bytes, 0, bytes.Length);
}
//新增或追加
using (StreamWriter streamWriter = File.AppendText(path))
{
    string sText = "Nice to meet you too.";
    streamWriter.Write(sText);
}

//一次读取
byte[] bytes = File.ReadAllBytes(path);
string sText = File.ReadAllText(path);
string[] aLineText = File.ReadAllLines(path);
IEnumerable<string> listLineText = File.ReadLines(path);
//大文件读取
using (FileStream fileStream = File.OpenRead(path))
{
    int length = 5;
    int result = 0;
    do
    {
        byte[] bytes = new byte[length];
        result = fileStream.Read(bytes, 0, 5);
        Console.WriteLine(Encoding.Default.GetString(bytes));
    } while (length == result);
}

DriveInfo[] aInfo = DriveInfo.GetDrives();
foreach (var info in aInfo)
{
    Console.WriteLine("----------------------------------------------------");
    Console.WriteLine("驱动器的名称：" + info.Name);
    Console.WriteLine("驱动器根目录：" + info.RootDirectory);
    Console.WriteLine("指示驱动器上可用空闲空间总量：" + info.AvailableFreeSpace);
    Console.WriteLine("文件系统名称：" + info.DriveFormat);
    Console.WriteLine("驱动器类型：" + info.DriveType);
    Console.WriteLine("获取一个指示驱动器是否已经准备好：" + info.IsReady);
    Console.WriteLine("获取驱动器上可用空闲空间总量：" + info.TotalFreeSpace);
    Console.WriteLine("获取驱动器空间总大小：" + info.TotalSize);
    Console.WriteLine("获取或设置驱动器的卷标：" + info.VolumeLabel);
}

object user = new
{
    Id = 1,
    Name = "Kangkang",
    Age = 12
};
//Console.WriteLine(user.Id);//无法获取 因为是object类型 该问题可以使用var关键字解决

var i = 1;

var user = new
{
    Id = 1,
    Name = "Kangkang",
    Age = 12
};
Console.WriteLine(user.Id);

{
    Console.WriteLine("**************** 匿名类型与var ****************");
    var user = new
    {
        Id = 1,
        Name = "Kangkang",
        Age = 12
    };
    //user.Name = "Xiaoming";//匿名类型属性只读
    Type type = user.GetType();
    var properties = type.GetProperties();
    foreach (var item in properties)
    {
        //只读属性反射也无法修改属性值
        //if (item.Name == "Name")
        //{
        //    item.SetValue(user, "Xiaoming", null);
        //}
        Console.WriteLine($"Property name is {item.Name}, value is {item.GetValue(user, null)}.");
    }
}

public static class ExtensionClass
{
    public static Human CheckHuman(this Human human)
    {
        human = human ?? new Human("Kangkang","China");
        human.Name = string.IsNullOrEmpty(human.Name) ? "EmptyName" : human.Name;
        human.Country = string.IsNullOrEmpty(human.Country) ? "China" : human.Country;
        return human;
    }
}

{
    Console.WriteLine("**************** 扩展方法的使用 ****************");
    Human human = null;
    human.CheckHuman().SayHi();
}

dynamic para = new System.Dynamic.ExpandoObject();
para.name = "Kangkang";
para.country = "China";
para.age = 12;

// 可以直接调用
Console.WriteLine(para.name);

// 可以重新赋值其他类型
para.name = 007;
Console.WriteLine(para.name);

// 可以理解其为一个特殊的字典 我们可以使用字典的方式遍历
foreach (var item in para as IDictionary<string, object>)
{
    Console.WriteLine($"{item.Key} {item.Value}");
}

// 调用不存在的“属性”编译时不会报错 但是运行时会报错
// Microsoft.CSharp.RuntimeBinder.RuntimeBinderException:“'System.Dynamic.ExpandoObject' does not contain a definition for 'hobby'”
Console.WriteLine(para.hobby);