一些基础知识

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml.Serialization;


namespace 基础知识
{
    class Program
    {
        static void Main(string[] args)
        {
        }
        * 基础知识#region * 基础知识
        /**//*
         内存模型：
         值类型：线程的堆栈上（栈）；从高位向低位压进；先进先出（回收）
         引用类型：逆向递归搜索所有继承直至System.Object，然后空间加和在托管堆上分配；从低位压进；先进后出
         引用类型已经在托管堆所以无所谓装拆箱
         box过程：
         * 在托管堆分配内存 容量=值类型字段大小 + 额外的开销（方法表指针和SyncBlockIndex）
         * 将值类型的字段copy到托管堆新分配的内存上
         * 将托管堆的对象地址返回给新的引用类型
         unbox过程：
         * 检查要拆箱的实例：null则NullReferfenceException；类型不则InvalidCastException
         * 返回值类型字段部分的地址的指针；到此是unbox，而unbox.any才会执行字段copy（.net默认）
         * 把字段copy回线程的堆栈上（栈）
         
         垃圾回收：
         * 标记和清除收集算法：比如A a = new A()建立了一个引用对象a，GC会以a为根递归所有引用，制成可达对象图表，凡不可达的对象，都会在下次GC时回收；
         * 托管资源：由GC按“代”管理，刚创建的为0代，也从0代开始GC，存活的变成1代；
         * 非托管资源：Finalize由GC自行调用，执行时间和执行顺序都无法控制，并且会“误伤”；
 
         参数传递：参数分值类型和引用类型2种，传递方法有按值传递和按引用传递2种，所以共4种组合，按这思路理解：引用类型的值是引用地址；
         * Params条件：一维数组；在参数列表最后；且只能有一个；可用object型数组以支持各种参数

         String是特殊的引用类型
         * 驻留机制——在内存中创建后被注册到一个由CLR维护的hashtable，各种操作只是创建新的临时string而不影响本身（没有注册到hashtable，所以不能被访问）。
         * 驻留是进程级的，可以跨程序域和进程访问
         * 参数传递的值，但这个值本身是引用（的key）
         * 恒定性造成动态创建效率低，所以引入SB
         */
        #endregion

        *#region * 
        #endregion

        * 枚举是引用类型并且是个抽象类,枚举提供了处理相关联的常数集的快捷途径，是强类型的分类结构#region * 枚举是引用类型并且是个抽象类,枚举提供了处理相关联的常数集的快捷途径，是强类型的分类结构
        enum myEnum
        {
            a,
            b = 7,//内存模型上是常数集合，从0开始，逐个加1，你也可以如下指定，所以现在是（0789）
            c,
            d
        }
        static void Enum_test()
        {
            //2种遍历方法
            foreach (string s in Enum.GetNames(typeof(myEnum)))
            {
                Console.WriteLine(s.ToString());
            }
            foreach (myEnum s in Enum.GetValues(typeof(myEnum)))
            {
                Console.WriteLine(s.ToString());
            }
            //判段元素是否存在，避免异常
            if (Enum.IsDefined(typeof(myEnum), "c"))
            {
                Console.WriteLine(myEnum.c.ToString());
            }
        }
        #endregion

        * 序列化的目的是保存对象的状态，以便可以在需要时重新创建对象#region * 序列化的目的是保存对象的状态，以便可以在需要时重新创建对象
        static void Serialize_test()
        {
            //先实例化一个类备用
            UserInfo ui = new UserInfo();
            ui.Name = "hb";
            ui.Age = 27;

            FileStream fs = new FileStream("Serializedfile", FileMode.Create);

            //二进制序列化是完全深序列化。
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter Serializer = new BinaryFormatter();

            //xml序列化是浅序列化，不能完成方法、索引器、私有和只读字段的序列化。用于webservice等
            //System.Xml.Serialization.XmlSerializer Serializer = new XmlSerializer(typeof(UserInfo));

            //soap(Simple Object Access Protocol是xml的一种编码格式)
            //XmlTypeMapping xtm = (new SoapReflectionImporter().ImportTypeMapping(typeof(UserInfo)));
            //System.Xml.Serialization.XmlSerializer Serializer = new XmlSerializer(xtm);

            Serializer.Serialize(fs, ui);
            fs.Close();

            fs = new FileStream("Serializedfile", FileMode.Open, FileAccess.Read, FileShare.Read);
            //反序列化
            UserInfo ui2 = Serializer.Deserialize(fs) as UserInfo;
            fs.Close();

            Console.WriteLine(ui2.Name + ui2.Age);
        }
        #endregion

