LINQ to Entities

一种 LINQ 技术，使开发人员可以使用 LINQ 表达式和 LINQ 标准查询运算符，针对实体数据模型 (EDM) 对象上下文创建灵活的强类型化查询。

ESQL

Entity SQL

一种与 SQL 类似的、独立于存储的语言。该语言直接操作概念实体架构，并支持实体数据模型功能，如继承和关系。

EF

实体框架ADO.NET Entity Framework

一套支持面向数据的软件应用程序开发的技术，可让开发人员使用映射到数据源中的逻辑架构的概念模型。

EDM

实体数据模型(Entity Data Model)

一个数据模型，用于将应用程序数据定义为公共语言运行时类型和存储结构可以映射到的实体和关系集。

Entity

实体

ADO.NET Entity Framework 应用程序域中的一个概念，数据类型在该域中定义

csdl

概念架构定义语言 Conceptual schema definition language

一种基于 XML 的语言，可用于定义概念模型的实体类型、关联、实体容器、实体集和关联集

ssdl

存储架构定义语言 Store schema definition language

一种基于 XML 的语言，用于定义存储模型的实体类型、关联、实体容器、实体集和关联集，经常对应于数据库架构。

msl

映射规范语言 Mapping specification language

一种基于 XML 的语言，可用于将概念模型中定义的项映射到存储模型中的项

Storage Provider

负责直接和数据源通讯，支持的数据库Sql Server

Mapping Layer

数据库概念层和逻辑层的映射。

通过EDM模型和mapping provider，应用程序将构建在更高层次的EDM模型抽象层次上。同时，在应用程序中将不再使用本地数据库的查询语言比如（T-sql),取而代之的将是Entity SQL。

Object Services

Object Services 的目标是消除数据和应用程序代码风格的不匹配

ADO.NET允许将查询结果呈现为行和列记录，同时也可以呈现为.NET对象。

该层还包括了更多被O/R mapping框架支持的高级的服务，比如身份认证，跟踪对象状态变化，并行性检查以及处理更新。

LINQ to Entities

将Entity Framework与LINQ项目集成，以提供面向对象编程语言适合自己特点的查询功能。

LINQ to Entities这一层依赖于object services和mapping layer这两层。

ADO.NET

ADO.NET Entity Framework

SqlConnection

EntityConnection

SqlCommand

EntityCommand

SqlDataReader.

EntityDataReader

SqlDataAdapter

ObjectContext

DataSet

ObjectQuery<T>

Entity

csdl,ssdl,msl

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection();

econ.ConnectionString = econString; 

EntityCommand ecmd = new EntityCommand();
ecmd.CommandType = CommandType.Text; 
ecmd.Connection = econ; 

ecmd.CommandText = "select it.ItemID,it.ItemMatter from myContext.DBItem as it";//esql

//或

// cmd.CommandText = "select value it from myContext.DBItem as it"; //esql

// to SQL : "select * from DBItem"

econ.Open();

EntityDataReader eReader = ecmd.ExecuteReader(CommandBehavior.SequentialAccess);  

while (eReader.Read())

{

    Console.WriteLine("{0},{1}", eReader[0].ToString(), eReader[1].ToString());

}

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString);
ObjectContext context = new ObjectContext(econ);  

context.DefaultContainerName = "myContext";
ObjectQuery<DBItem> queryTab = context.CreateQuery<DBItem>("DBItem");
foreach (var r in queryTab)

{

    System.Console.WriteLine("{0},{1}", r.ItemID, r.ItemMatter);

}

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString);
ObjectContext context = new ObjectContext(econ);

ObjectQuery<DBItem> queryTab = context.CreateQuery<DBItem>("select value it from myContext.DBItem as it where it.ItemID='a'");
foreach (var r in queryTab)

{

    System.Console.WriteLine("{0},{1}",r.ItemID,r.ItemMatter);

}

Conceptual Model

概念模型

用于描述实体(Entity)类型及其关系

Storage Model

存储模型

用于描述数据库实际存储架构

Mapping Specification

映射规范

将概念模型和存储模型连接起来，以便进行操作转换

Entity Class

实体类

用于描述实体的属性，每一个实体类都会定义一个属性或多个属性为一个键属性（Key Properties），用于唯一标识一个实体

实体类型可以通过继承关系加以扩展

Entity Set

实体集

