C#-LINQ

#region 隐式类型
var a = 1;
var b = "1";
var c = 1.23m;
var d = 1.23;
Console.WriteLine(a.GetType());
Console.WriteLine(b.GetType());
Console.WriteLine(c.GetType());
Console.WriteLine(d.GetType());
#endregion

#region 匿名类型
string Name = "藏锋";
//字段名字，Name根据上面定义的Name起名的。ID是自己定义的名字。
var user = new { Name, ID = 1 };
Console.WriteLine(user.Name);
Console.WriteLine(user.ID);
#endregion

#region 自动属性   属性不能定义在方法里面
int _UserId;
public int UserID
{
    get { return _UserId; }
    set { _UserId = value; }
}
//自动属性，生成的中间语言和  先定义一个私有变量，在写他的访问器一样。
public string UserNmae { get; set; }
#endregion

#region 初始化
var stuInit = new Student() { Name = "藏锋", ID = 1 };
IList<int> listInt = new List<int>() { 1, 2, 3, 4 };


//无论是值类型还是引用类型使用的时候都要初始化 赋值。
//值类型一般有默认值0
//引用类型为NULL
Student stuNULL;
int intNULL;
string strNULL;
string refStr = string.Empty;
int refID =0;
Console.WriteLine(refStr);
Console.WriteLine(refID);
//传出参数使用的时候不需要赋值，原因在方法里面会给他赋值。
string outStr;
int outID;
stuInit.GetUserName("WYX", ref refStr, ref refID, out outStr, out outID);
#endregion

#region 委托
Student stuForDele = new Student();
StuDele stuDele = new StuDele(stuForDele.GetUserId);
stuDele += stuForDele.GetUserId1;
stuDele += stuForDele.GetUserId2;
stuDele += stuForDele.GetUserId3;
stuDele -= stuForDele.GetUserId3;
Console.WriteLine(stuDele(2));
#endregion

#region 泛型
DAO<Teacher> dao = new DAO<Teacher>();
Teacher teac = new Teacher();
var pros1 = dao.GetAllPro();
var pros2 = dao.GetAllPro(teac);
Student stRef = new Student();
var typeName = dao.GetTypeName<Student>(stRef);
foreach (var item in pros1)
{
    Console.WriteLine(item);
}
foreach (var item in pros2)
{
    Console.WriteLine(item);
}
Console.WriteLine(typeName);
#endregion

//
// 摘要:
//     表示定义一组条件并确定指定对象是否符合这些条件的方法。
//
// 参数:
//   obj:
//     要按照由此委托表示的方法中定义的条件进行比较的对象。
//
// 类型参数:
//   T:
//     要比较的对象的类型。此类型参数是逆变。即可以使用指定的类型或派生程度更低的类型。有关协变和逆变的更多信息，请参见泛型中的协变和逆变。
//
// 返回结果:
//     如果 obj 符合由此委托表示的方法中定义的条件，则为 true；否则为 false。

//
// 摘要:
//     封装一个方法，该方法只有一个参数并且不返回值。
//
// 参数:
//   obj:
//     此委托封装的方法的参数。
//
// 类型参数:
//   T:
//     此委托封装的方法的参数类型。此类型参数是逆变。即可以使用指定的类型或派生程度更低的类型。有关协变和逆变的更多信息，请参见泛型中的协变和逆变。

//
// 摘要:
//     封装一个不具有参数但却返回 TResult 参数指定的类型值的方法。
//
// 类型参数:
//   TResult:
//     此委托封装的方法的返回值类型。此类型参数是协变。即可以使用指定的类型或派生程度更高的类型。有关协变和逆变的更多信息，请参见泛型中的协变和逆变。
//
// 返回结果:
//     此委托封装的方法的返回值。

#region 泛型委托
Student stupre = new Student() { ID = 10, Name = "WYX" };

Predicate<int> pStu = new Predicate<int>(stupre.CheUsreID);
Console.WriteLine(pStu(stupre.ID));

//0-16个参数     17中方法重载
Action ac1 = new Action(stupre.GetUserNameNoP);
ac1();
Action<string> ac2 = new Action<string>(stupre.GetUserNameNoP);
ac2("123");

