class Program
{
    static void Main(string[] args)
    {
        Dictionary<string, string> dict = new Dictionary<string, string>();
        dict.Add("one", "hello");
        dict.Add("two", "world");
        dict.Add("three", "gogo");

        //判断字典的key是否存在
        if (dict.ContainsKey("two"))
        {
            //根据键值取值
            Console.WriteLine(dict["two"]);
        }

        //输出字典的长度
        Console.WriteLine(dict.Count);

        //遍历字典
        foreach (var i in dict)
        {
            Console.WriteLine(i.Key + ":" + i.Value);
        }

        Console.ReadKey();
    }
}

对于泛型类，如A<T>，T为泛型，随着T的不同，这个类就是一个不同的类，也就是说A<int>和A<string>是两个不同的类型，所以他们的静态属性和方法是各自拥有和不是唯一的。

class Singleton<T> where T:new()
{
    private static T _instance = default(T);

    public static T GetInstance()
    {
        if (_instance == null)
        {
            _instance = new T();
        }

        return _instance;
    }

}

class NetManager
{
    public string Name = "Hello";
}

class GameManager
{
    public int t = 100;
}

class Program
{
    static void Main(string[] args)
    {
        GameManager g = Singleton<GameManager>.GetInstance();
        NetManager n = Singleton<NetManager>.GetInstance();
        Console.WriteLine(n.Name + g.t);
        Console.ReadKey();
    }
}

这样子，利用这个就是“一个泛型类的静态属性和方法不同的类型T是不同类型”，就可以把想控制为单例的类都通过这个访问，减少了很多重复的单例类的编写，像往常那样编写就可以了。坏处就是，这个单例类可能会没有经过这个步奏，从而会产生多个实例。

声明一个承载数据的类为public

public class MyClass
{
    public int Num;
    public string Str;
}

处理成xml格式的字符串

using System;
using System.Xml.Serialization;
using System.IO;

namespace Xml
{
    class Program
    {
        static void Main(string[] args)
        {
            MyClass my = new MyClass();
            my.Num = 10;
            my.Str = "Chicai";

            XmlSerializer serializer = new XmlSerializer(typeof(MyClass));
            StringWriter stringWriter = new StringWriter();
            serializer.Serialize(stringWriter, my);
            string xmlStr = stringWriter.ToString();
            stringWriter.Close();

            Console.WriteLine(xmlStr);
            Console.ReadKey();
        }
    }
}

using System;
using NHibernate.Cfg;
using Shit.Model;
using NHibernate;
using NHibernate.Criterion;

namespace Shit
{
    class Program
    {
        static void Main(string[] args)
        {
            Configuration config = new Configuration();
            config.Configure();
            config.AddAssembly("Shit");

            ISessionFactory sessionFactory = config.BuildSessionFactory();

            ISession session = sessionFactory.OpenSession();

            Config c;
            c = session.Get<Config>(2);
            session.Delete(c);//删除
            c = session.Get<Config>(3);
            c.Name = "Hello World";
            session.Update(c);//更新
            session.Flush();//将内存的字节流写入文件

            session.Close();
            Console.ReadKey();
        }
    }
}

这里不调用Flush的话删除数据是没有效果的，按常理说Close()之后就会写入的，但是没有，所以还是Flush()一下

当配置好连接的配置文件和类和表的映射配置文件，插入操作就很简单了

using System;
using NHibernate.Cfg;
using Shit.Model;
using NHibernate;

namespace Shit
{
    class Program
    {
        static void Main(string[] args)
        {
            Configuration config = new Configuration();
            config.Configure();
            config.AddAssembly("Shit");//加载映射配置

            ISessionFactory sessionFactory = config.BuildSessionFactory();
            ISession session = sessionFactory.OpenSession();
            //使用类构建数据
            Config c = new Config();
            c.UserID = 5200;
            c.Name = "Chicai";
            c.Val = 8000;
            //保存对象那样保存（插入）数据库
            session.Save(c);

            session.Close();
            Console.ReadKey();
        }
    }
}

首先数据库下有着这么一个表：

create TABLE chicai_config(
id int PRIMARY KEY auto_increment,
user_id int not null,
name VARCHAR(60) not null,
val int not null
)

创建一个对应的类，里面的属性对应上表的字段

namespace Shit.Model
{
    class Config
    {
        //还不知道为什么要声明为virtual
        public virtual int ID { get; set; }
        public virtual int UserID { get; set; }
        public virtual string Name { get; set; }
        public virtual int Val { get; set; }
    }
}

建立映射关系，需要一个XML配置文件，命名方式为：类名.hbm.xml，必须声明文件类型为“嵌入的资源”

<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
                   assembly="Shit"
                   namespace="Shit.Model">

  <class name="Config" table="chicai_config">
    <id name="ID" column="id" type="Int32">
      <generator class="identity"></generator>
    </id>
    <property name="UserID" column="user_id" type="Int32"></property>
    <property name="Name" column="name" type="String"></property>
    <property name="Val" column="val" type="Int32"></property>
  </class>

</hibernate-mapping>

映射配置文件详解看这一篇笔记