        *#region * 
        #endregion

    }
    [Serializable]
    public class UserInfo
    {
        public string Name;
        [XmlElement(ElementName = "MyAge")]//改变xml序列化的字段名
        [NonSerialized]//仅二进制序列化时可以防止被序列化
        public int Age;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
//Linq
using System.Data.Linq;
using System.Data.Linq.Mapping;


namespace 基础知识
{
    class Program
    {        
        private static string ConStr = @"Data Source=.\SQLEXPRESS;AttachDbFilename=D:\学习笔记\基础知识\DB.mdf;Integrated Security=True;User Instance=True";
        static void Main(string[] args)
        {
            DataSetTest();
            //LinqTest();
            Console.ReadLine();
        }
        #region * ADO.Net
        //执行SQL语句
        public static void DoSqlCmd(string sCmdText, Dictionary<string, object> dPar)
        {
            using (SqlConnection con = new SqlConnection(ConStr))
            {
                con.Open();
                using (SqlCommand cmd = new SqlCommand(sCmdText, con))
                {
                    foreach (KeyValuePair<string, object> kvp in dPar)
                    {
                        cmd.Parameters.AddWithValue(kvp.Key, kvp.Value);
                    }
                    cmd.ExecuteNonQuery();
                }
            }
        }
        //
        static void DataSetTest()
        {
            //DataSet离线数据库模型模型
            DataSet ds = new DataSet();
            DataTable dt = new DataTable();

            ds.Tables.Add(dt);
            DataColumn dc1 = new DataColumn("UserID", typeof(System.Guid));
            DataColumn dc2 = new DataColumn("UserName", typeof(System.String));
            dt.Columns.Add(dc1);
            dt.Columns.Add(dc2);
            dt.PrimaryKey = new DataColumn[] { dc1 };
            DataRow dr = dt.NewRow();
            dr["UserID"] = Guid.NewGuid();
            dr["UserName"] = "a";
            dt.Rows.Add(dr);

            dt.Reset();//重置
            SqlDataAdapter sda = new SqlDataAdapter("select * from tbUserInfo", ConStr);
            sda.Fill(dt);
            SqlCommand cmd = new SqlCommand("insert into tbUserInfo (UserName, Pwd, AddTime) values (@UserName, @Pwd, @AddTime)");
            cmd.Parameters.AddWithValue("@UserName", "ff");
            cmd.Parameters.AddWithValue("@Pwd", "ff");
            cmd.Parameters.AddWithValue("@AddTime", DateTime.Now);
            sda.InsertCommand = cmd;

            SqlCommandBuilder scb = new SqlCommandBuilder(sda);
            sda.Update(dt);

            //列遍历
            foreach (DataColumn dc in dt.Columns)
            {
                Console.WriteLine(dc.ColumnName);
            }
            //行遍历
            foreach (DataRow dr1 in dt.Rows)
            {
                Console.WriteLine(dr1["UserID"] + " " + dr1["UserName"]);
            }
        }
        #endregion

        #region * Linq to SQL为一个ORM框架(对象，关系，映射)
        static void LinqTest()
        {
            DataContext dc = new DataContext(ConStr);
            dc.Log = Console.Out;
            Table<tbUserInfo> Users = dc.GetTable<tbUserInfo>();//查询所有记录
            //var Users = from user in dc.GetTable<tbUserInfo>() where user.UserName == "a" select user;
            
            //添加
            tbUserInfo u1 = new tbUserInfo();
            u1.UserName = "d";
            u1.Pwd = "d";
            u1.AddTime = DateTime.Now;
            u1.Note = "d";
            Users.InsertOnSubmit(u1);
            
            //先查出来再操作
            var u2 = (from user in Users where user.UserName == "d" select user).First();
            u2.Pwd = "test";//更新
            Users.DeleteOnSubmit(u2); //删除
           
            dc.SubmitChanges();//提交更改，类似Dataset
            foreach (var user in Users)
            {
                Console.WriteLine(user.UserID + "****" + user.UserName + user.Pwd + user.AddTime);
            }
        }
        #endregion
    }
    //Linq采用侵入式映射
    [Table(Name = "tbUserInfo")]
    public class tbUserInfo
    {
        [Column(IsPrimaryKey = true, IsDbGenerated = true)]
        public Guid UserID { get; set; }
        [Column]
        public string UserName { get; set; }
        [Column]
        public string Pwd { get; set; }
        [Column]
        public DateTime AddTime { get; set; }
        [Column]
        public string Note { get; set; }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization;

namespace 基础知识
{
    class Program
    {
        static void Main(string[] args)
        {
            Son_Class son = new Son_Class();
            Console.WriteLine(Son_Class.str);
            son.virtualMethod();
            son.abstractMethod();

            myStruct s1 = new myStruct();//直接调用构造函数，推荐
            s1.Call();
            myStruct s2;//这种方式必须要给所有参数赋值后才能调用内部方法
            s2.Name = "hb";
            s2.Call();

            TypeChange();
            enmu_Test();

            Delegate_Test();
            Console.Read();
        }