实体（Entity）存在于实体集(Entity Set)中，就像表格中的行存在于表格中的一样

Entity Containe

实体容器,

实体集定义在实体容器（Entity Container）中

关联

关联

定义了实体之间的关系,可以直接通过关联，来访问相关联的对象,关联分为一对一、一对多、多对多

关联通过Association Type来定义,过实体类中的Navigation属性就可以访问与实体相关联的实体

Conceptual schema definition language (.csdl)

Store schema definition language (.ssdl)

Mapping specification language (.msl)

数据库中的表

模型

模型生成选项

myContext context = new myContext();

ObjectQuery<myTab> a = context.myTabSets;

ObjectQuery<myTabEx1> b = context.myTabSets.OfType<myTabEx1>();

ObjectQuery<myTabEx2> c = context.myTabSets.OfType<myTabEx2>();

从主键表访问数据

myContext context = new myContext();

ObjectQuery<tab1> tab1_List = context.tab1;

foreach (tab1 tab1_Entity in tab1_List)

{

Console.WriteLine("{0},{1}", tab1_Entity.a, tab1_Entity.b);

EntityCollection<tab2> tab2_List = tab1_Entity.Nvtab2;

tab2_List.Load(); //加载外键数据

foreach (tab2 tab2_Entity in tab2_List)

{

Console.WriteLine("{0},{1},{2}", tab2_Entity.ID,tab2_Entity.x,tab2_Entity.y);

}

}

lzm ,456

3 ,5 ,6

4 ,7 ,8

wxd ,123

1 ,1 ,2

2 ,3 ,4

从外键表访问数据

myContext context = new myContext();

ObjectQuery<tab2> tab2_List = context.tab2;

foreach (tab2 tab2_Entity in tab2_List)

{

Console.WriteLine("{0},{1},{2}", tab2_Entity.ID, tab2_Entity.x, tab2_Entity.y);

tab2_Entity.NVtab1Reference.Load(); //加载主键数据

tab1 tab1 = tab2_Entity.NVtab1;

Console.WriteLine("{0},{1}", tab1.a, tab1.b);

}

1 ,1 ,2

wxd ,123

2 ,3 ,4

wxd ,123

3 ,5 ,6

lzm ,456

4 ,7 ,8

lzm ,456

删除主键

myContext context = new myContext();

var v = context.tab1.First(p => p.a == "wxd");

// 要删除主键时,要保证内存中对应的外键数据为空

//v.Nvtab2.Load();

//if (v.Nvtab2.Count != 0)

//{

// List<tab2> list = new List<tab2>();

// foreach (var w in v.Nvtab2)

// {

// list.Add(w);

// }

// foreach (var ww in list)

// {

// context.DeleteObject(ww);

// }

//}

context.DeleteObject(v);

context.SaveChanges();

直接插入外键数据

myContext context = new myContext();

tab2 tab2 = new tab2();

tab2.ID = "101";

tab2.x = "555";

tab2.y = "666";

tab2.Nvtab1 = context.tab1.First(p => p.a == "wxd"); //要有主键信息

context.AddTotab2(tab2);

context.SaveChanges();

通过主键插入外键数据

myContext context = new myContext();

var tab1 = context.tab1.First(p => p.a == "wxd");

//第1条外键记录

tab2 r1 = new tab2();

r1.ID = "103";

r1.x = "r1";

r1.y = "r1";

tab1.Nvtab2.Add(r1);

//第2条外键记录

tab2 r2 = new tab2();

r2.ID = "104";

r2.x = "r1";

r2.y = "r1";

tab1.Nvtab2.Add(r2);

context.SaveChanges();

读取

myContext context = new myContext();

ObjectQuery<tab1> tab1_List = context.tab1;

foreach (tab1 tab1_Entity in tab1_List)

{

Console.WriteLine("{0},{1}", tab1_Entity.a, tab1_Entity.b);

tab1_Entity.NVtab3Reference.Load(); //加载关联数据

tab3 tab3 = tab1_Entity.NVtab3;

Console.WriteLine("{0},{1},{2}", tab3.a, tab3.m, tab3.n);

}

lzm ,456

lzm ,mmmm ,nnnn

wxd ,123

wxd ,nnn ,nnn

myContext context = new myContext();

ObjectQuery<tab3> tab3_List = context.tab3;

foreach (tab3 tab3_Entity in tab3_List)

