新语法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace 新语法
{
static class Program
{
static void Main(string[] args)
{
//2.1 调用带参数默认值的方法,编译后悔自动添加默认值到这个方法的括号中
// TestPareDafaule();
//2.2 通过命名参数调用此方法
// TestPareDafaule(18); //第一个赋值
//使用 命名参数为 方法的指定参数 赋值 其他的使用默认值
//TestPareDafaule(gender: true);//给第二个赋值
//TestAnoyclass();
//InvoExtenMethod();
// TestAction();
// TestPreDicate();
// TestCompaison();
Order();
Console.ReadLine();

}

static List<Dog> GetDogList()
{
return new List<Dog>()
{
new Dog(){Id=1, Age=3,Name="爱琴",Gender=true},
new Dog(){ Id=2,Age=5,Name="娟娟",Gender=true},
new Dog(){ Id=3,Age=1,Name="丽丽"},
};
}

static List<DogToy> GetDogTryList()
{
return new List<DogToy>()

{

new DogToy(){ DogId=1, ToyName="骨头" } ,
new DogToy(){ DogId=1, ToyName="骨头2" } ,
new DogToy(){ DogId=2,ToyName="fas"} ,

new DogToy(){ DogId=3,ToyName="dew"},
};
}
#region 1 隐私变量
//1 因素变量
//var 变量不能作为 全局变量使用
static void TestVar()
{
var a = 1;
a = a + 2;

var b = "";
b = "123123";
Console.WriteLine(b);

}
#endregion

#region 2 带默认值的参数
static void TestPareDafaule(int age = 18, bool gender = false)
{
Console.WriteLine(age + ":" + gender);
}

#endregion
#region 3.1 属性初始话器
/// <summary>
/// 属性初始话器
/// </summary>
static void TestProperty()
{
//属性初始化器
Dog d = new Dog() { Name = " 1" };
//编译后相与
Dog d1 = new Dog();
d1.Name = "1";

}
#endregion
#region 3.2 集合初始化器
/// <summary>
/// 3.2 集合初始化器
/// </summary>
static void TestInitLIs()
{
List<Dog> d = new List<Dog>()
{
new Dog(){ Age=1,Name="1"},
new Dog(){Age=2,Name="2"}
};
//编译后相当与
List<Dog> list = new List<Dog>();
list.Add(new Dog() { Age = 2, Name = "2" });

}
#endregion
#region 4 匿名累
/// <summary>
/// 匿名累
/// </summary>
static void TestAnoyclass()
{
//4,1 匿名类你编译后 会生成一个类 包含二个只读 变量 和只读属性 并重写了Object的所有方法
var cla = new { Name = "asd", Age = 23 };
var cla2 = new { Name = "asd", Age = 23 };
//4.2如果另一个匿名类对象的属性 类型 和顺序一样 那么会空用同一个匿名类
Console.WriteLine(cla.GetType() == cla2.GetType());//true
Console.WriteLine(cla.Name + ":" + cla.Age);

// 如果另一个匿名类 对象的属性 名称和属性一样但类型不一样,那么还是使用相同的匿名类.只不过泛型参数不同而已
var cls4 = new { Name = "asd", Age = "23" };
// 4.3 如果属性名相同 类型相同 但是顺序不同 也会新创建匿名类
var cls3 = new { Age = 23, Name = "sad" };

}
#endregion

//委托 本质是类 (内部类)
public delegate void DGTest(string str);
#region 5 匿名方法
/// <summary>
/// 匿名方法(指针)
/// </summary>
static void TestMethod()
{
//匿名方法 编译后 会生成一个编译器取名的静态方法 和一个静态的委托对象

//5.1使用委托 直接指定 命名方法
DGTest dg = new DGTest(TestMthod2);

//5.2 使用委托 传入匿名方法
DGTest dg2 = new DGTest(delegate(string str) { Console.WriteLine("我是匿名方法"); });

//5.3 使用 InvokeMthtod方法 传入匿名方法
InvokeMthtod(delegate(string srt) { Console.WriteLine("匿名方法" + srt); });
InvokeMthtod(delegate { Console.WriteLine("我省去了形参了"); });

}

static void TestMthod2(string str)
{

}
static void InvokeMthtod(DGTest dg)
{

dg("哈哈");
}

#endregion

#region 6 扩张方法
/// <summary>
/// 6 扩张方法
/// </summary>
static void InvoExtenMethod()
{

//List<Dog> list = new List<Dog>()
//{
// new Dog (){ Age=11, Name="das"} ,
// new Dog (){ Age=121, Name="da4s"} ,
// new Dog (){ Age=131, Name="da4s"} ,
//};
//IEnumerable<Dog> enu = list.Where(delegate(Dog d) { return d.Age > 44; });
//foreach (Dog d in enu)
//{
// Console.WriteLine(d.Name + ":" + d.Age);
//}

Dog d = new Dog() { Name = "小白", Age = 20 };
d.Pee(DateTime.Now);
//编译后: 就是直接调用 这个静态方法 并将当前对一个对象做为 第一个参数传过去

DogExtension.Pee(d, DateTime.Now);

//可以让空引用 调用扩张方法 如果扩张方法中 传入了实例 则会抱空指针 异常
Dog d2 = null;
d2.Pee(DateTime.Now);

//扩张方法可以被继承
FlowDog f = new FlowDog();
f.Pee(DateTime.Now);

}
#endregion

#region 7.1系统泛型委托 无返回值 Action
/// <summary>
/// 系统泛型委托 Action 委托 无返回值 遍历
/// </summary>
static void TestAction()
{
List<Dog> list = GetDogList();
list.ForEach(new Action<Dog>(delegate(Dog d)
{
Console.WriteLine(d.Name + "," + d.Age);
}));

//简写
list.ForEach(delegate(Dog d)
{ Console.WriteLine(d.Name + "," + d.Age); }
);

}
#endregion

#region 7.2 Predicate 带返回值的
static void TestPreDicate()
{
List<Dog> list = GetDogList();
list = list.FindAll(new Predicate<Dog>(delegate(Dog g) { return g.Age > 0; })

);
//简写
// FindAll 就可以帮助我们 根据条件筛选出一个新的集和 符合我们的条件
list = list.FindAll(delegate(Dog d) { return d.Age > 1; });
foreach (Dog item in list)
{

Console.WriteLine(item.Age + "," + item.Name);
}

//自己的方法实现
list.MyFindAll(delegate(Dog g) { return g.Age > 1; });

}
/// <summary>
/// 自己实现 FindAll方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="list"></param>
/// <param name="predicate"></param>
/// <returns></returns>

static List<T> MyFindAll<T>(this List<T> list, Predicate<T> predicate)
{
// 创建新集合
List<T> newlist = new List<T>();
foreach (T item in list)
{
//如果老集合中的item 符合条件则 吧item添加到新集合中
//调用传入的 predicate 方法 作为是否符合条件的判断
if (predicate(item))
{
newlist.Add(item);
}

}
return newlist;

}
#endregion

#region 7.3 系统泛型委托 Sort
/// <summary>
/// 系统泛型委托 Sort
/// </summary>
static void TestCompaison()
{
List<Dog> list = GetDogList();
list.Sort(delegate(Dog x, Dog y) { return x.Age - y.Age; });
list.ForEach(delegate(Dog d) { Console.WriteLine(d.Age + "," + d.Name); });

}

#endregion
#region 7.4 泛型委托 自定义返回值类型 Func
/// <summary>
/// 泛型委托 自定义返回值类型 Func
/// </summary>
static void TestFun()
{
List<Dog> list = GetDogList();
// list.Select(new Func<Dog, SmallDog>(delegate(Dog d) { return new SmallDog() { Name = d.Name }; }));

// IEnumerable<SmallDog> enuNew= list.Select(delegate(Dog d) { return new SmallDog() { Name = d.Name }; });

List<SmallDog> list2 = list.MySelect<Dog, SmallDog>(
new Func<Dog, SmallDog>(delegate(Dog d)
{
return new SmallDog() { Name = d.Name };

})

);

//将 dog 集合 转成 smalldog
list.MySelect<Dog, SmallDog>(delegate(Dog d) { return new SmallDog() { Name = d.Name }; });
}

static List<TR> MySelect<T1, TR>(this List<T1> list, Func<T1, TR> func)
{

List<TR> listNew = new List<TR>();
//遍历老集合
foreach (T1 item in list)
{
//调用func 委托 将老集合元素 转成另一个元素返回
TR re = func(item);
//将转换后的元素 存入新集合中
listNew.Add(re);

}
//返回新集合
return listNew;

}

#endregion
#region 7.5 Func 集合 匿名类
/// <summary>
/// Function
/// </summary>
static void TestFuncReturnAnoyClassList()
{
List<Dog> list = GetDogList();
//业务 ; 将dog 集合 转成包含 狗名字的 对象集合
//使用slect 方法 遍历list 集合 并转成一个匿名类对象的集合
list.Select(delegate(Dog d)
{
return new { Age = d.Age, Date = DateTime.Now };

});

}

#endregion
#region 7.5lambda
/// <summary>
///
/// </summary>
static void TestLambda()
{

List<Dog> list = GetDogList();
list.ForEach(delegate(Dog d) { Console.WriteLine(d.Name); });

//Lambda 语句
list.ForEach(d => Console.WriteLine(d.Name));
list.FindAll(d => d.Age > 1);
list.Sort((x, y) => x.Age - y.Age); //2个参数 就不能去 去括号
var ir= list.Select(d=>new SmallDog(){ Name=d.Name
}) ;
//多条语句的时候 还的必须加大括号
// lambda 表达式
list.Select(d =>
{
SmallDog sd = new SmallDog();
sd.Name = d.Name;
return sd;

});

}

#endregion

#region 8 标准化查询运算符
/// <summary>
/// 查询方法
/// </summary>
static void SQOWher()
{
List<Dog> list = GetDogList();
List<Dog> listdog = list.Where(d => d.Gender == true && d.Age > 2 && d.Age < 22).ToList();

list.ForEach(d => Console.WriteLine(d.ToString()));
}
#endregion

/// <summary>
/// select 投射方法
/// </summary>
static void SQOSelect()
{

List<Dog> list = GetDogList();
list.Select(d=>new SmallDog(){ Name=d.Name});

}
static void Order()
{

List<Dog> list = GetDogList();
//升序
// List<Dog> listsort=list.OrderBy(d => d.Age).ToList();
//降序
List<Dog> listsort = list.OrderByDescending(d => d.Age).ToList();
//多条件排序
List<Dog> listsort2 = list.OrderByDescending(d => d.Age).ThenBy(d => d.Id).ToList();
listsort.ForEach(d => Console.WriteLine(d.ToString()));
}

static void TestJoin()
{
List<Dog> listDog = GetDogList();
List<DogToy> listToy = GetDogTryList();
//连接查询 返回的是一个匿名类集合
var list= listDog.Join(listToy, d => d.Id, t => t.DogId, (d, t) => new { Dogid = d.Id, Dogname = d.Name, toname = t.ToyName }).ToList();

list.ForEach(a => Console.WriteLine(a.Dogname));

}
/// <summary>
/// 分组
/// </summary>
static void TestGroupby()
{
List<Dog> list = GetDogList();
IEnumerable<IGrouping< bool,Dog>> it= list.GroupBy(d => d.Gender);

IList<IGrouping<bool ,Dog>> listGrop=it.ToList();
foreach (var item in listGrop)
{
Console.WriteLine("小组" + item.Key);
foreach (Dog item2 in item)
{
Console.WriteLine(item2.ToString());

}

}

}
static void SOQPageList()
{
List<Dog> list = GetDogList().OrderBy(d => d.Id).ToList();

//假设每行2页
var pageone = list.Skip(0).Take(2);

var pagetwo = list.Skip(0).Take(2);

}

/// <summary>
/// Linq语句
/// </summary>
static void Linq()
{

List<Dog> list = GetDogList();
List<DogToy> listToys = GetDogTryList();

//将 老集合中查出每一个元素 放到新的集合中
var dogs1 = from d in list select d;
//wher 条件的 老集合中查出每一个元素 放到新的集合中
var dogs = from d in list where d.Gender = false select d;
//排序 order

var dog2 = from d in list orderby d.Age orderby d.Name descending select d;
//连接查询
var joinlist = from a in list join t in listToys on a.Id equals t.DogId select new { Dogs = a, names = t };
foreach (var item in joinlist)
{
Console.WriteLine(item.ToString());
}
//分组
var group = from d in list group d by d.Gender;
foreach (var item in group)
{

Console.WriteLine(item.Key);
foreach (var item2 in item)
{
Console.WriteLine(item2.ToString());

}
}

}

}
}

新语法,布布扣,bubuko.com

新语法

原文：http://www.cnblogs.com/cdaq/p/3597455.html