        static void TypeChange()
        {
            string str = new string(new char[]{'1','2'});//提倡这样干以充分利用其构造函数，呵呵
            int i = int.Parse(str);//各种基类型都提供了parse这个对string转换直通车
            int j = Convert.ToInt32(str);//Convert用于各种基类型的强制转换
            Console.WriteLine(i.GetType());
            Son_Class son = new Son_Class();
            if (son is Father_Class) 
            {
                //is用于类型判断，无异常；as先判断然后转换（失败会NullReferenceException）
                Father_Class father = son as Father_Class;
                father = (Son_Class)son;
            }
        }
        /*
         * const = ststic readonly：是编译时常量，只能为基本类型（int，string等）且必需赋初值；readonly：运行时常量，任意类型
         * 值类型深拷贝，引用类型用memberwithclone方法浅拷贝（只copy引用地址）
         */
        enum Enum_famliy
        { 
            farther = 5,//enum是引用类型，是个抽象类，默认从0开始的常数集合
            mother,
            me
        }
        static void enmu_Test()
        {
            Enum_famliy myFamliy = new Enum_famliy();
            
            foreach(string item in Enum.GetNames(myFamliy.GetType()))
            {Console.WriteLine(item);}//
            foreach (Enum_famliy item in Enum.GetValues(myFamliy.GetType()))
            { Console.WriteLine(item.ToString("D")); }//获取整数
            
        }

        delegate void CountDelegate(int x, int y);//第一步：声明委托
        public static void Sum(int x, int y) { Console.WriteLine(x + y); }//第二步：创建关联的方法，同参同返回值
        public static void Subtract(int x, int y) { Console.WriteLine(x - y); }
        private static CountDelegate Sum_Delegate;//第三步：定义委托类型变量
        static void Delegate_Test()
        {
            Sum_Delegate = new CountDelegate(Subtract);
            Sum_Delegate += new CountDelegate(Sum);//委托链
            Sum_Delegate(2, 3);
            //匿名方法：不知道委托类型变量时只能用匿名方法
            //CountDelegate Sum = delegate(int x, int y)//
            //{ Console.WriteLine(x + y); };
            //Sum(1, 2);
        }
    }
    abstract class Father_Class //抽象类才能有抽象方法
    {
        public static string str = "static = share,由类访问并被类的所有实例共享，避免冗余，如sqlconstr";
        public virtual void virtualMethod()
        { Console.WriteLine("接口用于定义类的能力；抽象类是能提供部分实现的接口，多用于定义属性，如版本控制"); }
        public abstract void abstractMethod();
    }
    class Son_Class : Father_Class
    {
        public override void virtualMethod()
        { Console.WriteLine("virtualMethod可以自己实现，也可以由子类override"); }
        public override void abstractMethod()
        { Console.WriteLine("abstractMethod只能由子类override"); }
    }
    struct myStruct 
    {
        public string Name;
        public void Call() { Console.WriteLine("Struct:值类型意味高效率；仅用于存储数据；仅可继承自接口"); }
    }

    [Serializable]
    public class MyException : Exception, ISerializable
    {
        //自定义本地文本信息
        private string myMsg;
        public string MyMsg{get { return myMsg; }}
        //重写只读本地文本信息属性
        public override string Message
        {
            get
            {
                string msgBase = base.Message;
                return myMsg == null ? msgBase : msgBase + myMsg;
            }
        }

        //实现基类的3个公有构造函数
        public MyException()
            : base() { }

        public MyException(string message)
            : base(message) { }

        public MyException(string message, Exception innerException)
            : base(message, innerException) { }

        //为新增字段实现构造函数
        public MyException(string message, string myMsg)
            : this(message)
        {
            this.myMsg = myMsg;
        }

        public MyException(string message, string myMsg, Exception innerException)
            : this(message, innerException)
        {
            this.myMsg = myMsg;
        }

        //用于序列化的构造函数，以支持跨应用程序域或远程边界的封送处理
        protected MyException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            myMsg = info.GetString("MyMsg");
        }

        //重写基类GetObjectData方法，实现向SerializationInfo中添加自定义字段信息
        public override void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("MyMsg", myMsg);
            base.GetObjectData(info, context);
        }
    }


}