{

Console.WriteLine("{0},{1},{2}", tab3_Entity.a, tab3_Entity.m,tab3_Entity.n );

tab3_Entity.NVtab1Reference.Load(); //加载关联数据

tab1 tab1 = tab3_Entity.NVtab1;

Console.WriteLine("{0},{1}", tab1.a, tab1.b );

}

lzm ,mmmm ,nnnn

lzm ,456

wxd ,nnn ,nnn

wxd ,123

删除

myContext context = new myContext();

var tab3 = context.tab3.First(p => p.a == "wxd");

//-要按顺序

tab3.NVtab1Reference.Load(); // 加载关联数据

context.DeleteObject(tab3.NVtab1); //删除关联数据

context.DeleteObject(tab3); // 删除

//

context.SaveChanges();

插入

myContext context = new myContext();

tab1 tab1 = new tab1();

tab1.a = "wxwinter";

tab1.b = "789";

//关联

tab1.NVtab3 = new tab3();

tab1.NVtab3.a = "wxwinter";

tab1.NVtab3.m = "mm";

tab1.NVtab3.n = "mm";

context.AddTotab1(tab1);

context.SaveChanges();

得到数据

myContext context = new myContext();

ObjectQuery<部门表> bList = context.部门表;

foreach (部门表 b in bList)

{

Console.WriteLine("{0},{1}", b.部门, b.部门说明);

b.场地表.Load();

EntityCollection<场地表> cList = b.场地表;

foreach (场地表 c in cList)

{

Console.WriteLine("{0},{1}", c.场地, c.场地说明);

}

}

丙 ,1

a ,11

b ,22

c ,33

甲 ,2

a ,11

乙 ,3

a ,11

b ,22

myContext context = new myContext();

ObjectQuery<场地表> cList = context.场地表;

foreach (场地表 c in cList)

{

Console.WriteLine("{0},{1}", c.场地, c.场地说明);

c.部门表.Load();

EntityCollection<部门表> bList = c.部门表;

foreach (部门表 b in bList)

{

Console.WriteLine("{0},{1}", b.部门, b.部门说明);

}

}

a ,11

丙 ,1

甲 ,2

乙 ,3

b ,22

丙 ,1

乙 ,3

c ,33

丙 ,1

删除数据

myContext context = new myContext();

场地表 c = context.场地表.First(p => p.场地 == "a");

//1.如果加载关联数据,[中转表]中的关联数据也会被删除,

//2.如果不加载关联数据,将不会删除[中转表]中的关联数据

//c.部门表.Load(); // <-------[是/否]

context.DeleteObject(c);

context.SaveChanges();

添加数据

myContext context = new myContext();

场地表 c = new 场地表();

c.场地 = "d";

c.场地说明 = "44";

context.AddTo场地表(c);

context.SaveChanges();

同时添加数据到

[源表],

[关联表],

[中转表]

//可以将数据同时添加[源表],[关联表],[中转表]

myContext context = new myContext();

场地表 c = new 场地表();

c.场地 = "e";

c.场地说明 = "55";

c.部门表.Add(new 部门表() { 部门 = "vv", 部门说明 = "vv" });

context.AddTo场地表(c);

context.SaveChanges();

查询

PRSelectDBItem

CREATE PROCEDURE PRSelectDBItem

@v nvarchar(50)

as

select * from DBItem where ItemID=@v

myContext context = new myContext();

ObjectResult<DBItem> dbitemList= context.PRSelectDBITem("a");

foreach (var r in dbitemList)

{

Console.WriteLine("{0},{1}", r.ItemID, r.ItemMatter);

}

public class Context :ObjectContext

{

public Context() : base("name=myContext", "myContext")

{ }

public ObjectResult<DBItem> PRSelectDBITem(string v)

{

return base.ExecuteFunction<DBItem>("PRSelectDBITem", new ObjectParameter("v", v));

}

}

Context context = new Context();

ObjectResult<DBItem> dbitemList = context.PRSelectDBITem("a");

foreach (var r in dbitemList)

{

Console.WriteLine("{0},{1}", r.ItemID, r.ItemMatter);

}

插入

PRinsertDBItem

CREATE PROCEDURE PRinsertDBItem

@ItemID nvarchar(50),

@ItemMatter nvarchar(50)

as

insert into DBItem (ItemID,ItemMatter) values (@ItemID,@ItemMatter)

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection();

econ.ConnectionString = econString;

