LINQ简单的入门
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Linq.Expressions;
namespace LinQ
{
public partial class Form1 : Form
{
/// <summary>
/// <Author>jilongliang</Author>
/// <Date>2012/8/14</Date>
/// <Language>CSharp</Language>
/// <From>http://www.java2s.com/</From>
/// </summary>
public Form1()
{
InitializeComponent();
}
private void btnTest1_Click(object sender, EventArgs e)
{
string[] presidents = { "A", "Ar", "B", "Bu", "C", "Cleveland" };
/*
*=>是lambda表达式在JDK8好像也支持这个语法
*Where并不是string里面的方法而是 Enumerable里面的
*IEnumerable是一个公开的枚举
*p.StartsWith的寻找到字符串第一个C就输出
*/
IEnumerable<string> sequence = presidents.Where(p => p.StartsWith("C"));
foreach (string s in sequence)
txtTest1.Text += string.Format("{0}", s);
}
private void btnTest2_Click(object sender, EventArgs e)
{
IEnumerable<char> query = "I Love Sports T!";
/*
* 经过测试!=这个符号c!='T'意思就是循环到包括有t的字符串就去掉t之后,
* 再输出剩下来循环到的字符串
* c=='T'的意思寻找到t就把所有都输出
*
*/
query = query.Where(c => c != 'T');//
foreach (char c in query)
{
txtTest2.Text += string.Format("{0}", c);
}
}
private void btnTest3_Click(object sender, EventArgs e)
{
string[] names = { "A123123", "B123", "C123123", "E123", "W" };
//循环字符串长度小于六的长度
IEnumerable<string> sequence = from n in names
where n.Length < 6
select n;
foreach (string name in sequence)
{
textTest3.Text += string.Format("{0}", name);
}
}
private void btnTest4_Click(object sender, EventArgs e)
{
/**
* Aa Bb Cc Dd Ee Ff Gg Hh Ii Jj Kk Ll Mm
* Nn Oo Pp Qq Rr Ss Tt Uu Vv Ww Xx Yy Zz
*/
String[] Query = { "One", "Two", "Three", "Four", "Five",
"Six", "Seven", "Eight", "Nine", "Ten" };
/**
* 找到字符串第一个字母(StringValue.Substring(0, 1))大于A的就输出,
* 并且按照这个字母进行排序orderby IndexValue
*/
var query = from StringValue in Query
let IndexValue = StringValue.Substring(0, 1)
where Convert.ToChar(IndexValue) > 'A'
orderby IndexValue
select new { StringValue, IndexValue };
foreach (var ThisValue in query)
txtTest4.Text += string.Format("{0}", ThisValue.IndexValue
+ " - " + ThisValue.StringValue);
}
private void btnTest5_Click(object sender, EventArgs e)
{
List<ProductWithNullablePrice> products = ProductWithNullablePrice.GetSampleProducts();
foreach (ProductWithNullablePrice product in products.Where(p => p.Price == null))
{
txtTest5.Text += product.Name;
}
}
#region
private class ProductWithNullablePrice
{
public string Name { get; private set; }
public decimal? Price { get; private set; }//这个?的意思就是允许插入数据库为Null值
public ProductWithNullablePrice(string name, decimal price)
{
Name = name;
Price = price;
}
//无参数构造方法
ProductWithNullablePrice()
{
}
public static List<ProductWithNullablePrice> GetSampleProducts()
{
return new List<ProductWithNullablePrice>
{
new ProductWithNullablePrice { Name="C", Price= 9.99m },
new ProductWithNullablePrice { Name="A", Price= 4.99m },
new ProductWithNullablePrice { Name="F", Price= 3.99m },
new ProductWithNullablePrice { Name="S", Price=null }
};
}
/// <summary>
/// 重写
/// C#中重写(override)和重载(overload)
/// <URL>http://www.cnblogs.com/forward/archive/2009/02/16/1391976.html</URL>
/// </summary>
/// <returns></returns>
public override string ToString()
{
return string.Format("{0}: {1}", Name, Price);
}
}
#endregion
private void btnTest6_Click(object sender, EventArgs e)
{
// LinqArrayLength();
//GetIntersect();
//GetFilter();
//FilterArrayOfInts();
//GetLookUp();
//GetAggregate();
//GetAggregate_Factorial();
//GetAggregateRang();
//GetLambda();
//GetExpression();
//GetOdd_Even();
//GetToDictionary();
//GetFirstOrDefault();
//GetRepeat();
//GetNested_Query();
//GetDistinct();
//GetSelectMany();
GetSequenceEqual();
}
/// <summary>
/// 使用Linq的Select处理数组的Length
/// </summary>
private void LinqArrayLength()
{
string[] presidents = { "A", "Ar", "Buc", "Bush", "Carte", "Clevel" };
var nameObjs = presidents.Select(p => new { p, p.Length });
foreach (var item in nameObjs)
txtTest6.Text += item.ToString() + "\t";
}
/// <summary>
/// 获取最大值
/// </summary>
/// <returns></returns>
private int GetMaxValue()
{
int[] myInts = new int[] { 974, 2, 7, 1374, 27, 54 };
int maxInt = myInts.Max();
return maxInt;
}
/// <summary>
/// 获取最小值
/// </summary>
/// <returns></returns>
private int GetMinValue()
{
int[] myInts = new int[] { 974, 2, 7, 1374, 27, 54 };
int minInt = myInts.Min();
return minInt;
}
/// <summary>
/// Intersect使用
/// </summary>
private void GetIntersect()
{
int[] numbersA = { 0, 2, 4, 5, 6, 8, 9 };
int[] numbersB = { 1, 3, 5, 7, 8 };
var commonNumbers = numbersA.Intersect(numbersB);
//两个数组共同拥有的数组是
Console.WriteLine("Common numbers shared by both arrays:");
foreach (var n in commonNumbers)
{
txtTest6.Text += string.Format("数组共同数字是{0}", n.ToString() + "\t");
}
}
#region
/// <summary>
/// 过滤数组
/// FilterArrayOfInts和delegate使用
/// delegate是表示委托，委托是一种数据结构,它引用静态方法或引用类实例及该类的实例方法
/// </summary>
private void FilterArrayOfInts()
{
int[] nums = { 1, 2, 3, 4, 5, 6 };
int[] oddNums = FilterArrayOfInts(nums, delegate(int i) { return ((i & 1) == 1); });
foreach (int i in oddNums)
txtTest6.Text += string.Format("FilterArrayOfInts{0}", i);
}
//定义一个bool的委托IntFilter
public delegate bool IntFilter(int i);
public static int[] FilterArrayOfInts(int[] ints, IntFilter filter)
{
ArrayList list = new ArrayList();
foreach (int i in ints)
{
if (filter(i))
{
list.Add(i);
}
}
return ((int[])list.ToArray(typeof(int)));
}
#endregion
#region
public class Employee
{
public int birthYear;
public string firstName;
public string lastName;
public static Employee[] GetEmployees()
{
Employee[] actors = new Employee[]
{
new Employee { birthYear = 1964, firstName = "乔", lastName = "锋" },
new Employee { birthYear = 1968, firstName = "黄", lastName = "蓉" },
new Employee { birthYear = 1960, firstName = "郭", lastName = "靖" },
new Employee { birthYear = 1964, firstName = "杨", lastName = "过" },
};
return (actors);
}
}
/// <summary>
/// Lookup的使用
/// </summary>
private void GetLookUp()
{
ILookup<int, string> lookup = Employee.GetEmployees()
.ToLookup(k => k.birthYear, a => string.Format("firstName:{0} lastName:{1}", a.firstName, a.lastName));
IEnumerable<string> actors = lookup[1964];
foreach (var actor in actors)
txtTest6.Text = string.Format("{0}", actor);
}
#endregion
/// <summary>
///Aggregate是使用
///指定一个数组求数组的数字加起来的总和
/// </summary>
private void GetAggregate()
{
int[] numbers = { 9, 3, 5, 4, 2, 6, 7, 1, 8 };
//指定5个种子值用作累加器初始值
var query = numbers.Aggregate(5, (a, b) => ((a < b) ? (a * b) : a));
txtTest6.Text = string.Format("{0}", query + "\t");
}
/// <summary>
/// Aggregate是使用
/// 求指定一个数字求阶乘
/// 6!=6*5*4*3*2*1
/// </summary>
private void GetAggregate_Factorial()
{
int N = 6;
int agg = 0;
IEnumerable<int> intSequence = Enumerable.Range(1, N);
foreach (int item in intSequence)
{
agg = intSequence.Aggregate((av, e) => av * e);
}
txtTest6.Text = string.Format("{0}! = {1}", N, agg);
}
/// <summary>
/// 指定一个范围的数组进行求总和
/// </summary>
private void GetAggregateRang()
{
int sum = 0;
IEnumerable<int> intSequence = Enumerable.Range(1, 10);
foreach (int item in intSequence)
{
sum = intSequence.Aggregate(0, (s, i) => s + i);
}
txtTest6.Text = string.Format("{0}", sum + "\t");
}
#region
delegate int NumericSequence();
private void GetLambda()
{
int seed = 1;
NumericSequence natural = () => seed++;
txtTest6.Text = natural().ToString();
}
#endregion
#region
private void GetSequenceEqual() {
string[] stringifiedNums1 = { "101", "49", "017", "1080", "00027", "2" };
string[] stringifiedNums2 = { "1", "1049", "17", "080", "27", "02" };
bool eq = stringifiedNums1.SequenceEqual(stringifiedNums2, new MyStringifiedNumberComparer());
txtTest6.Text = string.Format("{0}", eq);
}
public class MyStringifiedNumberComparer : IEqualityComparer<string>
{
public bool Equals(string x, string y)
{
return (Int32.Parse(x) == Int32.Parse(y));
}
public int GetHashCode(string obj)
{
return Int32.Parse(obj).ToString().GetHashCode();
}
}
#endregion
/// <summary>
/// 以表达式目录树的形式将强类型 lambda 表达式表示为数据结构，无法继承此类.
/// 获取偶数与奇数的数字显示出来
/// </summary>
private void GetExpression()
{
Expression<Func<int, bool>> isOddExpression = i => (i & 1) == 1;
ParameterExpression param = Expression.Parameter(typeof(int), "i");
Expression<Func<int, bool>> isOdd =
Expression.Lambda<Func<int, bool>>(
Expression.Equal(
Expression.And(
param,
Expression.Constant(1, typeof(int))),
Expression.Constant(1, typeof(int))),
new ParameterExpression[] { param });
Func<int, bool> isOddCompiledExpression = isOddExpression.Compile();
for (int i = 0; i < 10; i++)
{
if (isOddCompiledExpression(i))
txtTest6.Text += string.Format("{0}", i + " is odd" + "\t");
else
txtTest6.Text += string.Format("{0}", i + " is even" + "\t");
}
}
/// <summary>
/// 获取偶数与奇数的数字显示出来
/// </summary>
private void GetOdd_Even()
{
//Func封装一个具有一个参数并返回 TResult 参数指定的类型值的方法
Func<int, bool> isOddDelegate = i => (i & 1) == 1;
for (int i = 0; i < 10; i++)
{
if (isOddDelegate(i))
txtTest6.Text += string.Format("{0}", i + " is odd" + "\t");
else
txtTest6.Text += string.Format("{0}", i + " is even" + "\t");
}
}
/// <summary>
/// ToDictionary字典的使用
/// </summary>
private void GetToDictionary()
{
var scoreRecords = new[] {
new {Name = "数学", Score = 120},
new {Name = "英文" , Score = 140},
new {Name = "中文", Score = 145}
};
try
{
var scoreRecordsDict = scoreRecords.ToDictionary(sr => sr.Name);
//指定一个科目是否在字典里面,如果不在就报异常
txtTest6.Text = string.Format("Bob's score: {0}", scoreRecordsDict["英文"] + "\t");
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// 获取第一个或者默认的值
/// </summary>
private void GetFirstOrDefault()
{
string[] presidents = { "G", "H", "a", "H", "over", "Jack" };
string name = presidents.FirstOrDefault(p => p.StartsWith("B"));
txtTest6.Text = string.Format("{0}", name == null ? "NULL" : name);
}
/// <summary>
/// 获取Repeat重复
/// 生成包含一个重复值的序列
/// 返回结果:
// 一个 System.Collections.Generic.IEnumerable<T>，包含一个重复值
/// </summary>
private void GetRepeat()
{
IEnumerable<int> ints = Enumerable.Repeat(2, 10);
foreach (int i in ints)
txtTest6.Text = string.Format("{0}", i + "\t");
}
/// <summary>
/// an untidy nested query
/// </summary>
private void GetNested_Query()
{
string[] names = { "Tom", "Dick", "Harry", "Mary", "Jay" };
IEnumerable<string> query =
Enumerable.Select(
Enumerable.OrderBy(
Enumerable.Where(
names, n => n.Contains("a")//处理包括有a的字符串
), n => n.Length
), n => n.ToUpper() //转换为大写
);
foreach (var q in query)
{
txtTest6.Text += string.Format("{0}", q + "\t"); //\t代表制8位
}
}
/// <summary>
/// 处理重复的数字,重复的就拿唯一D一个值
/// </summary>
private void GetDistinct()
{
int[] fl = { 2, 2, 3, 5, 5 };
var unique= fl.Distinct();
foreach (var f in unique)
{
txtTest6.Text += string.Format("{0}", f + "\t");
}
}
/// <summary>
/// 查找更多的值
/// </summary>
private void GetSelectMany()
{
string[] presidents = { "A", "Art", "Buch", "Bush", "Carter", "land" };
IEnumerable<char> chars = presidents
.SelectMany((p, i) => i < 5 ? p.ToArray() : new char[] { });
foreach (char ch in chars)
txtTest6.Text += string.Format("{0}",ch);
}
#region
/// <summary>
/// Filter过滤使用
/// </summary>
private void GetFilter()
{
List<Person> people = new List<Person> {
new Person { ID = 1, IDRole = 1, LastName = "布斯", FirstName = "乔"},
new Person { ID = 2, IDRole = 2, LastName = "帮主", FirstName = "乔"}
};
//过滤ID为1的用户
Func<Person, bool> filter = delegate(Person p) { return p.ID == 1; };
var query = people
.Where(filter)
.Select(p => new { p.FirstName, p.LastName });
foreach (var q in query)
txtTest6.Text += string.Format("被过滤的用户是:{0}", q.ToString() + "\t");
}
/// <summary>
/// Preson实体类
/// </summary>
private class Person
{
int _id;
int _idRole;
string _lastName;
string _firstName;
public int ID
{
get { return _id; }
set { _id = value; }
}
public int IDRole
{
get { return _idRole; }
set { _idRole = value; }
}
public string LastName
{
get { return _lastName; }
set { _lastName = value; }
}
public string FirstName
{
get { return _firstName; }
set { _firstName = value; }
}
}
#endregion
}
}
扫一扫
77
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
