置顶随笔 #
posted @ 2011-12-10 21:29 韩迎龙 阅读(278) 评论(0) 编辑
posted @ 2011-12-09 17:06 韩迎龙 阅读(1973) 评论(16) 编辑
2012年5月25日 #
posted @ 2012-05-25 10:53 韩迎龙 阅读(1303) 评论(12) 编辑
2012年5月24日 #
前言：由于这段时间公司的事情比较的繁忙，每天都要学习新的东西，所以好久没有写博客了，今天抽空写写博客来记录我这段时间研究的东西，给自己加深一下印象，我用easyUI的组件开发了一个简单操作数据库的小样例，一些常用的数据库操作都实现了，希望能和博客园里面的博主们交流交流意见。
首先我用的开发环境是Visual Studio 2010，ASP.NET MVC2.0，SQL SERVER2005，我用的NHibernate的版本是1.2.1，Spring.net的版本是1.1.0。
首先在这里将我的疑惑先说出来，希望有人能够给我解答解答，在这里谢过了，我在用版本的时候我发现NHibernate1.2.1和spring.net1.1.0（低版本）结合最好，Nhibernate3.0和spring.net 1.3.1（高版本）结合做好，不知道我的认为正确吗？但是低版本的话不能使用Nhibernate.Linq,只有Nhibernate3.0以上的版本支持Nhibernate，但是高版本的话我们项目里面有一个功能我们没有做出来，就是我们故意把数据库的连接字符串写错误，然后我执行不经过数据操作的页面的话，比如这个页面我就输出一句话，但是也会报错，说无法连接数据库，用户登录失败，但是我想要的是在没有操作数据库的页面可以正常显示，在操作数据库的页面在提示错误即可？不知道哪位博友有什么好方法呢？这种效果在低版本下面我可以实现了。
(1) 打开数据库SQL Server 2005，新建一个数据库bjk241，然后再此数据库中新建一张表，起名为：User_DepInfo，用来存放我们录入的数据，表的建立样式如下图所示：
(1) 打开Visual Studio 2010集成开发环境，在Visual Studio 2010中建立一个ASP.MVC 2.0的项目,给项目其名称是NewKJ241，将会生成微软封装好的自带的MVC的整个架构结构,然后在项目里面建立几个类库，用来存放我在后面建立的一些项目，当我们建立完成之后如图所示：
(2) 当我们看到这张图的时候,我们是不是在疑惑这都是干什么的呢?不要着急,下面我就介绍一下各个项目和类库的作用。
1) 首先我们看到了NewKJ241里面的内容和我们刚建立的不一样吧，那是因为我重新建立了几个文件夹，将没有的文件夹介绍一下，Configs文件夹里面放的是spring.net的XML节点，实现的作用是链接数据库和映射整个框架，下面我会详细介绍的，dlls文件夹里面放的是我们所要引用的dll,如图所示：
，easyUI文件夹里面是存放的是我们需要引用的easyUI的类库，其他的都是建立的时候自动生成的，后面会讨论的。
2) NewKJ241.Model类库的作用是存放映射的数据库的文件。
3) NewKJ241.IDao类库的作用是实现了我们所需要的在项目中实现数据库方法的接口。
4) NewKJ241. NhibernateDao类库的作用是实现了IDao的接口，完成了接口所要实现的方法的代码。
5）NewKJ241.IBLL类库的作用是实现了我们在项目中要使用Spring.NET所要使用的接口，和NewKJ241.IDao接口的写法一模一样。
6）NewKJ241.BLL类库的方法是实现了Nhibernate的实现方法，继承自IBLL项目，是为了使用Spring.NET所写的方法。
下面我就讲我写的东西详细的讲述一下,有什么不足或者缺点我们可以讨论。
(1) 首先我们要映射出数据库中表的信息的文件，这里我们怎么映射呢，那么多的代码？？别着急，我们可以用一个自动生成映射文件的组件CodeSmith软件，这个软件可以快速的帮助我们生成映射文件，关于这个软件怎么使用可以看我以前写的篇博客，那里详细的叙述了如何使用这个软件：http://www.cnblogs.com/hanyinglong/archive/2012/04/21/2462302.html。
(2) 接下来我们在NewKJ241.Model里面建立一个文件夹Mappings,在这个文件夹里面我们存放了映射的文件，生成之后附加到项目中如图所示：
1) UserDepInfo的作用是定义数据库中的字段，再用CodeSmith生成的时候模式字段属性是不加Virtual的，我们人为的给字段属性加上，代码如下：
protected int _id;
protected int _depID;
protected string _depName;
public UserDepInfo() { }
public UserDepInfo(int depID, string depName)
{
this._depID = depID;
this._depName = depName;
}
public virtual int Id
{
get { return _id; }
set { _id = value; }
}
public virtual int DepID
{
get { return _depID; }
set { _depID = value; }
}
public virtual string DepName
{
get { return _depName; }
set
{
if (value != null && value.Length > 50)
throw new ArgumentOutOfRangeException("Invalid value for DepName", value, value.ToString());
_depName = value;
}
}
2) 然后映射文件的代码如下：注意，在这里我们需要把这个XML文件改成嵌入的资源，不然后面我们事先不了功能，怎么改呢?很简单，右键——属性——生成操作改成嵌入的资源，这样就OK了，前期准备工作完成了下面我们就开始写方法了。在这里又看不懂是什么意思的，可以看我的博客：http://www.cnblogs.com/hanyinglong/archive/2012/04/20/2459314.html。
<?xml version="1.0" encoding="utf-8" ?>
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2"
assembly="NewKJ241.Model.UserDepInfo"
namespace="NewKJ241.Model.UserDepInfo">
<class name="NewKJ241.Model.UserDepInfo,NewKJ241.Model" table="User_DepInfo" lazy="false">
<!--下面是使用缓存所使用的一句话，但是本项目里面的二级缓存注释掉了，所以这里也注释-->
<!--<cache usage="read-write"/>-->
<!--部门表主键ID-->
<id name="Id" type="Int32" unsaved-value="null">
<column name="ID" length="4" sql-type="int" not-null="true" unique="true"/>
<generator class="native" />
</id>
<!--部门表ID-->
<property name="DepID" type="Int32">
<column name="DepID" length="4" sql-type="int" not-null="false"/>
</property>
<!--部门表名称-->
<property name="DepName" type="String">
<column name="DepName" length="50" sql-type="varchar" not-null="false"/>
</property>
</class>
</hibernate-mapping>
(1) 在NewKJ241.IDao类库下面新建一个类，起名为：IUserDepInfoDao，然后在此类中写要实现方法的接口，代码如下：
//where表明了对类型变量T的约束关系，where T : class表示类型变量T是继承自class或者class本身
public interface IUserDepInfoDao<T> where T : class
{
/// <summary>
/// 获取实体
/// </summary>
/// <param name="id">主键</param>
/// <returns>实体</returns>
T Get(object id);
/// <summary>
/// 获取实体
/// </summary>
/// <param name="id">主键</param>
/// <returns>实体</returns>
T Load(object id);
/// <summary>
/// 插入实体
/// </summary>
/// <param name="entity">实体</param>
/// <returns>插入的数据</returns>
object Save(T entity);
/// <summary>
/// 修改实体
/// </summary>
/// <param name="entity">实体数据</param>
void Update(T entity);
/// <summary>
/// 保存或者修改实体
/// </summary>
/// <param name="entity">实体数据</param>
void SaveOrUpdate(T entity);
/// <summary>
/// 删除实体
/// </summary>
/// <param name="id">主键ID</param>
void Delete(object id);
/// <summary>
/// 删除实体
/// </summary>
/// <param name="odList">主键ID的集合，删除多个项</param>
void Delete(string idList);
/// <summary>
///读取如果用户不输入任何信息进行查询的方法
/// </summary>
/// <param name="sort">按照某个字段进行排序</param>
/// <param name="order">按照某个字段进行排序</param>
/// <returns></returns>
IList<UserDepInfo> loadByAll(string sort, string order);
/// <summary>
/// 读取用户输入条件进行查询的方法
/// </summary>
/// <param name="sort">按照某个字段进行排序</param>
/// <param name="order">按照某个字段进行排序</param>
/// <param name="name">只用户输入的信息</param>
/// <returns></returns>
IList<UserDepInfo> loadAllCheck(string sort, string order, string name);
/// <summary>
///
/// </summary>
/// <param name="total">总的数量</param>
/// <param name="page">当前的页数</param>
/// <param name="rows">每页所显示的数量</param>
/// <param name="order">按照某个字段进行排序</param>
/// <param name="sort">按照某个字段进行排序</param>
/// <param name="DepName">只用户输入的信息</param>
/// <returns></returns>
IList<UserDepInfo> LoadAllByPage(out long total, int page, int rows, string order, string sort, string DepName);
}
这里就没什么说的了，写法都很固定！！
(1) 在NewKJ241.Nhibernate类库下面建立类，起名为：UserDepInfoDao，在该方法中继承自IDao接口，实现了IDAO接口里面的所有方法，在书写本代码的时候，我们必须引入dll，引入的dll如图所示：
代码如下：
public class UserDepInfoDao<T> : HibernateDaoSupport, IUserDepInfoDao<T> where T : class
{
public T Get(object id)
{
return this.HibernateTemplate.Get<T>(id);
}
public T Load(object id)
{
return this.HibernateTemplate.Load<T>(id);
}
public virtual object Save(T entity)
{
return this.HibernateTemplate.Save(entity);
}
public void Update(T entity)
{
this.HibernateTemplate.Update(entity);
}
public void SaveOrUpdate(T entity)
{
this.HibernateTemplate.SaveOrUpdate(entity);
}
public void Delete(object id)
{
var entity = this.HibernateTemplate.Get<T>(id);
if (entity == null)
{
return;
}
else
{
this.HibernateTemplate.Delete(entity);
}
}
public void Delete(string idList)
{
string[] idl = idList.Split(',');
int len = idl.Length;
for (int i = 0; i < len; i++)
{
var entity = this.HibernateTemplate.Get<T>(int.Parse(idl[i].ToString()));
if (entity == null)
{
return;
}
else
{
this.HibernateTemplate.Delete(entity);
}
}
}
public IList<UserDepInfo> loadByAll(string sort, string order)
{
string hql = "from UserDepInfo order by " + sort + " " + order;
return this.HibernateTemplate.Find<UserDepInfo>(hql).ToList();
}
public IList<UserDepInfo> loadAllCheck(string sort, string order, string name)
{
string hql = "from UserDepInfo where DepName like ? order by " + sort + " " + order;
return this.HibernateTemplate.Find<UserDepInfo>(hql, new object[] { "%" + name + "%" }).ToList();
}
public IList<UserDepInfo> LoadAllByPage(out long total, int page, int rows, string order, string sort, string DepName)
{
IList<UserDepInfo> list = null;
if (DepName == null)
{
list = this.loadByAll(sort, order);
}
else
{
list = this.loadAllCheck(sort, order, DepName);
}
total = list.LongCount();
list = list.Skip((page - 1) * rows).Take(rows).ToList();
return list;
}
}
哎，工作一天了，累了，回学校了，明天继续，今天写的这些都是基础，后面还会在写这个项目的，一直到这个项目写完！！，也是最有知识点了，所谓学习吗，一步一个脚印，慢慢来吧！！！
posted @ 2012-05-24 19:54 韩迎龙 阅读(1523) 评论(12) 编辑
2012年5月19日 #
(1) HTML只是描述网页长相的标记语言，没有计算，判断能力，如果所有计算，判断(比如判断文本框是否为空，判断两次密码是否输入一致)店铺放到服务器端执行的话网页的页面会非常的慢，用起来也很难用，对服务器的压力也很大，因此要求能在浏览器中执行一些简单的运算，判断，JavaScript就是一种在浏览器端执行的语言。
(2) JavaScript和Java没有直接的关系，唯一的关系就是JavaScript原名LiveScript，后来吸取了Java的一些特性，升级为JavaScript，JavaScript有时被简称为JS。
(3) JavaScript是解释性语言，无需编译就可以随时执行，这样哪怕语法有错误，没有语法错误的部分还是能够正确的执行。
(1) VS中JavaScript，Jqery的自动完成功能。
(2) JS是非常灵活的动态语言，不像C#等静态语言那样严谨。
(1) <script type="text/javascript">
alert(new Date().toLocaleDateString());
</script>
(2) JavaScript代码放到<script>标签中，<script>可以放到<head>,<body>等任意位置，而且可以有不止一个<script>标签。alert函数是弹出消息窗口，new Date()是创建一个Date类的对象，默认值就是当前的时间。
(3) 放到<head>中的<script>在body加载之前就已经运行了，写在body中的<script>是随着页面的加载而一个个的执行的。
(4) 除了可以再页面中声明JavaScript之外，还可以将JavaScript写在单独的JS文件中，然后在页面中引入：<script src=”common.js” type=”text/javascript”></script>。声明到单独的JS文件的好处是多页面也可以共享，减少网络流量。
(1) <a href="javascript:alert('Hello')">点击我</a>
<a href="javascript:void(0)">我就不弹出东西</a><br />
<a href="JSoop.htm" onclick="alert('您确认你要跳转吗？')">单击我</a>
(2) JavaScript中也有事件的概念，当按钮被点击的时候
1) <input type="button" value="单击我" onclick="alert('终于单击我了')" />
2) 只有超链接的href中的JavaScript中才需要”JavaScript:”，因为他不是事件，而是把”JavaScript:’看成像”http:”，”ftp:”，”thunder://”，ed2k://，mailto://一样的网络协议，交由JS解析引擎处理，只有href中这一个特列。
(1) JavaScript中既可以使用双引号声明字符串，也可以使用单引号声明字符串，主要是方便和HTML集成，避免转义符的麻烦。
(2) var i=10; //声明一个变量，名字为i，指向10这个整数，一旦指向10，i就是int类型， alert(i);
(3) JavaScript中有null，underfined两种，null表示变量的值为空，underfined则表示变量还没有指向任何的对象，未初始化。
(4) JavaScript是弱类型，表示变量的时候无法：int i=10.只能通过var i=10;声明变量，和C#中的var不一样，不是C#中的那样的类型推断。
(5) JavaScript中也可以不用var声明变量，直接用，这样的变量是”全局变量”，因此除非确实想用全局变量，否则使用的时候最好加上var。
(6) JS是动态类型的，因此var i=10;i=”abc”是合法的。
(1) var sum = 0;
for (var i = 0; i <= 100; i++) {
sum = sum + i;
}
alert(sum);
(2) 如果JavaScript中的代码有语法错误，浏览器会弹出报错信息，查看报错信息就能帮助排查错误。
(3) JavaScript的调试，使用VS可以很方便的进行JavaScript的调试，调试时需要注意几点：
1) IE的调试选项要打开，Internet选项-高级，去掉”禁用脚本调试”前的勾选。
2) 以调试方式运行界面。
3) 设置断点，监视变量等操作和C#一样。
(1) JavaScript中判断变量，参数是否初始化的三种方法。
var r;
if (r == null) { if (typeof (r) == "undefined") { if (!x) {
alert("null"); alert("undefined"); alert("不X");
} } }
注：推荐用最后一种方法
(1) JavaScript中声明函数的方法：
function Add(i1, i2) {
return i1 + i2;
}
(2) 不需要声明返回值类型，参数类型，函数定义以function开头
var r = Add(10, 20);
alert(r);
var r = Add("tom，", "您好");
alert(r);
(3) JavaScript中不像C#中那样要求所有路径都有返回值。
(1) var f1 = function sum(i1, i2) {
return i1 + i2;
}
alert(f1(10, 20));
(2) 类似于C#中的匿名函数。
(3) 这种匿名的用法在Jquery中用法特别多。
(4) alert(function sum(i1, i2) {
return i1 + i2;
} (100, 10));
注解：C#中匿名函数使用委托来调用。
(1) JavaScript中没有类的语法，是用函数闭包(closure)模拟出来的，下面讲解的时候还是用C#中的类，构造函数等概念，JavaScript中string，date等”类”都被叫做”对象”，JavaScript中声明类(类不是类，是对象)。
(2) function Person(name, age) { //声明一个函数，当成类用
this.Name = name;
this.Age = age;
this.SayHello = function () {
alert("你好，我是" + this.Name + ",我今年：" + this.Age + "岁了");
}
}
var p1 = new Person("韩迎龙", "23");
p1.SayHello();
(3) 必须要声明类名，function Person(name,age)可以看做是声明构造函数，Name,Age这些属性也是使用者动态添加了。
(1) JavaScript中的Array对象就是数组，首先是一个动态数组，而且是一个像C#中数组ArrayList，Hashtable等的超强综合体。
(2) var names = new Array();
names[0] = "韩迎龙";
names[1] = "得到";
names[2] = "说的";
for (var i = 0; i < names.length; i++) {
alert(names[i]);
}
(3) 无需预先制定大小，动态。
(1) Array练习，求出一个数组中的最大值。
<script type="text/javascript">
function MyMax(arr) {
var max = arr[0];
for (var i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
} }
return max;
}
var arr = new Array();
arr[0] = 20;
arr[1] = 10;
arr[2] = 34;
alert(MyMax(arr));
</script>
(1) 将一个字符串数组的元素的顺序进行反转，{3,9,5,34,54}{54,34.5.9.3}。不要使用JavaScript中的反转函数，提示：第i个和第length-i-1进行交换，定义函数。
<script type="text/javascript">
function MyReverse(arr) {
for (var i = 0; i < arr.length / 2; i++) {
var temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
}
var arr = new Array();
arr[0] = "3";
arr[1] = "9";
arr[2] = "5";
arr[3] = "34";
arr[4] = "54";
alert(arr);
MyReverse(arr);
alert(arr);
(1) 将一个字符串数组输出为|分割的形式，比如：韩迎龙|试试|订单。不要使用JavaScript中的Join函数，arr.join(1)将数组用分割符链接成一个字符串。
<script type="text/javascript">
function MyJoin(arr) {
if (arr.length <= 0) {
return;
}
var s = arr[0];
for (var i = 1; i < arr.length; i++) {
s = s + "|" + arr[i];
}
return s;
}
var arr = new Array();
arr[0] = "韩迎龙";
arr[1] = "试试";
arr[2] = "订单";
alert(MyJoin(arr));
//第二种方法
alert(arr.join("|"));
</script>
(1) JS中的Array是一个宝贝，不仅是一个数组，还是一个Dictionary，还是一个Stack。
(2) var names = new Array();
names["人"] = "ren";
names["扣"] = "kou";
names["手"] = "shou";
alert(names["人"]);
alert(names.人);
for (var k in names) {
alert(k);
}
(3) 像Hashtable,Dictionary那样用，而且像他们一样的效率高。
(1) Array还可以有简化的方式
var arr=[3,4,5,6,7]; //普通数组初始化
这种数组可以看做是names[“人”]=”ren”;的特例，也就是key为0,1,2,3,4,5
(2) 字典风格的简化创建方式
var arr={”tom”=30,”jim=”30};
(1) 对于数组风格的Array来说，可以使用join方法拼接为字符串。
var arr = ["tom", "jim", "kencery"];
alert(arr.join(",")); //JS中join是array的方法，不像.net中是string的方法
(2) for循环可以像C#中的foreach一样的使用。
for (var e in document) {
alert(e);
}
posted @ 2012-05-19 21:29 韩迎龙 阅读(1040) 评论(0) 编辑
2012年5月16日 #
(1) select() 语法是：
public static IEnumerable<TResult> select<TSource,TResult>(
this IEnumerbale<TSource> source.
Func<TSource,TResult> selector)
说明：1) select方法本身是一个泛型扩展方法
2) 它作用于IEnumerable<TSource>类型
3) 他只接受一个Func<TSource,TResult>类型参数
4) Func<TSource,TResult>是一个泛型委托，位于System名字的空间下，System.Core.dll中，在这里Selector是一个提取器。
(2) 举例说明，先定义一个静态类ExtraClass，然后再静态类中在定义一个静态的扩展方法，实现输出信息。代码如下：
public static class ExtraClass
{
//为IEnumerable提供输出的方法
public static void Print(this IEnumerable<string> ie)
{
IEnumerator<string> result = ie.GetEnumerator();
while (result.MoveNext())
{
MessageBox.Show(result.Current);
}
}
}
然后如图所示，单击图上的按钮事件，在按钮事件中的代码是：
此事件下面的代码实现了将一个泛型集合中的数据循环显示出来，代码如下：
List<string> persons = new List<string>();
persons.Add("zhang san");
persons.Add("zhang san feng");
persons.Add("li si");
persons.Add("wang wu");
persons.Add("wang liu");
persons.Add("li ba");
persons.Add("lao wu");
persons.Add("zhang xx");
//输出persons里面的所有的元素
var result = persons.Select(p => p);
result.Print();
执行结果是按顺序循环输出。
2. LINQ基本查询操作符-过滤数据
(1) where() 语法是：
public static IEnumerable<TSource> where<TSource>(
this IEnumerable<TSource> source,
Func<TSource,bool> predicate)
说明：1) where方法是一个泛型扩展方法
2) 它和select()一样作用与IEnumerable<TSource>类型
3) 它只接受一个Func<TSource,bool>泛型委托参数，在这里predicate是一个判断条件。
(2) 举例说明，还是上面的例子，使用那个泛型集合，实现按照一定的条件输出信息。先创建一个方法，实现输出姓“zhang”的人的信息，代码如下：
public bool Judge(string s)
{
if (s.StartsWith("zhang"))
{
return true;
}
return false;
}
在select控件的事件下面用LINQ代码输出只是姓张的各种各样的实现代码：
//输出persons里面姓“zhang”的人
//var result = persons.Where(p => p.StartsWith("zhang")); //第一种方法
//var result = persons.Select(p => p).Where(p => p.StartsWith("zhang")); //第二种方法
//var result = persons.Where(p => p.StartsWith("zhang")).Select(p => p); //第三种方法
var result = persons.Where(p => Judge(p)); //第四种方法
result.Print();
3. LINQ基本查询操作符-排序数据
(1) OrderBy() 语法是：
pblic static IOrderedEnumerable<TSource> orderBy<TSource,TKey>(
this IEnumerable<TSource> source
Func<TSource,TKey> keySelector)
注：1) orderBy方法也是一个泛型扩展方法
2) 它和select()一样作用与IEnumerable<TSource>类型
3) 它只接收一个Func<TSource,Tkey>类型参数，在这里keySelctor指定要排序的字段。
4) 如果想要降序排列可以使用orderbyDescending方法。
(2) 举例说明，同上例，实现排序的代码如下：
//var result = persons.OrderBy(p => p);
//按照名字的最后一个字母排序
//var result = persons.OrderBy(p => p.Substring(p.Length - 1, 1)).Select(p => p);
//降序排列
var result = persons.OrderByDescending(p => p);
result.Print();
(1) GroupBy() 语法是：
public static IEnumerable<IGrouping<Tkey,TSource>>
GroupBy<TSource,TKey>(
this IEnumerable<TSource> source,
Func<TSource,TKey> keySelector )
说明：1) GroupBy()方式和OrderBy()方式非常类似，它也是一个泛型扩展方法。
2) 它和OrderBy()一样作用与IEnumerable<TSource>类型。
3) 它只接受一个Func<TSource,TKey>类型参数，在这里keySelector指定要分组的字段。
(2) 举例说明，同上例，实现分组的代码是：
//分组---按照姓名来分组¦--取出姓名中的空格前的部分
var result = persons.GroupBy(p => p.Split(new char[] { ' ' })[0]);
foreach (var group in result)
{
Console.WriteLine("姓：" + group.Key);
foreach (var name in group)
{
Console.WriteLine("\t" + name);
}
Console.WriteLine();
}
(1) 从前面的试验中，我们发现一次查询实际上经过以下3步。
1) 第一步：获取数据源 int[] numbers=new int[]{3,45,65,76,2,434,54,65,76,76,65,43};
2) 第二步：定义查询 var even=numbers.Where(p=>p%2==0).Select(p=>{
Console.WriteLine(“Hi!”+p.ToString());
return p; });
3) 第三步：执行查询 foreach(var item in even){ }
(1) 查询分为以下三步，获取数据源，定义查询，执行查询
(2) 定义查询后，查询直到需要枚举结果时才被真正执行，这种方法称为”延迟执行”。
(3) 当查询结果返回单一值时，查询立即执行。举例，如代码：
//查询时机---当返回值为单值时马上执行语句，负责延迟执行
var result = persons.Select(p => p).Count();
Console.WriteLine("个数是" + result);
(4) 因此，可以通过以下技巧在定义查询时就强制执行查询
(1) Method syntax，查询方法方式
主要利用System.Linq.Enumerable类中定义的扩展方法和Lambda表达式方式进行查询。
(2) Query syntax ，查询语句方式
注：查询语句和查询方法存在着紧密的关系
(1) CLR本身并不理解查询语句，它只理解查询方法。
(2) 编译器负责在编译时将查询语句翻译为查询方法。
(3) 大部分查询方法都有对应的查询语句形式，如：Select()对应select，OrderBy()对应orderby。
(4)部分查询方法目前在C#中还没有对应的查询语句：如：Count()和Max()这时只能采用以下替代方案
1) 查询方法
2) 查询语句+查询方法的混合方式
(5) 一般情况下，建议使用可读性更好的查询语句。举例说明：
还是用上面多定义的泛型集合数组persons，用查询语句实现几个简单的功能，代码如下：
//输出persons中的所有的元素
var result = from p in persons select p;
//输出persons中姓zhang的人----语句和方法的混合编排?
var result = (from p in persons select p).Where(p => p.StartsWith("zhang"));
//排序
var result = from p in persons orderby p select p;
result.Print();
(1) 聚合类 Count()，Max()/Min()，Average()，Sum()。举例说明：
重新定义一个数组来实现上面的各种各样的方法，代码如下：
//LINQ to Objects查询高级方法
//数组数据arr
int[] arr = { 23, 34, 5, 5, 23, 45, 65, 33, 43, 76, 67, 87 };
//聚合类
Console.WriteLine("arr的最大值： + arr.Max());
Console.WriteLine("arr的最小值¦： " + arr.Min());
Console.WriteLine("arr的平均值¦： " + arr.Average());
Console.WriteLine("arr的数组元素个是" + arr.Count());
Console.WriteLine("arr的总和是： " + arr.Sum());
(2) 排序类 thenBy() 代码如下：
//排序类
var result = arr.OrderBy(p => p.ToString().Substring(0, 1));
//2次排序混编模式没有达到要求
var result = arr.OrderBy(p => p.ToString().Substring(0, 1)).ThenBy(p => p);
//按照语句排序
var t = arr.OrderBy(p => p.ToString().Substring(0, 1));
var result = from p in t orderby p descending select p;
(3) 分区类 Take,TakeWhile,Skip,SkipWhile 代码如下：
//分区类
var result = arr.Skip(3).Take(3); //跳过三个值取三个值
var result = arr.Skip(3); //跳过几个值
var result = arr.SkipWhile(p => p > 4); //方法体部分是该Linq语句不在往后执行的条件,当第一次遇到条件成立时，取剩下的所有元素
var result = arr.TakeWhile(p => p > 4); //方法体部分是该Linq语句提取数据的条件，当第一次遇到条件不成立的情况就停止执行
(4) 集合类 Distinct 代码如下：
//集合类
var result = arr.Distinct();
(5) 生成类 Range,Repeat 代码如下：
//生成类-----静态类
var result = System.Linq.Enumerable.Range(10, 50);
var result = System.Linq.Enumerable.Range('a', 50); //生成连续的序列
var result = System.Linq.Enumerable.Repeat(40, 10);
result.Print();
注：使用生成类查询方法时，需要注意以下几点：
(1) 和其它几类方法不同，Range/Repeat不是扩展方法，而是普通的静态方法
(2) Range只能产生整数序列。
(3) Repeat可以产生泛型序列。
(4) 所有的查询方法都存放在System.Linq.Enumerable静态类中。
posted @ 2012-05-16 21:29 韩迎龙 阅读(1173) 评论(1) 编辑
2012年4月21日 #
posted @ 2012-04-21 20:02 韩迎龙 阅读(1586) 评论(41) 编辑
2012年4月20日 #
posted @ 2012-04-20 14:45 韩迎龙 阅读(2773) 评论(32) 编辑
2012年4月15日 #
posted @ 2012-04-15 21:20 韩迎龙 阅读(304) 评论(1) 编辑
2012年4月12日 #
posted @ 2012-04-12 19:26 韩迎龙 阅读(184) 评论(0) 编辑
2012年4月10日 #
posted @ 2012-04-10 15:30 韩迎龙 阅读(320) 评论(0) 编辑
2012年4月9日 #
posted @ 2012-04-09 11:43 韩迎龙 阅读(282) 评论(1) 编辑