EntityCommand ecmd = new EntityCommand();

ecmd.CommandType = CommandType.Text;

ecmd.Connection = econ;

ecmd.CommandText = "myContext.PRinsertDBItem";

ecmd.CommandType = CommandType.StoredProcedure;

EntityParameter p1 = new EntityParameter("ItemID", System.Data.DbType.String);

p1.Value = "aaa";

EntityParameter p2 = new EntityParameter("ItemMatter", System.Data.DbType.String);

p2.Value = "bbb";

ecmd.Parameters.Add(p1);

ecmd.Parameters.Add(p2);

econ.Open();

ecmd.ExecuteNonQuery();

算加法

PRadd

CREATE PROCEDURE PRadd

@x int = 0,

@y int = 0,

@s int = 0 output

as

set @s= @x * @y

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection();

econ.ConnectionString = econString;

EntityCommand ecmd = new EntityCommand();

ecmd.CommandType = CommandType.Text;

ecmd.Connection = econ;

ecmd.CommandText = "myContext.PRadd";

ecmd.CommandType = CommandType.StoredProcedure;

EntityParameter p1 = new EntityParameter("x", System.Data.DbType.Int32);

p1.Value = 123;

EntityParameter p2 = new EntityParameter("y", System.Data.DbType.Int32);

p2.Value = 456;

EntityParameter rt = new EntityParameter("s",

System.Data.DbType.Int32,

0,

ParameterDirection.Output,

false,

0,

0,

"",

DataRowVersion.Current,

0);

ecmd.Parameters.Add(p1);

ecmd.Parameters.Add(p2);

ecmd.Parameters.Add(rt);

econ.Open();

ecmd.ExecuteNonQuery();

Console.WriteLine(rt.Value); //579

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;  

provider=System.Data.SqlClient;  

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString);
ObjectContext context = new ObjectContext(econ);  
context.DefaultContainerName = "myContext";  
ObjectQuery<DBItem> queryTab = context.CreateQuery<DBItem>("DBItem");  

foreach (var r in queryTab)

{

System.Console.WriteLine("{0},{1}", r.ItemID, r.ItemMatter);

}

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString);

ObjectContext context = new ObjectContext(econ);

ObjectQuery<DBItem> queryTab = context.CreateQuery<DBItem>("select value it from myContext.DBItem as it where it.ItemID='a'");

foreach (var r in queryTab)

{

    System.Console.WriteLine("{0},{1}",r.ItemID,r.ItemMatter);

}

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString); 

ObjectContext context = new ObjectContext(econ); 

ObjectQuery<DbDataRecord> queryTab = new ObjectQuery<DbDataRecord>("select it.ItemID,it.ItemMatter from myContext.DBItem as it", context）

foreach (var r in queryTab)

{

    System.Console.WriteLine("{0},{1}",r[0].ToString(),r[1].ToString());

}

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString);  

ObjectContext context = new ObjectContext(econ); 

ObjectQuery<int> queryTab = new ObjectQuery<int>("select value Count(it.ItemID) from myContext.DBItem as it", context);

foreach (var r in queryTab)

{

System.Console.WriteLine("个数:{0}", r.ToString() );

}

string econString = @"

metadata=res://*/myModel.csdl

|res://*/myModel.ssdl

|res://*/myModel.msl

;

provider=System.Data.SqlClient;

provider connection string=""

Data Source=.;

Initial Catalog=LingTestDB;

Integrated Security=True;

MultipleActiveResultSets=True;

""

";

EntityConnection econ = new EntityConnection(econString);  

ObjectContext context = new ObjectContext(econ);

context.DefaultContainerName = "myContext";

ObjectQuery<DBItem> queryTab = context.CreateQuery<DBItem>("DBItem");  

ObjectResult<DBItem> resultTab = queryTab.Execute(MergeOption.NoTracking);

foreach (var r in resultTab)

{

System.Console.WriteLine("{0},{1}",r.ItemID,r.ItemMatter);

}

ObjectQuery<TResultType> OfType<TResultType>();

myContext context = new myContext();

ObjectQuery<DBItemEx> v = context.DBItem.OfType<DBItemEx>();

判断集合中是否所有元素都满足某一条件

myContext context = new myContext();

bool b= context.DBItemList.All(p => p.ItemValue >= 0);

SELECT