//最后一个参数为返回参数out  协变   ，前面可以放0-16个参数
Func<string> fun1 = new Func<string>(stupre.ToString);
fun1();
Func<int, int> fun2 = new Func<int, int>(stupre.GetUserId3);
Console.WriteLine(fun2(5));
#endregion

//自定义泛型委托
NoInOutDele<int> custom1 = new NoInOutDele<int>(stupre.GetUserNameP);
Console.WriteLine(custom1());
OnePDele<string> custom2 = new OnePDele<string>(stupre.GetUserNameP);
Console.WriteLine(custom2("藏锋"));
OutPDele<string, string, string> custom3 = new OutPDele<string, string, string>(stupre.GetUserNameNoP);
Console.WriteLine(custom3("123", "456"));

#region 匿名方法
//委托里面添加的是一个个方法，可以写一个匿名方法给他   delegate(){} 
//好处 可以访问上下文变量
OutPDele<string, string, string> unNameFun1 = new OutPDele<string, string, string>(delegate (string s1, string s2)
{
    return s1 + s2;
});
Console.WriteLine(unNameFun1("藏", "锋"));

#endregion

#region Lambda
OutPDele<string, string, string> lamdFun = new OutPDele<string, string, string>((string s1, string s2) =>
{
    return s1 + s2;
});
//=>读 gos to
//一个参数可以(string s)=>s或者s=>s
//多个参数(string s1,string s2.....)  一定加括号
//返回只有一条语句返回  s=>{return s;}  或者s=>s  (默认为返回)
//多条语句  s=>{吧啦吧啦}
OnePDele<string> lamdFun1 = new OnePDele<string>(s => { return s; });
#endregion

//表达是一个委托
OutPDele<string, string, string> lamdFunD = (string s1, string s2) => s1 + s2;
lamdFunD.Invoke("1", "2");

#region 扩展方法
string s = "藏锋";
Console.WriteLine(s.MargTwoStr("1", "2"));
Console.WriteLine(s.MarMySelf("23"));
#endregion

public string GetUserNameNoP(string p_Name, string p_Name1)
{
    return p_Name1 + this.Name + p_Name;
}

public Teacher()
{

}
public Teacher(string p_TeacherName):this()
{

}
public Teacher(string p_TeacherName, DateTime p_CreateDate) : base(p_CreateDate)
{

}

public class MyIndex
{
    private string[] strList = new string[10];
    public string this[int index]
    {
        get { return strList[index]; }
        set { strList[index] = value; }
    }
}

public class MyIndexStr
{
    //用string索引查看的药用hashtable  key value列表
    private Hashtable hash = new Hashtable();
    public string this[string indexstr]
    {
        set { hash.Add(indexstr, value); }
        get { return hash[indexstr].ToString(); }
    }
}

#region 迭代器   都要继承IEnumerable接口实现了GetEnumerator方法。
List<Teacher> teas = new List<Teacher>();
for (int i = 0; i < 10; i++)
{
    Teacher tae = new Teacher() { CreateUserID = i, TeacherName = i.ToString(), CreateDate = DateTime.Now };
    teas.Add(tae);
}
//我们foreach的时候就是使用的迭代器
//但是数组也可以使用foreach，那是因为编译器把他转化为了for。中间语言中还是for
//IEnumerable接口中只有一个方法。
foreach (var item in teas)
{
    Console.WriteLine(item.TeacherName);
}
foreach (var item in GetIterator())
{
    Console.WriteLine(item.ToString());
}
//foreach遍历的集合每次只会返回一个，不把所有的都加载。GetIterator()方法一段一段的执行，遍历中间结束，后面的代码也不会执行

foreach (var item in GetIterator())
{
    if(item==2)
    {
        break;
    }
}
#endregion

//yield ：在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。
static IEnumerable<int> GetIterator()
{
    Console.WriteLine("迭代器返回了1");
    yield return 1;
    Console.WriteLine("迭代器返回了2");
    //终止迭代
    //yield break;
    yield return 2;
    Console.WriteLine("迭代器返回了3");
    yield return 3;
}