CASE WHEN ( NOT EXISTS (SELECT

    cast(1 as bit) AS [C1]

    FROM [dbo].[DBItemList] AS [Extent1]

    WHERE ( NOT ([Extent1].[ItemValue] >= 1)) OR (CASE WHEN ([Extent1].[ItemValue] >= 0) THEN cast(1 as bit) WHEN ( NOT([Extent1].[ItemValue] >= 0)) THEN cast(0 as bit) END IS NULL)

)) THEN cast(1 as bit) WHEN ( EXISTS (SELECT

    cast(1 as bit) AS [C1]

    FROM [dbo].[DBItemList] AS [Extent2]

    WHERE ( NOT ([Extent2].[ItemValue] >= 0)) OR (CASE WHEN ([Extent2].[ItemValue] >= 0) THEN cast(1 as bit) WHEN ( NOT([Extent2].[ItemValue] >= 0)) THEN cast(0 as bit) END IS NULL)

)) THEN cast(0 as bit) END AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

判断集合中是否有元素满足某一条件

myContext context = new myContext();

bool b = context.DBItemList.Any(p => p.ItemValue == 4);

SELECT

CASE WHEN ( EXISTS (SELECT

    cast(1 as bit) AS [C1]

    FROM [dbo].[DBItemList] AS [Extent1]

    WHERE 4 = [Extent1].[ItemValue]

)) THEN cast(1 as bit) WHEN ( NOT EXISTS (SELECT

    cast(1 as bit) AS [C1]

    FROM [dbo].[DBItemList] AS [Extent2]

    WHERE 4 = [Extent2].[ItemValue]

)) THEN cast(0 as bit) END AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

获取集合的前n个元素

myContext context = new myContext();

IQueryable<DBItemList> list = context.DBItemList.Take(3);

SELECT TOP (3)

[c].[AutoId] AS [AutoId],

[c].[NameID] AS [NameID],

[c].[ItemID] AS [ItemID],

[c].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [c]

跳过集合的前n个元素,

Linq To Entity 要求必须先OrderBy

myContext context = new myContext();

IQueryable<DBItemList> list = context.DBItemList.OrderBy(p=>p.ItemValue).Skip(5);

SELECT

[Extent1].[AutoId] AS [AutoId],

[Extent1].[NameID] AS [NameID],

[Extent1].[ItemID] AS [ItemID],

[Extent1].[ItemValue] AS [ItemValue]

FROM ( SELECT [Extent1].[AutoId] AS [AutoId], [Extent1].[NameID] AS [NameID], [Extent1].[ItemID] AS [ItemID],[Extent1].[ItemValue] AS [ItemValue], row_number() OVER (ORDER BY [Extent1].[ItemValue] ASC) AS [row_number]

    FROM [dbo].[DBItemList] AS [Extent1]

) AS [Extent1]

WHERE [Extent1].[row_number] > 5

ORDER BY [Extent1].[ItemValue] ASC

集合的第一个元素,集合中没有会报错,

myContext context = new myContext();

DBItemList f1 = context.DBItemList.First();

DBItemList fi = context.DBItemList.First(p => p.ItemValue == 5);

SELECT TOP (1)

[Extent1].[AutoId] AS [AutoId],

[Extent1].[NameID] AS [NameID],

[Extent1].[ItemID] AS [ItemID],

[Extent1].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent1]

WHERE 5 = [Extent1].[ItemValue]

集合中的第一个元素,没有则返回类型默认值,对象型默认值为null

myContext context = new myContext();

DBItemList fi = context.DBItemList.FirstOrDefault(p => p.ItemValue ==5);

if (fi != null)

{

Console.WriteLine(fi.ItemValue);

}

用LinqExpressions为条件进行查询

myContext context = new myContext();

IQueryable<DBItemList> list= context.DBItemList.Where(p => p.ItemValue == 5);

SELECT

[Extent1].[AutoId] AS [AutoId],

[Extent1].[NameID] AS [NameID],

[Extent1].[ItemID] AS [ItemID],

[Extent1].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent1]

WHERE 5 = [Extent1].[ItemValue]

过滤集合中的相同项

ObjectQuery<T> Distinct()

myContext context = new myContext();

ObjectQuery<DbDataRecord> list = context.DBItemList.Select("it.ItemValue");

ObjectQuery<DbDataRecord> dlist= list.Distinct();

SELECT

[Distinct1].[C1] AS [C1],

[Distinct1].[ItemValue] AS [ItemValue]

FROM ( SELECT DISTINCT

    [Extent1].[ItemValue] AS [ItemValue],

    1 AS [C1]

    FROM [dbo].[DBItemList] AS [Extent1]

) AS [Distinct1]

排序升,排序降

myContext context = new myContext();

IQueryable<DBItemList> list = context.DBItemList.OrderBy(p=>p.ItemValue);

IQueryable<DBItemList> list = context.DBItemList.OrderByDescending(p=>p.ItemValue);

SELECT

[Extent1].[AutoId] AS [AutoId],

[Extent1].[NameID] AS [NameID],

[Extent1].[ItemID] AS [ItemID],

[Extent1].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent1]

ORDER BY [Extent1].[ItemValue] ASC

SELECT

[Extent1].[AutoId] AS [AutoId],

[Extent1].[NameID] AS [NameID],

[Extent1].[ItemID] AS [ItemID],

[Extent1].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent1]

ORDER BY [Extent1].[ItemValue] DESC

ThenBy,ThenByDescending 方法必须跟在 OrderBy 方法或对 ThenBy 方法的另一次调用之后

当用OrderBy,OrderByDescending指定主排序字段后,可用ThenBy呀ThenByDescending指定次排序字段

myContext context = new myContext();

IQueryable<DBItemList> query = context.DBItemList.OrderBy(p=>p.ItemValue).ThenByDescending(p => p.ItemID);

foreach (var r in query)

{

Console.WriteLine("{0},{1},{2},{3}", r.AutoId, r.ItemID, r.NameID, r.ItemValue);

}

SELECT

[Extent1].[AutoId] AS [AutoId],

[Extent1].[NameID] AS [NameID],

[Extent1].[ItemID] AS [ItemID],

[Extent1].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent1]

ORDER BY [Extent1].[ItemValue] ASC, [Extent1].[ItemID] DESC

平均值,求和

myContext context = new myContext();

double d = context.DBItemList.Average(p => p.ItemValue);

double s = context.DBItemList.Sum(p => p.ItemValue);

SELECT

[GroupBy1].[A1] AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

LEFT OUTER JOIN (SELECT

    AVG( CAST( [Extent1].[ItemValue] AS float)) AS [A1]

    FROM [dbo].[DBItemList] AS [Extent1] ) AS [GroupBy1] ON 1 = 1

SELECT

[GroupBy1].[A1] AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

LEFT OUTER JOIN (SELECT

    SUM([Extent1].[ItemValue]) AS [A1]

    FROM [dbo].[DBItemList] AS [Extent1] ) AS [GroupBy1] ON 1 = 1

集合最大值，最小值

myContext context = new myContext();

var mx = context.DBItemList.Max(p => p.ItemValue);

var mi = context.DBItemList.Min(p => p.ItemValue);

SELECT

[GroupBy1].[A1] AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

LEFT OUTER JOIN (SELECT

    MAX([Extent1].[ItemValue]) AS [A1]

    FROM [dbo].[DBItemList] AS [Extent1] ) AS [GroupBy1] ON 1 = 1

SELECT

[GroupBy1].[A1] AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

LEFT OUTER JOIN (SELECT

    MIN([Extent1].[ItemValue]) AS [A1]

    FROM [dbo].[DBItemList] AS [Extent1] ) AS [GroupBy1] ON 1 = 1

集合中的元素个数

myContext context = new myContext();

int n = context.DBItemList.Count();

int ni = context.DBItemList.Count(p => p.ItemValue == 5);

long ln = context.DBItemList.LongCount();

SELECT

[GroupBy1].[A1] AS [C1]

FROM ( SELECT cast(1 as bit) AS X ) AS [SingleRowTable1]

LEFT OUTER JOIN (SELECT

    COUNT(cast(1 as bit)) AS [A1]

    FROM [dbo].[DBItemList] AS [Extent1]

    WHERE 5 = [Extent1].[ItemValue] ) AS [GroupBy1] ON 1 = 1

连接不同集合，不会自动过滤相同项,两个集合可以不是同一个Context

myContext context1 = new myContext();

myContext context2 = new myContext();

IQueryable<DBItemList> list1 = context1.DBItemList.Where(p => p.ItemValue == 1);

IQueryable<DBItemList> list2 = context1.DBItemList.Where(p => p.ItemValue == 2);

IQueryable<DBItemList> list = list1.Concat(list2);

SELECT

[UnionAll1].[AutoId] AS [C1],

[UnionAll1].[NameID] AS [C2],

[UnionAll1].[ItemID] AS [C3],

[UnionAll1].[ItemValue] AS [C4]

FROM (SELECT

    [Extent1].[AutoId] AS [AutoId],

    [Extent1].[NameID] AS [NameID],

    [Extent1].[ItemID] AS [ItemID],

    [Extent1].[ItemValue] AS [ItemValue]

    FROM [dbo].[DBItemList] AS [Extent1]

    WHERE 1 = [Extent1].[ItemValue]

UNION ALL

    SELECT

    [Extent2].[AutoId] AS [AutoId],

    [Extent2].[NameID] AS [NameID],

    [Extent2].[ItemID] AS [ItemID],

    [Extent2].[ItemValue] AS [ItemValue]

    FROM [dbo].[DBItemList] AS [Extent2]

    WHERE 2 = [Extent2].[ItemValue]) AS [UnionAll1]

连接不同集合，自动过滤相同项,两个集合要是同一个Context

ObjectQuery<T> Union(ObjectQuery<T> query)

IQueryable<T> Union( IQueryable<T> query)

IQueryable<T> Uniont( IQueryable<T> query,IEqualityComparer<T>)

myContext context1 = new myContext();

IQueryable<DBItemList> query1 = context1.DBItemList.Where(p => p.ItemID == "c" || p.ItemID == "b");

IQueryable<DBItemList> query2 = context1.DBItemList.Where(p => p.ItemID == "c" || p.ItemID == "a");

IQueryable<DBItemList> v = query2.Union(query1);

foreach (var r in v)

{

Console.WriteLine("{0},{1},{2},{3}", r.AutoId, r.ItemID, r.NameID, r.ItemValue);

}

myContext context1 = new myContext();

ObjectQuery<DBItemList> query1 = context1.CreateQuery<DBItemList>("select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'b' ");

ObjectQuery<DBItemList> query2 = context1.CreateQuery<DBItemList>("select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'a' ");

ObjectQuery<DBItemList> v = query2.Union(query1);

foreach (var r in v)

{

Console.WriteLine("{0},{1},{2},{3}", r.AutoId, r.ItemID, r.NameID, r.ItemValue);

}

SELECT

[Distinct1].[C1] AS [C1],

[Distinct1].[C2] AS [C2],

[Distinct1].[C3] AS [C3],

[Distinct1].[C4] AS [C4]

FROM ( SELECT DISTINCT

    [UnionAll1].[AutoId] AS [C1],

    [UnionAll1].[NameID] AS [C2],

    [UnionAll1].[ItemID] AS [C3],

    [UnionAll1].[ItemValue] AS [C4]

    FROM (SELECT

        [Extent1].[AutoId] AS [AutoId],

        [Extent1].[NameID] AS [NameID],

        [Extent1].[ItemID] AS [ItemID],

        [Extent1].[ItemValue] AS [ItemValue]

        FROM [dbo].[DBItemList] AS [Extent1]

        WHERE (N'c' = [Extent1].[ItemID]) OR (N'a' = [Extent1].[ItemID])

    UNION ALL

        SELECT

        [Extent2].[AutoId] AS [AutoId],

        [Extent2].[NameID] AS [NameID],

        [Extent2].[ItemID] AS [ItemID],

        [Extent2].[ItemValue] AS [ItemValue]

        FROM [dbo].[DBItemList] AS [Extent2]

        WHERE (N'c' = [Extent2].[ItemID]) OR (N'b' = [Extent2].[ItemID])) AS [UnionAll1]

) AS [Distinct1]

两个集合的相同项都会返回,两个集合要是同一个Context

ObjectQuery<T> UnionAll(ObjectQuery<T> query);

myContext context1 = new myContext();

ObjectQuery<DBItemList> query1 = context1.CreateQuery<DBItemList>("select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'b' ");

ObjectQuery<DBItemList> query2 = context1.CreateQuery<DBItemList>("select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'a' ");

ObjectQuery<DBItemList> v = query2.UnionAll(query1);

foreach (var r in v)

{

Console.WriteLine("{0},{1},{2},{3}", r.AutoId, r.ItemID, r.NameID, r.ItemValue);

}

SELECT

[UnionAll1].[AutoId] AS [C1],