Entity Framework 基本概念

時間 2019-11-09

標籤 entity framework 基本概念简体版

原文原文鏈接

概念

LINQ to Entitiessql	一種 LINQ 技術，使開發人員可使用 LINQ 表達式和 LINQ 標準查詢運算符，針對實體數據模型 (EDM) 對象上下文建立靈活的強類型化查詢。數據庫
ESQLexpress	Entity SQL編程一種與 SQL 相似的、獨立於存儲的語言。該語言直接操做概念實體架構，並支持實體數據模型功能，如繼承和關係。windows
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 的語言，可用於將概念模型中定義的項映射到存儲模型中的項

ADO.NET Entity Framework

架構

ADO.NET Entity Framework分Storage Provider ，Mapping Layer ，Object Services，LINQ to Entities 四層。

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 Entity Framework 的數據訪問方式與ADO.NET 有相似之處

ADO.NET	ADO.NET Entity Framework
SqlConnection	EntityConnection
SqlCommand	EntityCommand
SqlDataReader.	EntityDataReader
SqlDataAdapter	ObjectContext
DataSet	ObjectQuery<T>
	Entity
	csdl,ssdl,msl

注意:ADO.NET與 ADO.NET Entity Framework是不一樣的技術,這個對比只是一個幫助理解的比效

EntityConnection

EntityCommand

經過EntityDataReader 方式的數據訪問

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());

}

經過ObjectContext返回ObjectQuery<T> 方式的數據訪問

ObjectContext提供了管理數據的功能

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）中
關聯		關聯定義了實體之間的關係,能夠直接經過關聯，來訪問相關聯的對象,關聯分爲一對1、一對多、多對多關聯經過Association Type來定義,過實體類中的Navigation屬性就能夠訪問與實體相關聯的實體

模型關係說明

模型設計器結構說明

EDM

EF 沒有采起 LINQ to SQL 基於Attribute映射的作法。

爲了適應變化和提供更多的數據庫類型擴展,EF 提供了專門的定義語言來完成模型設置

Conceptual schema definition language (.csdl)
Store schema definition language (.ssdl)
Mapping specification language (.msl)

默認,Model設計器將(.csdl)(.ssdl)(.msl)存放在一個名爲(.edmx)的XML 格式定義文件,並會根據設計自動生成對應的Context與實體類

Model設計器

數據庫中的表
模型
模型生成選項

edmx文件

	<?xml version="1.0" encoding="utf-8"?> <edmx:Edmx Version="1.0" xmlns:edmx="http://schemas.microsoft.com/ado/2007/06/edmx"> <!-- EF Runtime content -->
	<edmx:Runtime>
存儲模型	<!-- SSDL content --> <edmx:StorageModels> <Schema Namespace="myModel.Store" Alias="Self" Provider="System.Data.SqlClient"ProviderManifestToken="2008"xmlns:store="http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator"xmlns="http://schemas.microsoft.com/ado/2006/04/edm/ssdl"> <EntityContainer Name="myModelStoreContainer"> <EntitySet Name="myTab" EntityType="myModel.Store.myTab" store:Type="Tables"Schema="dbo" /> </EntityContainer> <EntityType Name="myTab"> <Key> <PropertyRef Name="a" /> </Key> <Property Name="a" Type="nchar" Nullable="false" MaxLength="10" /> <Property Name="b" Type="nchar" Nullable="false" MaxLength="10" /> <Property Name="c" Type="nchar" MaxLength="10" /> <Property Name="d" Type="nchar" MaxLength="10" /> </EntityType> </Schema> </edmx:StorageModels>
概念模型	<!-- CSDL content --> <edmx:ConceptualModels> <Schema Namespace="myModel" Alias="Self"xmlns="http://schemas.microsoft.com/ado/2006/04/edm"> <EntityContainer Name="mySets"> <EntitySet Name="myTab" EntityType="myModel.myTab" /> </EntityContainer> <EntityType Name="myTab"> <Key> <PropertyRef Name="aa" /> </Key> <Property Name="aa" Type="String" Nullable="false" MaxLength="10" Unicode="true"FixedLength="true" /> <Property Name="bb" Type="String" Nullable="false" MaxLength="10" Unicode="true"FixedLength="true" /> <Property Name="cc" Type="String" MaxLength="10" Unicode="true" FixedLength="true" /> <Property Name="dd" Type="String" MaxLength="10" Unicode="true" FixedLength="true" /> </EntityType> </Schema> </edmx:ConceptualModels>
映射	<!-- C-S mapping content --> <edmx:Mappings> <Mapping Space="C-S" xmlns="urn:schemas-microsoft-com:windows:storage:mapping:CS"> <EntityContainerMapping StorageEntityContainer="myModelStoreContainer"CdmEntityContainer="mySets"> <EntitySetMapping Name="myTab"> <EntityTypeMapping TypeName="IsTypeOf(myModel.myTab)"> <MappingFragment StoreEntitySet="myTab"> <ScalarProperty Name="aa" ColumnName="a" /> <ScalarProperty Name="bb" ColumnName="b" /> <ScalarProperty Name="cc" ColumnName="d" /> <ScalarProperty Name="dd" ColumnName="c" /> </MappingFragment> </EntityTypeMapping> </EntitySetMapping> </EntityContainerMapping> </Mapping> </edmx:Mappings>
	</edmx:Runtime>
圖形設計器的配置部份	<!-- EF Designer content (DO NOT EDIT MANUALLY BELOW HERE) --> <edmx:Designer xmlns="http://schemas.microsoft.com/ado/2007/06/edmx"> <edmx:Connection> <DesignerInfoPropertySet> <DesignerProperty Name="MetadataArtifactProcessing" Value="EmbedInOutputAssembly" /> </DesignerInfoPropertySet> </edmx:Connection> <edmx:Options> <DesignerInfoPropertySet> <DesignerProperty Name="ValidateOnBuild" Value="true" /> </DesignerInfoPropertySet> </edmx:Options> <!-- Diagram content (shape and connector positions) --> <edmx:Diagrams> <Diagram Name="myModel"> <EntityTypeShape EntityType="myModel.myTab" Width="1.5" PointX="0.75" PointY="0.75"Height="1.7" IsExpanded="true" /> </Diagram> </edmx:Diagrams> </edmx:Designer>
	</edmx:Edmx>

Context

public class myContext :ObjectContext

{

public myContext(EntityConnection connection) :

base(connection, "mySets")

{

}

public ObjectQuery<myTab> myTab

{

get

{

if ((this._myTab == null))

{

this._myTab = base.CreateQuery<myTab>("[myTab]");

}

return this._myTab;

}

private ObjectQuery<myTab> _myTab;

public void AddTomyTab(myTab myTab)

{

base.AddObject("myTab", myTab);

}

實體類

[EdmEntityType(NamespaceName = "myModel", Name = "myTab")]

[DataContract(IsReference = true)]

[Serializable()]

public class myTab :EntityObject

{

public static myTab CreatemyTab(string aa, string bb)

{

myTab myTab = new myTab();

myTab.aa = aa;

myTab.bb = bb;

return myTab;

}

private string _aa;

[EdmScalarProperty(EntityKeyProperty = true, IsNullable = false)]

[DataMember()]

public string aa

{

get

{

return this._aa;

}

set

{

this.ReportPropertyChanging("aa");

this._aa = StructuralObject.SetValidValue(value, false);

this.ReportPropertyChanged("aa");

}

private string _bb;

[EdmScalarPropertyAttribute(IsNullable = false)]

[DataMemberAttribute()]

public string bb

{

get

{

return this._bb;

}

set

{

this.ReportPropertyChanging("bb");

this._bb = global::System.Data.Objects.DataClasses.StructuralObject.SetValidValue(value,false);

this.ReportPropertyChanged("bb");

}

private string _cc;

[EdmScalarProperty()]

[DataMember()]

public string cc

{

get

{

return this._cc;

}

set

{

this.ReportPropertyChanging("cc");

this._cc =StructuralObject.SetValidValue(value, true);

this.ReportPropertyChanged("cc");

}

private string _dd;

[EdmScalarProperty()]

[DataMember()]

public string dd

{

get

{

return this._dd;

}

set

{

this.ReportPropertyChanging("dd");

this._dd = StructuralObject.SetValidValue(value, true);

this.ReportPropertyChanged("dd");

}

使用

myContext cn;

EntityConnection econ = new EntityConnection();

string s = @"

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;

econ.ConnectionString = s;

cn = new myDate.myContext(econ);

this.dataGridView1.DataSource = cn.myTab;

使用嚮導建立模型

映射基本規則

1.[概念模型]的[數據類型],[鍵],[非空]約束要與[存儲模型]對應

2.[概念模型]的屬性名與[存儲模型]的字段名沒必要一致

3.[存儲模型]的字段若是有[鍵],[非空]約束, [概念模型]必須要有對應的屬性與之映射

4. [概念模型]中出現的屬性,在[存儲模型]中必需要有對應的字段映射

5. [存儲模型]的多個字段能夠映射到[概念模型]的同一個屬性上

加載時, [概念模型]的屬性加載[存儲模型]的第一個字段值

保存時, [概念模型]的屬性會保存到[存儲模型]的多個字段上

映射條件

一個字段,若是要做爲映射條件,就不能映射到屬性上
加載數據時,只會加載符合條件的數據
添加數據時, 映射條件字段不可見, 射條件字段的字直接使用設計時的設定值

繼承

1. 要實現繼承,要使用映射條件進行篩選

2. [概念模型]與 [子概念模型] 全部的篩選條件不能有相的

3. [子概念模型] 自動獲得 [概念模型] 的屬性

4. [子概念模型] 中能夠沒有屬性

5. 所的[子概念模型] 的篩選條件將以[Or]的方式影響[概念模型]的篩選,也就是說[概念模型]的記錄將包括[子概念模型] 記錄

6. [概念模型]與 [子概念模型] 共用同一個 [實體集], [實體集]的數據類型爲 ObjectQuery<概念模型>

7. 可使用類型轉換的方式從[實體集]得[子概念模型]的數據

myContext context = new myContext();

ObjectQuery<myTab> a = context.myTabSets;

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

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

多表聯合

1. 不要求在數據庫中有關係,最好是主鍵對主鍵

2. 使用對聯的方式,只篩選出有對應鍵的記錄

3. 插入時,會在兩個表中同時插入鍵相同的記錄

4. 刪除時,會同時在兩個表中刪除鍵相同的記錄

關聯

[(1)—(*)] 關聯

1. [(1)—(*)]爲主外關係,主鍵表爲(1),外鍵表爲(*)

2. 外鍵字段不能出如今[概念模型]中

3. 能夠在嚮導中直接跟據數據庫中的關係直接生成,也能夠在設計[概念模型]時任意添加

4. 關聯要綁定到外鍵表上

5. 要刪除主鍵時,要保證內存中沒有對應的外鍵數據

6. 插入外鍵數據,能夠插入到主鍵的外鍵集合,也可建立帶主鍵信息的外鍵對象後直接插入到Context中

表

設置

操做數據

從主鍵表訪問數據

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();

[(1)—(1)]關聯

1. [(1)—(1)]爲主主關係,既兩個表的主鍵關聯

2. 兩個表的地位是平等的

3. 主鍵字段不能刪除

4. 能夠在嚮導中直接跟據數據庫中的關係直接生成,也能夠在設計[概念模型]時任意添加

5. 關聯可綁定到任意一個表上

6. 刪除時,要先將關聯數據刪除

7. 插入時,要有與之關聯的數據

表

設置

操做數據

讀取

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();

[(1)—(0..1)]關聯

設計與[(1)—(0..1)]相同.

1. 插入(1)時,能夠不插入(0..1)

2. 刪除(0..1) 時,能夠不刪除(1)

3. 插入(0..1)時,須要插入(1)

4. 刪除(1) 時, 須要刪除(0..1)

[()—()]關聯

表

顯示中轉方式

隱示中轉方式

1. 要實現這個關聯,要將關聯綁定到 [中轉表(安排表)]上

2. 所用的[中轉表(安排表)]不能以[概念模型]的方式出現

3. 兩個表的地位是平等的

4. 添加一端的(*)時,不受另外一端(*)約束

5. 能夠在添加一端的(*)時,經過[關聯集合]將數據也添加到[關聯表]與[中轉表]中

6. 若是加載關聯數據,[中轉表]中的關聯數據也會被刪除.

若是不加載關聯數據,將不會刪除[中轉表]中的關聯數據

操做數據

獲得數據

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)

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)

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

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,

ParameterDirection.Output,

false,

"",

DataRowVersion.Current,

0);

ecmd.Parameters.Add(p1);

ecmd.Parameters.Add(p2);

ecmd.Parameters.Add(rt);

econ.Open();

ecmd.ExecuteNonQuery();

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

說明

ObjectContext提供了管理數據的功能

Context操做數據

AddObject 添加實體

將實體添加到集合中,

建立實體時,狀態爲EntityState.Detached

當調用AddObject將實體添加到Context時,狀態爲EntityState.Added

myContext context = new myContext();

myTab r = new myTab();

r.ID = 10;

r.a = "wxwinter";

Console.WriteLine(r.EntityState); //print:Detached

context.AddTomyTab(r);

Console.WriteLine(r.EntityState); //print:Added

context.SaveChanges();

myContext context = new myContext();

myTab newrow = new myTab() { a = "wxd", b = "lzm", c = "wxwinter" };

context.AddObject("myTab",newrow);

context.SaveChanges();

DeleteObject 刪除實體

將集合中的實體添標記爲刪除

當調用Context.DeleteObject時,並非將實體移除集合,而是將實體添標記爲EntityState.Deleted ,在下次調用SaveChanges()方法時跟新數據庫

myContext context = new myContext();

myTab r = context.myTab.First(p=>p.ID==1);

Console.WriteLine(r.EntityState); //print:Unchanged

context.DeleteObject(r);

Console.WriteLine(r.EntityState); //print:Deleted

context.SaveChanges();

Detach 分離實體

將實體從Context中分離,將狀態標記爲EntityState.Detached 。

myContext context = new myContext();

myTab r = myTab.CreatemyTab(22);

Console.WriteLine(r.EntityState); //print:Detached

context.AddTomyTab(r);

Console.WriteLine(r.EntityState); //print:Added

context.Detach(r);

Console.WriteLine(r.EntityState); //print: Detached

修改實體

能夠直接修在實體對象上修改

當修改在Context中的實體時,會將實體的狀態標記爲EntityState.Modified

myContext context = new myContext();

myTab r = context.myTab.First(p=>p.ID==1);

Console.WriteLine(r.EntityState); //print:Unchanged

r.a = "wxwinter";

Console.WriteLine(r.EntityState); //print:Modified

context.SaveChanges();

ApplyPropertyChanges 修改實體

使用ApplyPropertyChanges,可使用不在集合中的實體覆蓋到集合中主鍵對應用實體上,若是內存中沒有主鍵對應的記錄,會報錯:「ObjectStateManager 不包含具備對「XXX」類型的對象的引用的 ObjectStateEntry。」該方法還有一個特色就是，會拿內存中的對象（新對象）和context中的對象（舊對象）對比，自動生成對應字段修改的Update語句，若是內存中的對象與context中的對象徹底相等(每一個字段的值都相等),將不生成響應的Update

myContext context = new myContext();

myTab r1 = context.myTab.First(p => p.ID == 1);

myTab nr = myTab.CreatemyTab(1);

nr.a = "wxwinter";

Console.WriteLine(nr.EntityState); //print:Detached

Console.WriteLine(r1.EntityState); //print:Unchanged

context.ApplyPropertyChanges("myTab", nr);

myTab r2 = context.myTab.First(p => p.ID == 1);

Console.WriteLine(nr.EntityState); //print:Detached

Console.WriteLine(r2.EntityState); //print:Modified

context.SaveChanges();

Orders order;
using (NorthwindEntities ne = new NorthwindEntities())
{
    //利用EntityObject.Execute(MergeOption.NoTracking)，等效於使用ObjectContext.Dettach(EntityObject)
    //查詢並分離對象
    order = ne.Orders.Execute(MergeOption.NoTracking).Where(v => v.OrderID == 10248).FirstOrDefault();
}
//修改分離的值
order.ShipName = "1111111111111111";
//使用分離的對象 order 更新
using (NorthwindEntities context = new NorthwindEntities())
{
    //將數據載入到context中以便更新
    context.GetObjectByKey(order.EntityKey);
    //使用order 更新 context中的對應對象
    context.ApplyPropertyChanges(order.EntityKey.EntitySetName, order);
    context.SaveChanges();
}

Attach / AttachTo 附加實體

使用Attach方法可將[外部實體]附加到Context集合中

在使用服務器/客戶端模式,或要將[實體]從Context集合中分離,修改後要用Context更新回數據庫時,可用這種方式

Attach與ApplyPropertyChanges有相似之處,都是將Context集合外的[實體]與Context集合內的[實體]同步.

ApplyPropertyChanges調用時,要求對應的[實體]在內存中,Attach不要求
ApplyPropertyChanges調用後,集合內的實體狀態會標記爲EntityState.Modified
Attach調用後不會修改合內的實體狀態,如要SaveChanges(),要手動標記EntityState.Modified
ApplyPropertyChanges是用[外部實體]全覆蓋Context集合中的[實體],
Attach方式,經過SetModifiedProperty()方法,可在調用SaveChanges()時,只修改只定有字段值

myContext context = new myContext();
myTab v = myTab.CreatemyTab(1);
v.EntityKey = context.CreateEntityKey("myTab", v);
v.a = "wxwinter";
context.Attach(v);
//context.AttachTo("myTab", v);
ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(v);
//設置修改
ose.SetModified();
//指定修改的字段名
ose.SetModifiedProperty("a");
context.SaveChanges();

修改前

修改後

CreateEntityKey 建立EntityKey

myContext context = new myContext();

myTab nr = myTab.CreatemyTab(1);

EntityKey ek= context.CreateEntityKey("myTab", nr);

EntityKey

EntityContainerName 屬性
EntityKeyValues 集合
EntitySetName 屬性
IsTemporary 屬性
GetEntitySet(System.Data.Metadata.Edm.MetadataWorkspace) 方法
OnDeserialized(System.Runtime.Serialization.StreamingContext) 方法
OnDeserializing(System.Runtime.Serialization.StreamingContext) 方法

GetObjectByKey/TryGetObjectByKey 經過EntityKey獲得實體

myContext context = new myContext();

myTab nr = myTab.CreatemyTab(1);

EntityKey ek= context.CreateEntityKey("myTab", nr);

myTab r = context.GetObjectByKey(ek) as myTab ;

Console.WriteLine("{0},{1},{2},{3}", r.ID, r.a, r.b, r.c);

myContext context = new myContext();

myTab nr = myTab.CreatemyTab(1);

EntityKey ek= context.CreateEntityKey("myTab", nr);
object obj;

if (context.TryGetObjectByKey(ek,out obj))

{

myTab r = obj as myTab;

Console.WriteLine("{0},{1},{2},{3}", r.ID, r.a, r.b, r.c);

}

CreateQuery 建立查詢

更多見esql

myContext context = new myContext();

string esql = "SELECT VALUE DBItemList FROM myContext.DBItemList";

// ObjectQuery<DBItemList> query = new ObjectQuery<DBItemList>(esql, context);

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

Console.WriteLine(r.NameID);

}

狀態管理

EntityState 狀態枚舉

EntityState.Added 已經過AddObject方法加到集合中，AcceptChanges 還沒有調用。

EntityState.Deleted 已經過 DeleteObject 方法被刪除。

EntityState.Detached 已被建立，但不屬於任何集合。在如下狀況下當即處於此狀態：建立以後添加到集合中以前；或從集合中移除以後。

EntityState.Modified 已被修改，AcceptChanges 還沒有調用。

EntityState.Unchanged 自上次調用 AcceptChanges 以來還沒有更改

Context.ObjectStateManager 管理記錄的狀態

GetObjectStateEntry 根據實體對象或實體主鍵獲得狀態實體

實體必須在當前鏈接對象 context 中不然沒法獲取實體狀態會引起：
ObjectStateManager 不包含具備對「 context 」類型的對象的引用的 ObjectStateEntry
也就是該方法沒法獲取已分離的實體對象狀態

ObjectStateEntry = GetObjectStateEntry(實體對像/EntityKey)

獲得所指定的[實體對像]或EntityKey的 ObjectStateEntry

myContext context = new myContext();

myTab r = myTab.CreatemyTab(22);

context.AddTomyTab(r);

// ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(r.EntityKey);

Console.WriteLine(ose.State); //print:Added

TryGetObjectStateEntry 根據實體對象或實體主鍵獲得狀態實體

bool = TryGetObjectStateEntry(實體對像/EntityKey,out ObjectStateEntry)

獲得所指定的[實體對像]或EntityKey的 ObjectStateEntry

myContext context = new myContext();

myTab r = myTab.CreatemyTab(22);

context.AddTomyTab(r);

ObjectStateEntry ose;

if( context.ObjectStateManager.TryGetObjectStateEntry(r,out ose))

{

Console.WriteLine(ose.State); //print:Added

}

GetObjectStateEntries 根據狀態類型獲得狀態實體集合

IEnumerable<ObjectStateEntry> = GetObjectStateEntries(EntityState枚舉)

返回IEnumerable<ObjectStateEntry>,獲得EntityState枚舉所指定的某種狀態的列表

myContext context = new myContext();

myTab r = myTab.CreatemyTab(22);

context.AddTomyTab(r);

IEnumerable<ObjectStateEntry> oseList = context.ObjectStateManager.GetObjectStateEntries(EntityState.Added);

foreach (ObjectStateEntry v in oseList)

{

Console.WriteLine("{0},{1},{2}", v.State, v.CurrentValues["ID"], v.EntitySet.Name);

}

//print:Added,22,myTab

ObjectStateManagerChanged 事件

CollectionChangeEventHandler(object sender, CollectionChangeEventArgs e)

e.Action : 集合操做行爲

System.ComponentModel.CollectionChangeAction.Add

System.ComponentModel.CollectionChangeAction.Refresh

System.ComponentModel.CollectionChangeAction.Remove

e.Element : 操做的實體對象

void ObjectStateManager_ObjectStateManagerChanged(object sender, CollectionChangeEventArgse)

{

Console.WriteLine(e.Action);
myTab v = e.Element as myTab;

Console.WriteLine("{0}",v.ID);

}

//===================================

myContext context = new myContext();

context.ObjectStateManager.ObjectStateManagerChanged+=newCollectionChangeEventHandler(ObjectStateManager_ObjectStateManagerChanged);

myTab r = myTab.CreatemyTab(22);

context.AddTomyTab(r);

*print:

Add

ObjectStateEntry 對象

基本屬性

IsRelationship 屬性
Entity 屬性
EntityKey 屬性
EntitySet 屬性

State 狀態屬性

EntityState 枚舉

myContext context = new myContext();

myTab r = myTab.CreatemyTab(22);

context.AddTomyTab(r);

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

Console.WriteLine(ose.State); //print:Added

CurrentValues 當前值

處於 deleted 或 detached 狀態的對象沒有當前值。

myContext context = new myContext();

myTab r = new myTab() { ID = 22, a = "wxwinter" };

context.AddTomyTab(r);

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

Console.WriteLine("{0},{1}",ose.CurrentValues["ID"],ose.CurrentValues["a"]);

//print: 22,wxwinter

OriginalValues 原始值

處於 added 或 detached 狀態的對象沒有原始值

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);

r.a = "wxwinter";

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

Console.WriteLine(ose.State);

Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]);

Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

* print:

Modified

CurrentValues :1,wxwinter

OriginalValues:1,aa

GetModifiedProperties 獲得被修改的屬性

返回IEnumerable<string>

獲得被修改的屬性集合

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);

r.a = "wxwinter";

r.b = "wxd";

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

IEnumerable<string> list = ose.GetModifiedProperties();

foreach (string pr in list)

{

Console.WriteLine(pr);

}

* print:

SetModified,SetModifiedProperty 標記爲修改

SetModified() 方法將記錄標記爲 EntityState.Modified

只是這樣,調用Context.SaveChanges方法是沒法保存修改到數據庫中的,Context.SaveChanges方法要查找被修改過的屬性,

可用SetModifiedProperty方法標記被修改過的屬性

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);

r.a = "wxwinter";

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);
ose.AcceptChanges();

Console.WriteLine(ose.State);

Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]);

Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

* print:

Unchanged

CurrentValues :1,wxwinter

OriginalValues:1,wxwinter

ose.SetModified();

ose.SetModifiedProperty("a");

Console.WriteLine(ose.State);

Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]);

Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

* print:

Modified

CurrentValues :1,wxwinter

OriginalValues:1,wxwinter

context.SaveChanges();

Delete 標記爲刪除

標記爲EntityState.Deleted

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

ose.Delete();

Console.WriteLine(ose.State); //print: Detached

Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

//print:OriginalValues:1,wxwinter

用 context.DeleteObject方法的效果與上例同樣

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);
ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(r);
context.DeleteObject(r);
Console.WriteLine(ose.State); //print: Detached
Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

//print:OriginalValues:1,wxwinter

AcceptChanges 方法

將記錄的狀態置爲EntityState.Unchanged

用[CurrentValues 當前值]替換[OriginalValues 原始值],

使用[ Context.AcceptAllChanges 方法]也有一樣效果

注意:狀態爲[EntityState.Deleted ]的記錄,會被[Detach]

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);
r.a = "wxwinter";

context.AcceptAllChanges();
ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

ose.AcceptChanges();

Console.WriteLine(ose.State);

Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]);

Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

* print:

Unchanged

CurrentValues :1,wxwinter

OriginalValues:1,wxwinter

當調用AcceptChanges時,若是對像處於[EntityState.Deleted ],會將對象移除集合,這時對像的狀態爲[EntityState.Detached ]

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

ose.Delete();

ose.AcceptChanges();

Console.WriteLine(ose.State); //print: Detached

保存修改到數據庫

Context.SaveChanges 方法

若是集合中有狀態爲EntityState.Added的記錄,用[CurrentValues 當前值]添加到數據庫中

若是集合中有狀態爲EntityState.Deleted的記錄,從數據庫是刪除與之對應的數據庫記錄

若是集合中有狀態爲EntityState.Modified的記錄,用[OriginalValues 原始值]與對應的數據庫記錄比效,查看併發, 用[CurrentValues 當前值]更新與之對應的數據庫記錄

SaveChanges(true)	將數據保存到數據庫後將全部記錄狀態標記爲EntityState.Unchanged ,(調用Context.AcceptAllChanges )
SaveChanges(true)	myContext context = new myContext(); myTab r = context.myTab.First(p => p.ID == 1); r.a = "wxwinter"; ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(r); context.SaveChanges(true); Console.WriteLine(ose.State); Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]); Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]); /* * print: Unchanged CurrentValues :1,wxwinter OriginalValues:1,wxwinter */
SaveChanges()	與SaveChanges(true)相同
SaveChanges(false)	將數據保存到數據庫, 但並不改變記錄狀態
SaveChanges(false)	myContext context = new myContext(); myTab r = context.myTab.First(p => p.ID == 1); r.a = "wxwinter"; ObjectStateEntry ose = context.ObjectStateManager.GetObjectStateEntry(r); context.SaveChanges(false); Console.WriteLine(ose.State); Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]); Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]); /* * print: Modified CurrentValues :1,wxwinter OriginalValues:1,aa */

Context.SavingChanges 事件

myContext context = new myContext();

context.SavingChanges+=new EventHandler(context_SavingChanges);

myTab r = context.myTab.First(p => p.ID == 1);
r.a = "wxwinter";
context.SaveChanges();

void context_SavingChanges(object sender, EventArgs e)

{

myContext context = sender as myContext;

Console.WriteLine(context.DefaultContainerName);

}

Context.AcceptAllChanges 方法

將全部記錄的狀態置爲EntityState.Unchanged

用[CurrentValues 當前值]替換[OriginalValues 原始值]

效果與對所在記錄的ObjectStateEntry上調用AcceptAllChanges同樣

注意:狀態爲[EntityState.Deleted ]的記錄,會被[Detach]

myContext context = new myContext();

myTab r = context.myTab.First(p => p.ID == 1);

r.a = "wxwinter";

context.AcceptAllChanges();

ObjectStateEntry ose= context.ObjectStateManager.GetObjectStateEntry(r);

Console.WriteLine(ose.State);

Console.WriteLine("CurrentValues :{0},{1}", ose.CurrentValues["ID"], ose.CurrentValues["a"]);

Console.WriteLine("OriginalValues:{0},{1}", ose.OriginalValues["ID"], ose.OriginalValues["a"]);

* print:

Unchanged

CurrentValues :1,wxwinter

OriginalValues:1,wxwinter

鏈接屬性

Context.DefaultContainerName 屬性

Context.Connection 屬性

Context.CommandTimeout 屬性

Context.MetadataWorkspace

數據刷新與併發

EF提供了兩種併發衝突處理方式：聽任無論方式和開放式併發。默認採用聽任無論的方式處理。

若是要使用開放式併發，必須設置相應屬性上的[併發模式]值[Fixed]

後修改數據的ObjectContext緩存了舊版本的數據時,當提交修改後系統就會拋出"OptimisticConcurrencyException"（開放式併發異常）。

當程序捕獲到異常之後，可使用ObjectContext的Refresh方法對異常採起處理。

緩存數據不會自動更新

公共

myContext context1 = new myContext();

myContext context2 = new myContext();

查詢

foreach (var r in context1.DBItem)

{

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

}

Console.WriteLine("---------------------");

foreach (var r in context2.DBItem)

{

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

}

a,this is a

b,this is b

c,this is c

---------------------

a,this is a

b,this is b

c,this is c

修改

DBItem dbitem1 = context1.DBItem.First(p => p.ItemID == "a");

dbitem1.ItemMatter = "hello";

context1.SaveChanges();

再查詢

foreach (var r in context1.DBItem)

{

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

}

Console.WriteLine("---------------------");

foreach (var r in context2.DBItem)

{

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

}

a,hello

b,this is b

c,this is c

---------------------

a,this is a

b,this is b

c,this is c

[併發模式]值爲[Fixed]的併發異常

注意,只有後修改數據的ObjectContext緩存了舊版本的數據時,長會產生異常

DBItem dbitem1 = context1.DBItem.First(p => p.ItemID == "a");

dbitem1.ItemMatter = "hello";

context1.SaveChanges();

DBItem dbitem2 = context2.DBItem.First(p => p.ItemID == "a");

dbitem2.ItemMatter = "wxwinter";

context2.SaveChanges();

ObjectContext.Refresh()

Refresh的第一個參數RefreshMode枚舉,RefreshMode.StoreWins,RefreshMode.ClientWins

StoreWins

StoreWins : Refresh之後，用數據庫的值回寫,當前的修改值被放棄

公共

myContext context1 = new myContext();

myContext context2 = new myContext();

查詢

foreach (var r in context1.DBItem)

{

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

}

Console.WriteLine("---------------------");

foreach (var r in context2.DBItem)

{

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

}

a,this is a

b,this is b

c,this is c

---------------------

a,this is a

b,this is b

c,this is c

修改

DBItem dbitem1 = context1.DBItem.First(p => p.ItemID == "a");

dbitem1.ItemMatter = "hello";

context1.SaveChanges();

DBItem dbitem2 = context2.DBItem.First(p => p.ItemID == "a");

dbitem2.ItemMatter = "wxwinter";

try

{

context2.SaveChanges();

}

catch

{

context2.Refresh( RefreshMode.StoreWins , dbitem2);

}

在System.Data.OptimisticConcurrencyException 中第一次偶然出現的"System.Data.Entity.dll"類型的異常

再查詢

foreach (var r in context1.DBItem)

{

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

}

Console.WriteLine("---------------------");

foreach (var r in context2.DBItem)

{

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

}

a,hello

b,this is b

c,this is c

---------------------

a,hello

b,this is b

c,this is c

ClientWins

StoreWins: Refresh之後，當前的修改值仍存在,只是告訴ObjectContext知到的併發問題了,這時再調用 ObjectContext.SaveChanges()時,ObjectContext就不會報[開放式併發異常]

DBItem dbitem1 = context1.DBItem.First(p => p.ItemID == "a");

dbitem1.ItemMatter = "hello";

context1.SaveChanges();

DBItem dbitem2 = context2.DBItem.First(p => p.ItemID == "a");

dbitem2.ItemMatter = "wxwinter";

try

{

context2.SaveChanges();

}

catch

{

context2.Refresh(RefreshMode.ClientWins, dbitem2);

context2.SaveChanges();

}

也能夠先Refresh()再SaveChanges(),而不用異常捕獲

DBItem dbitem1 = context1.DBItem.First(p => p.ItemID == "a");

dbitem1.ItemMatter = "hello";

context1.SaveChanges();

DBItem dbitem2 = context2.DBItem.First(p => p.ItemID == "a");

dbitem2.ItemMatter = "wxwinter";

context2.Refresh(RefreshMode.ClientWins, dbitem2);

context2.SaveChanges();

事務處理

同一SubmitChanges 會作默認的事務處理

下例因爲ItemID主鍵衝突,兩條數據都不會被插入

myContext context1 = new myContext();

DBItem item1 = new DBItem();

item1.ItemID = "w";

item1.ItemMatter = "wxwinter";

context1.AddObject("DBItem", item1);

DBItem item2 = new DBItem();

item2.ItemID = "w";

item2.ItemMatter = "wxd";

context1.AddObject("DBItem", item2);

context1.SaveChanges();

不一樣SubmitChanges 不會作事務處理

下例因爲ItemID主鍵衝突,後一條數據都不會被插入

myContext context1 = new myContext();

DBItem item1 = new DBItem();

item1.ItemID = "w";

item1.ItemMatter = "wxwinter";

context1.AddObject("DBItem", item1);

context1.SaveChanges();

myContext context2 = new myContext();

DBItem item2 = new DBItem();

item2.ItemID = "w";

item2.ItemMatter = "wxd";

context2.AddObject("DBItem", item2);

context2.SaveChanges();

System.Data.Common.DbTransaction

下例因爲ItemID主鍵衝突,兩條數據都不會被插入

myContext context1 = new myContext();

DBItem item1 = new DBItem();

item1.ItemID = "w";

item1.ItemMatter = "wxwinter";

context1.AddObject("DBItem", item1);

if (context1.Connection.State != ConnectionState.Open)

{

context1.Connection.Open();

}

System.Data.Common.DbTransaction tran = context1.Connection.BeginTransaction();

context1.SaveChanges();

try

{

DBItem item2 = new DBItem();

item2.ItemID = "w";

item2.ItemMatter = "wxd";

context1.AddObject("DBItem", item2);

context1.SaveChanges();

tran.Commit();

}

catch

{

tran.Rollback();

}

死鎖(兩個Context使用DbTransaction)

myContext context1 = new myContext();

DBItem item1 = new DBItem();

item1.ItemID = "w";

item1.ItemMatter = "wxwinter";

context1.AddObject("DBItem", item1);

if (context1.Connection.State != ConnectionState.Open)

{

context1.Connection.Open();

}

System.Data.Common.DbTransaction tran = context1.Connection.BeginTransaction();

context1.SaveChanges();

try

{

myContext context2 = new myContext();

DBItem item2 = new DBItem();

item2.ItemID = "w";

item2.ItemMatter = "wxd";

context2.AddObject("DBItem", item2);

context2.SaveChanges();

tran.Commit();

}

catch

{

tran.Rollback();

}

TransactionScope 事務(兩個Context)

System.Transactions.TransactionScope

可解決[死鎖(兩個Context使用DbTransaction)]

下例因爲ItemID主鍵衝突,兩條數據都不會被插入

using (System.Transactions.TransactionScope tc = new TransactionScope())

{

try

{

myContext context1 = new myContext();

DBItem item1 = new DBItem();

item1.ItemID = "w";

item1.ItemMatter = "wxwinter";

context1.AddObject("DBItem", item1);

context1.SaveChanges();

myContext context2 = new myContext();

DBItem item2 = new DBItem();

item2.ItemID = "w";

item2.ItemMatter = "wxd";

context2.AddObject("DBItem", item2);

context2.SaveChanges();

tc.Complete();

}

catch

{

}

ObjectQuery<T>數據加載方式

1. ObjectQuery<T> 提供了一個管理[實體對像]集合
2. ObjectQuery<T>繼承System.Data.Objects.ObjectQuery, ObjectQuery對ObjectContext進行了封裝，
3.能夠經過ObjectContext.CreateQuery<T>("esql")的方式建立ObjectQuery<T>
4.能夠經過new ObjectQuery<T>(ObjectContext,"esql")的方式建立ObjectQuery<T>,跟據SQL字串的不一樣，會獲得具體的ObjectQuery<值類型>，或ObjectQuery<DbDataRecord>或ObjectQuery<實體>

訪問方式

Context.CreateQuery<T>()

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);

}

ObjectQuery<DbDataRecord>

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());

}

ObjectQuery<簡單類型>

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() );

}

Execute方法與ObjectResult

Execute方法

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);

}

ObjectResult<T> 結果集

ObjectQuery<T>.Execute()方法返回ObjectResult<T>對象

類型轉換

OfType(TResultType)

ObjectQuery<TResultType> OfType<TResultType>();

myContext context = new myContext();

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

Linq方法

All

判斷集合中是否全部元素都知足某一條件

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]

Any

判斷集合中是否有元素知足某一條件

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]

Take

獲取集合的前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]

Skip

跳過集合的前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

First

集合的第一個元素,集合中沒有會報錯,

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]

FirstOrDefault

集合中的第一個元素,沒有則返回類型默認值,對象型默認值爲null

myContext context = new myContext();

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

if (fi != null)

{

Console.WriteLine(fi.ItemValue);

}

Where

用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]

Distinct

過濾集合中的相同項

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]

OrderBy,OrderByDescending

排序升,排序降

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

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

Average,Sum

平均值,求和

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

Max,Min

集合最大值，最小值

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

Count,LongCount

集合中的元素個數

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

Concat

鏈接不一樣集合，不會自動過濾相同項,兩個集合能夠不是同一個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]

Union

鏈接不一樣集合，自動過濾相同項,兩個集合要是同一個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]

UnionAll

兩個集合的相同項都會返回,兩個集合要是同一個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],

[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 ([Extent1].[ItemID] = 'c') OR ([Extent1].[ItemID] = 'a')

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 ([Extent2].[ItemID] = 'c') OR ([Extent2].[ItemID] = 'b')) AS [UnionAll1]

Except

從某集合中刪除其與另外一個集合中相同的項,兩個集合要是同一個Context

ObjectQuery<T> Except(ObjectQuery<T> query)

IQueryable<T> Except( IQueryable<T> query)

IQueryable<T> Except( 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.Except(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.Except(query1);

foreach (var r in v)

{

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

}

SELECT

[Except1].[AutoId] AS [C1],

[Except1].[NameID] AS [C2],

[Except1].[ItemID] AS [C3],

[Except1].[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])

EXCEPT

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 [Except1]

Intersect

獲取不一樣集合的相同項（交集）,兩個集合要是同一個Context

ObjectQuery<T> Intersect(ObjectQuery<T> query)

IQueryable<T> Intersect( IQueryable<T> query)

IQueryable<T> Intersect( 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.Intersect(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.Intersect(query1);

foreach (var r in v)

{

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

}

SELECT

[Intersect1].[AutoId] AS [C1],

[Intersect1].[NameID] AS [C2],

[Intersect1].[ItemID] AS [C3],

[Intersect1].[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])

INTERSECT

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 [Intersect1]

Select

射影

myContext context = new myContext();

var list = context.DBItemList.Select(p => new {a= p.ItemValue,p.NameID });

SELECT

1 AS [C1],

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

[Extent1].[NameID] AS [NameID]

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

GroupBy

分組,該方法分組結果集合

System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey,TElement>>

myContext context = new myContext();

var query = context.DBItemList.GroupBy(p => p.ItemID);

foreach (var g in query)

{

Console.WriteLine(g.Key);

foreach (var r in g)

{

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

}

23,a,n01,4

24,a,n01,5

25,a,n02,2

26,a,n02,3

27,a,n02,6

28,a,n03,3

11,b,n03,5

14,b,n01,2

16,b,n01,1

5,c,n01,4

7,c,n01,5

9,c,n02,2

10,c,n02,3

12,c,n02,6

17,c,n03,3

SELECT

[Project2].[ItemID] AS [ItemID],

[Project2].[C1] AS [C1],

[Project2].[C2] AS [C2],

[Project2].[AutoId] AS [AutoId],

[Project2].[NameID] AS [NameID],

[Project2].[ItemID1] AS [ItemID1],

[Project2].[ItemValue] AS [ItemValue]

FROM ( SELECT

[Distinct1].[ItemID] AS [ItemID],

1 AS [C1],

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

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

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

[Extent2].[ItemValue] AS [ItemValue],

CASE WHEN ([Extent2].[AutoId] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C2]

FROM (SELECT DISTINCT

[Extent1].[ItemID] AS [ItemID]

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

LEFT OUTER JOIN [dbo].[DBItemList] AS [Extent2] ON ([Extent2].[ItemID] = [Distinct1].[ItemID]) OR (([Extent2].[ItemID] ISNULL) AND ([Distinct1].[ItemID] IS NULL))

) AS [Project2]

ORDER BY [Project2].[ItemID] ASC, [Project2].[C2] ASC

Join

聯合查詢

myContext context1 = new myContext();

ObjectQuery<DBItem> query1 = context1.DBItem;

ObjectQuery<DBItemList> query2 = context1.DBItemList;

var v = query1.Join(query2, temp1 => temp1.ItemID, temp2 => temp2.ItemID, (temp1, temp2) => new { temp1.ItemID, temp1.ItemMatter, temp2.ItemValue, temp2.AutoId, temp2.NameID });

foreach (var r in v)

{

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

}

myContext context1 = new myContext();

ObjectQuery<DBItem> query1 = context1.DBItem;

ObjectQuery<DBItemList> query2 = context1.DBItemList;

var v = from temp1 in query1 join temp2 in query2 on temp1.ItemID equals temp2.ItemID

select new { temp1.ItemID, temp1.ItemMatter, temp2.ItemValue, temp2.AutoId,temp2.NameID };

foreach (var r in v)

{

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

}

5,c,n01,4,this is c

7,c,n01,5,this is c

9,c,n02,2,this is c

10,c,n02,3,this is c

11,b,n03,5,this is b

12,c,n02,6,this is c

14,b,n01,2,this is b

16,b,n01,1,this is b

17,c,n03,3,this is c

23,a,n01,4,this is a

24,a,n01,5,this is a

25,a,n02,2,this is a

26,a,n02,3,this is a

27,a,n02,6,this is a

28,a,n03,3,this is a

SELECT

1 AS [C1],

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

[Extent1].[ItemMatter] AS [ItemMatter],

[Extent2].[ItemValue] AS [ItemValue],

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

[Extent2].[NameID] AS [NameID]

FROM [dbo].[DBItem] AS [Extent1]

INNER JOIN [dbo].[DBItemList] AS [Extent2] ON ([Extent1].[ItemID] = [Extent2].[ItemID]) OR (([Extent1].[ItemID] IS NULL) AND([Extent2].[ItemID] IS NULL))

GroupJoin

myContext context1 = new myContext();

ObjectQuery<DBItem> query1 = context1.DBItem;

ObjectQuery<DBItemList> query2 = context1.DBItemList;

var v = query1.GroupJoin(query2, temp1 => temp1.ItemID, temp2 => temp2.ItemID, (temp1, temp2) => new { temp1.ItemID, temp1.ItemMatter, 個數 = temp2.Count() });

foreach (var r in v)

{

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

}

myContext context1 = new myContext();

ObjectQuery<DBItem> query1 = context1.DBItem;

ObjectQuery<DBItemList> query2 = context1.DBItemList;

var v = from temp1 in query1

join temp2 in query2 on temp1.ItemID equals temp2.ItemID

into newtab

select new { temp1.ItemID, temp1.ItemMatter, 個數 = newtab.Count() };

foreach (var r in v)

{

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

}

a,this is a,6

b,this is b,3

c,this is c,6

SELECT

1 AS [C1],

[Project1].[ItemID] AS [ItemID],

[Project1].[ItemMatter] AS [ItemMatter],

[Project1].[C1] AS [C2]

FROM ( SELECT

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

[Extent1].[ItemMatter] AS [ItemMatter],

(SELECT

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

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

WHERE ([Extent1].[ItemID] = [Extent2].[ItemID]) OR (([Extent1].[ItemID] IS NULL) AND ([Extent2].[ItemID] IS NULL)))AS [C1]

FROM [dbo].[DBItem] AS [Extent1]

) AS [Project1]

無效的Linq方法

可將ObjectQuery<T>轉換爲List<T>後使用 List的對應方法

Aggregate

據輸入的表達式獲取一個聚合值

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

DBItemList r = list.Aggregate((x, y) => new DBItemList() { ItemValue = x.ItemValue + y.ItemValue });

Console.WriteLine("ItemValue合計爲:{0}", r.ItemValue);

//print: ItemValue合計爲:54

TakeWhile

條件第一次不成立就跳出循環

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

IEnumerable<DBItemList> v = list.TakeWhile(p => p.ItemValue >= 2);

foreach (var r in v)

{

Console.WriteLine(r.ItemValue);

}

//print

SkipWhile

條件第一次不成立就失效，將後面的數據全取

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

IEnumerable<DBItemList> v = list.SkipWhile(p => p.ItemValue >= 2);

foreach (var r in v)

{

Console.WriteLine(r.ItemValue);

}

//print

Reverse

順序返轉

myContext context = new myContext();

IEnumerable<DBItemList> list = context.DBItemList.AsEnumerable();

IEnumerable<DBItemList> v = list.Reverse();

Last,LastOrDefault

集合的最後一個元素,集合中沒有會報錯,

集合中的最後一個元素,沒有則返回類型默認值,對象型默認值爲null

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

DBItemList l1 = list.Last();

DBItemList li = list.Last(p=>p.ItemValue==5);

DBItemList lid = list.LastOrDefault(p => p.ItemValue == 15);

if (lid != null)

{

Console.WriteLine(lid.ItemValue);

}

Single,SingleOrDefault

集合中符合條件的惟一元素,集合中沒有會報錯,集合中有兩個以上會報錯

集合中符合條件的惟一元素,集合中有兩個以上會報錯,集合中沒有則返回類型默認值,對象型默認值爲null

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

DBItemList di = list.Single(p=>p.ItemValue==5);

DBItemList did = list.SingleOrDefault(p => p.ItemValue == 15);

if (did != null)

{

Console.WriteLine(did.ItemValue);

}

Contains

判斷集合中是否包含有某一元素

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

DBItemList r = new DBItemList();

r.ItemValue = 3;

bool b = list.Contains(r,new c());

class c : IEqualityComparer<DBItemList>

{

public bool Equals(DBItemList x, DBItemList y)

{

if (x.ItemValue == y.ItemValue)

{

return true;

}

else

{

return false;

}

public int GetHashCode(DBItemList obj)

{

return 0;

}

Distinct

過濾集合中的相同項

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

IEnumerable<DBItemList> v = list.Distinct(new c());

class c : IEqualityComparer<DBItemList>

{

public bool Equals(DBItemList x, DBItemList y)

{

if (x.ItemValue == y.ItemValue)

{

return true;

}

else

{

return false;

}

public int GetHashCode(DBItemList obj)

{

return 0;

}

ElementAt,ElementAtOrDefault

集合中指定索引的元素

集合中指定索引的元素,沒有則返回類型默認值,對象型默認值爲null

myContext context = new myContext();

List<DBItemList> list = context.DBItemList.ToList();

DBItemList r = list.ElementAt(5);

DBItemList rd = list.ElementAtOrDefault(50);

DefaultIfEmpty

若是集合是的無素爲空(count==0),就向集合中插入一個默認元素

DBItemList r=new DBItemList();

r.ItemValue=100;

List<DBItemList> list = new List<DBItemList>();

var pp = list.DefaultIfEmpty(r);

SelectMany

myContext context = new myContext();

List<DBItemList> query = context.DBItemList.ToList();

IEnumerable<string> ls=query.SelectMany(p => p.NameID.Split('0'));

foreach (string r in ls)

{

Console.WriteLine(r);

}

Lambda表達式

List<string> ls = new List<string>() { "wxd/1", "lzm/2", "wxwinter/3" };

var li = ls.SelectMany(p => p.Split('/'));

foreach (var s in li)

{

Console.WriteLine(s);

}

對應Select效果

var ll = ls.Select(p => p.Split('/'));

foreach (var s in ll)

{

foreach (var ss in s)

{

Console.WriteLine(ss);

}

SequenceEqual

比較兩個序列是否相等，能夠指定相等比較方法

myContext context = new myContext();

List<DBItemList> list1 = context.DBItemList.Where(p => p.ItemID == "a" ).ToList();

List<DBItemList> list2 = context.DBItemList.Where(p => p.ItemID == "a").ToList();

bool b = list1.SequenceEqual(list2);

Console.WriteLine(b);

//print:True

比起 LINQ to SQL，EF 除了提供 LINQ 查詢方式, 還提供了 Entity SQL language

ESQL 相似 Hibernate 的 HSQL，ESQL 與SQL 語言的語法類似，以字符串的方式執行

esql的查詢結果集 ObjectQuery

ObjectQuery<實體>

myContext context = new myContext();

string esql = "SELECT VALUE DBItemList FROM myContext.DBItemList";

// ObjectQuery<DBItemList> query = new ObjectQuery<DBItemList>(esql, context);

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

Console.WriteLine(r.NameID);

}

myContext context = new myContext();

string esql = "SELECT VALUE it FROM myContext.DBItemList as it";

// ObjectQuery<DBItemList> query = new ObjectQuery<DBItemList>(esql, context);

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

Console.WriteLine(r.NameID);

}

ObjectQuery<DbDataRecord>

myContext context = new myContext();

string esql = "SELECT it.NameID FROM myContext.DBItemList as it";

//ObjectQuery<DbDataRecord> query = new ObjectQuery<DbDataRecord>(esql, context);

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine(r["NameID"].ToString());

}

ObjectQuery<簡單類型>

myContext context = new myContext();

string esql = "SELECT value count(it.NameID) FROM myContext.DBItemList as it";

// ObjectQuery<int> query = new ObjectQuery<int>(esql, context);

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

myContext context = new myContext();

string esql = "SELECT value it.NameID FROM myContext.DBItemList as it";

// ObjectQuery<int> query = new ObjectQuery<int>(esql, context);

ObjectQuery<string> query = context.CreateQuery<string>(esql);

foreach (string n in query)

{

Console.WriteLine(n);

}

esql的使用

能夠在

ObjectQuery的Linq方法,
構造ObjectQuery,
context.CreateQuery返方法,

中使用esql,並獲得返回的欖查詢結果ObjectQuery

it關鍵字

[it] 出如今 ESQL 中, 由 ObjectQuery<T>.Name 屬性設定，用於標示源查詢對象(ObjectQuery)的名稱，

相似於 "SELECT * FROM Tab as it WHERE it.ItemValue =14" 。

能夠將這個默認值 "it" 改爲其餘字符串。

myContext context = new myContext();

context.DBItemList.Name = "wxd";

ObjectQuery<DBItemList> list = context.DBItemList.Where("wxd.ItemValue=5");

myContext context = new myContext();

var sql = "SELECT VALUE DBItemList FROM myContext.DBItemList";

var query = new ObjectQuery<DBItemList>(sql, context);

query.Name = "wxd";

ObjectQuery<DBItemList> list = query.Where("wxd.ItemValue=@v", newObjectParameter("v", 5));

value 關鍵字

value 後只能返回一個成員

myContext context = new myContext();

string esql = "SELECT value AVG(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

/* print:

string esql = "select value it.ItemID from myContext.DBItemList as it";

ObjectQuery<string> query = context.CreateQuery<string>(esql);

foreach (string r in query)

{

Console.WriteLine(r);

}

myContext context = new myContext();

string esql = "select value row( it.ItemValue ,it.NameID,'wxd' as wxwinter) from myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1},{2}", r["ItemValue"], r["NameID"], r["wxwinter"]);

}

查詢參數的使用

myContext context = new myContext();

string esql = "SELECT VALUE it FROM myContext.DBItemList as it where it.ItemValue=@v1 or it.NameID=@v2";

ObjectParameter v1 = new ObjectParameter("v1", 3);

ObjectParameter v2 = new ObjectParameter("v2", "n01");

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql,v1,v2);

foreach (DBItemList r in query)

{

Console.WriteLine("{0},{1}",r.NameID,r.ItemValue);

}

中文字段

使用[]將字段括起來

myContext context = new myContext();

ObjectQuery<typeTest> query = context.typeTest.Where("it.值 ==22.22");

System.Console.WriteLine(query.CommandText);

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}", r.a, r.b, r.c, r.d, r.e, r.值);

}

myContext context = new myContext();

ObjectQuery<typeTest> query = context.typeTest.Where("it.[值] ==22.22");

System.Console.WriteLine(query.CommandText);

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}", r.a, r.b, r.c, r.d, r.e, r.值);

}

獲得esql與sql字串

myContext context = new myContext();

string esql = "SELECT VALUE it FROM myContext.DBItemList as it";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

Console.WriteLine(query.CommandText);

Console.WriteLine(query.ToTraceString())

SELECT VALUE it FROM myContext.DBItemList as it

SELECT

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

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

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

[Extent1].[ItemValue] AS [ItemValue]

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

CommandText屬性

獲得esql字串

ToTraceString方法

獲得sql字串

ObjectQuery的Linq方法

Where

用字符串爲條件進行查詢

ObjectQuery<T> Where(string predicate, params ObjectParameter[] parameters);

myContext context = new myContext();

ObjectQuery<DBItemList> list = context.DBItemList.Where("(it.ItemValue=5 or it .ItemValue=5) and it.NameID='n01'");

SELECT

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

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

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

[Extent1].[ItemValue] AS [ItemValue]

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

WHERE (([Extent1].[ItemValue] = 5) OR ([Extent1].[ItemValue] = 5)) AND([Extent1].[NameID] = 'n01')

OrderBy

排序

ObjectQuery<T> OrderBy(string keys, params ObjectParameter[] parameters);

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.OrderBy("it.ItemValue,it.ItemID desc");

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

Select

射影

ObjectQuery<DbDataRecord> Select(string projection, params ObjectParameter[] parameters);

myContext context = new myContext();

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

SELECT

1 AS [C1],

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

[Extent1].[NameID] AS [NameID]

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

SelectValue(projection)

返回只有一組字段的數組

ObjectQuery<TResultType> SelectValue<TResultType>(string projection, paramsObjectParameter[] parameters);

myContext context = new myContext();

ObjectQuery<int> query = context.DBItemList.SelectValue<int>("it.ItemValue + it.AutoID");

foreach (var r in query)

{

Console.WriteLine(r);

}

SELECT

[Extent1].[ItemValue] + [Extent1].[AutoId] AS [C1]

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

Top(count)

集合的前n個元素

count : 前n個元素

ObjectQuery<T> Top(string count, params ObjectParameter[] parameters);

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.Top("3"); ;

foreach (var r in query)

{

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

}

SELECT TOP (3)

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

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

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

[c].[ItemValue] AS [ItemValue]

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

Skip(keys,count)

跳過集合的前n個元素,

keys : 用於排序的字段

count : 要跳過的記錄個數

ObjectQuery<T> Skip(string keys, string count, params ObjectParameter[] parameters);

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.Skip("it.ItemValue", "5");

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 ( 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

分頁 Skip Top

Skip與Top一塊兒使用

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.Skip("it.ItemValue", "5").Top("3"); ;

foreach (var r in query)

{

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

}

SELECT TOP (3)

[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

GroupBy(keys,projection)

分組

keys: GROUP BY的字段

projection : Select 的內容

ObjectQuery<DbDataRecord> GroupBy(string keys, string projection, paramsObjectParameter[] parameters);

myContext context = new myContext();

ObjectQuery<DbDataRecord> query = context.DBItemList.GroupBy("it.ItemID","it.ItemID,Sum(it.ItemValue) as ValueSum");

foreach (var r in query)

{

Console.WriteLine("{0},{1}", r["ItemID"], r["ValueSum"]);

}

a,23

b,8

c,23

SELECT

1 AS [C1],

[GroupBy1].[K1] AS [ItemID],

[GroupBy1].[A1] AS [C2]

FROM ( SELECT

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

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

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

GROUP BY [Extent1].[ItemID]

) AS [GroupBy1]

SELECT it.ItemID,Sum(it.ItemValue) as ValueSum

FROM ( [DBItemList] ) AS it

GROUP BY it.ItemID

Include(path)

加載關聯數據,參數爲實體的[導航屬性]的字串,調用Include("導航屬性")後,關聯數據會加載,這樣就不用在[實體.導航屬性]上調用Load()方法

ObjectQuery<T> Include(string path);

myContext context = new myContext();

var r = context.DBItem.Include("DBItemList");

foreach (var dbitem in r)

{

foreach (var dbitemlist in dbitem.DBItemList)

{

Console.WriteLine("{0},{1}", dbitemlist.NameID, dbitemlist.ItemValue);

}

效果與下例相同

myContext context = new myContext();

var r = context.DBItem;

foreach (var dbitem in r)

{

dbitem.DBItemList.Load();

foreach (var dbitemlist in dbitem.DBItemList)

{

Console.WriteLine("{0},{1}", dbitemlist.NameID, dbitemlist.ItemValue);

}

esql註釋,成員訪問,分行

註釋	--
成員訪問	.
分行	;

esql運算符

算術運算符

加	+
減	-
乘	*
除	/
模	%
負	-

比效運算符

等於	=
大於	>
大於等於	>=
空判斷	IS NOT NULL IS NULL
小於	<
小天等於	<=
不等於	!= <>
字符比效	LIKE '' NOT LIKE ''
字符比效	% : _ : [ ] : [^] :

邏輯運算符

與

AND

非

NOT

或

區間

BETWEEN

之間

BETWEEN n AND m

NOT BETWEEN n AND m

myContext context = new myContext();

string esql = "SELECT VALUE it FROM [DBItemList] AS it WHERE it.ItemValue BETWEEN 2 and 4";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.Where(" it.ItemValue not BETWEEN 2 and 4");

foreach (DBItemList r in query)

{

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

}

在集合中

IN {v,v}

NOT IN{v,v}

myContext context = new myContext();

string esql = "SELECT VALUE it FROM [DBItemList] AS it WHERE it.ItemValue IN {1,2,3}";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.Where("it.ItemValue not IN {1,2,3}");

foreach (DBItemList r in query)

{

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

}

EXISTS

存在

EXISTS(select from)

NOT EXISTS(select from)

myContext context = new myContext();

string esql = "SELECT VALUE it FROM [DBItemList] AS it WHERE exists(Select VALUE it2 From DBItem as it2 Where it2.ItemID=it.ItemID )";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

myContext context = new myContext();

ObjectQuery<DBItemList> query = context.DBItemList.Where("exists(Select VALUE it2 From DBItem as it2 Where it2.ItemID=it.ItemID )");

foreach (DBItemList r in query)

{

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

}

分頁

SELECT VALUE it FROM ( [DBItemList] ) AS it

ORDER BY it.ItemValue

SKIP 5

LIMIT 3

集合運算

Union

(合集)

鏈接不一樣集合

UNION --自動過濾相同項

UNION ALL --兩個集合的相同項都會返回

myContext context = new myContext();

string esql = "(select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'a' ) UNION (select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'b' )";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

EXCEPT

(左並集)

從集合中刪除其與另外一個集合中相同的項

myContext context = new myContext();

string esql = "(select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'a' ) EXCEPT (select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'b' )";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

INTERSECT

（交集）

獲取不一樣集合的相同項

myContext context = new myContext();

string esql = "(select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'a' ) INTERSECT (select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID == 'b' )";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

ANYELEMENT

集合中的第一個

myContext context = new myContext();

string esql = "ANYELEMENT(select value it from myContext.DBItemList as it where it.ItemID == 'a') ";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

//若是集合中有兩個以上,只返回第一個到集合中

foreach (DBItemList r in query)

{

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

}

SELECT

[Element1].[AutoId] AS [AutoId],

[Element1].[NameID] AS [NameID],

[Element1].[ItemID] AS [ItemID],

[Element1].[ItemValue] AS [ItemValue]

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

LEFT OUTER JOIN (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 [Extent1].[ItemID] = 'a' ) AS [Element1] ON 1 =1

OVERLAPS

兩個集合是否有相交部份

myContext context = new myContext();

string esql = "(select value it from myContext.DBItemList as it where it.ItemID == 'c' || it.ItemID=='b' ) OVERLAPS (select value it from myContext.DBItemList as it where it.ItemID == 'a' || it.ItemID=='b')";

ObjectQuery<bool> query = context.CreateQuery<bool>(esql);

foreach (bool r in query)

{

Console.WriteLine(r);

}

//print: True

SELECT

CASE WHEN ( EXISTS (SELECT

cast(1 as bit) AS [C1]

FROM (SELECT

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

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

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

[Extent1].[ItemValue] AS [ItemValue]

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

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

INTERSECT

SELECT

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

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

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

[Extent2].[ItemValue] AS [ItemValue]

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

WHERE ([Extent2].[ItemID] = 'a') OR([Extent2].[ItemID] = 'b')) AS [Intersect1]

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

cast(1 as bit) AS [C1]

FROM (SELECT

[Extent3].[AutoId] AS [AutoId],

[Extent3].[NameID] AS [NameID],

[Extent3].[ItemID] AS [ItemID],

[Extent3].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent3]

WHERE ([Extent3].[ItemID] = 'c') OR([Extent3].[ItemID] = 'b')

INTERSECT

SELECT

[Extent4].[AutoId] AS [AutoId],

[Extent4].[NameID] AS [NameID],

[Extent4].[ItemID] AS [ItemID],

[Extent4].[ItemValue] AS [ItemValue]

FROM [dbo].[DBItemList] AS [Extent4]

WHERE ([Extent4].[ItemID] = 'a') OR([Extent4].[ItemID] = 'b')) AS [Intersect2]

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

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

Set

去掉重複項

myContext context = new myContext();

string esql = "set(select value it.ItemID from myContext.DBItemList as it)";

ObjectQuery<string> query = context.CreateQuery<string>(esql);

foreach (string r in query)

{

Console.WriteLine(r);

}

//去掉了重複項

SELECT

[Distinct1].[ItemID] AS [ItemID]

FROM ( SELECT DISTINCT

[Extent1].[ItemID] AS [ItemID]

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

) AS [Distinct1]

esql函數

統計類

Avg

平均值

myContext context = new myContext();

string esql = "SELECT value AVG(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

/* print:

BigCount

個數(long)

myContext context = new myContext();

string esql = "SELECT value BigCount(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<long> query = context.CreateQuery<long>(esql);

foreach (long n in query)

{

Console.WriteLine(n);

}

/* print:

Count

個數(int)

myContext context = new myContext();

string esql = "SELECT value Count(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

/* print:

Max

最大值

myContext context = new myContext();

string esql = "SELECT value Max(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

/* print:

Min

最小值

myContext context = new myContext();

string esql = "SELECT value Min(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

/* print:

Sum

合計

myContext context = new myContext();

string esql = "SELECT value Sum(it.ItemValue) FROM myContext.DBItemList as it";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int n in query)

{

Console.WriteLine(n);

}

/* print:

聯合使用

myContext context = new myContext();

string esql = "SELECT Max(it.ItemValue) as Max , Min(it.ItemValue) as Min FROM myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("Max:{0},Min:{1}", r["Max"], r["Min"]);

}

/* print:

Max:6,Min:1

與group by一塊兒使用

myContext context = new myContext();

string esql = "SELECT ID as ItemID , Max(it.ItemValue) as Max , Min(it.ItemValue) as Min FROM myContext.DBItemList as it group by it.ItemID as ID";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("ItemID:{0}, Max:{1},Min:{2}", r["ItemID"], r["Max"], r["Min"]);

}

/* print:

ItemID:a, Max:6,Min:2

ItemID:b, Max:5,Min:1

ItemID:c, Max:6,Min:2

數學類

Abs

絕對值

Abs(-2)

Round

隨機數

Round(748.58)

日期

CurrentDateTime()
CurrentDateTimeOffset()
CurrentUtcDateTime()
Day( expression )	Day(cast('03/12/1998' as DateTime)) --返回:12
GetTotalOffsetMinutes	--返回: SQL Server 2008 only
Hour ( expression )	Hour(cast('22:35:5' as DateTime)) --返回:22
Minute( expression )	Minute(cast('22:35:5' as DateTime)) --返回:35
Month (expression)	Month(cast('03/12/1998' as DateTime)) --返回:3
Second( expression )	Second(cast('22:35:5' as DateTime)) --返回:5
Year( expression )	Year(cast('03/12/1998' as DateTime)) --返回:1998

字符

Concat ( string1, string2) 字符串鏈接	Concat('abc', 'xyz') --返回:abcxyz
IndexOf( string1, string2) 字符串位置查找	IndexOf('xyz', 'abcxyz') --返回:4
Length ( string ) 字符串長度	Legth('abcxyz') --返回:6
Reverse ( string ) 字符串反轉	Reverse('abcd') --返回:dcba
ToLower( string ) 大寫轉小寫	ToLower('ABC') --返回:abc
ToUpper( string ) 小寫轉大寫	ToUpper('abc') --返回:ABC
Trim( string ) 去兩端空格	Trim(' abc ') --返回:abc
LTrim( string ) 去左端空格	LTrim(' abc') --返回:abc
RTrim( string ) 去右端空格
Left ( string, length) 左端截取	Left('abcxyz', 3) --返回:abc
Right ( string, length) 右端截取	Right('abcxyz', 3) --返回:xyz
Substring ( string, start, length) 兩端截取	Substring('abcxyz', 4, 3) --返回:xyz

esql語句

查詢語句

SELECT

myContext context = new myContext();

string esql = "SELECT it.ItemValue as a,it.NameID FROM [DBItemList] AS it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1}", r["a"], r["NameID"]);

}

SELECT

1 AS [C1],

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

[Extent1].[NameID] AS [NameID]

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

WHERE

myContext context = new myContext();

string esql = "SELECT VALUE it FROM [DBItemList] AS it WHERE (it.ItemValue=5 or it .ItemValue=5) and it.NameID='n01' ";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

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

}

SELECT

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

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

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

[Extent1].[ItemValue] AS [ItemValue]

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

WHERE (([Extent1].[ItemValue] = 5) OR ([Extent1].[ItemValue]= 5)) AND ([Extent1].[NameID] = 'n01')

GROUP BY

myContext context = new myContext();

string esql = "SELECT it.ItemID,Sum(it.ItemValue) as ValueSum FROM [DBItemList] AS it GROUP BY it.ItemID ";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1}", r["ItemID"], r["ValueSum"]);

}

SELECT

1 AS [C1],

[GroupBy1].[K1] AS [ItemID],

[GroupBy1].[A1] AS [C2]

FROM ( SELECT

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

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

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

GROUP BY [Extent1].[ItemID]

) AS [GroupBy1]

ORDER BY

myContext context = new myContext();

string esql = "SELECT VALUE it FROM [DBItemList] AS it ORDER BY it.ItemValue,it.ItemID desc ";

ObjectQuery<DBItemList> query = context.CreateQuery<DBItemList>(esql);

foreach (DBItemList r in query)

{

Console.WriteLine("{0},{1}", r.ItemID, 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

HAVING

myContext context = new myContext();

string esql = "SELECT it.ItemID,Count(it.ItemValue) as ValueSum FROM DBItemList AS it GROUP BY it.ItemID HAVING SUM(it.ItemValue) > 5";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1}", r["ItemID"], r["ValueSum"]);

}

SELECT

1 AS [C1],

[GroupBy1].[K1] AS [ItemID],

[GroupBy1].[A2] AS [C2]

FROM ( SELECT

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

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

COUNT([Extent1].[ItemValue]) AS [A2]

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

GROUP BY [Extent1].[ItemID]

) AS [GroupBy1]

WHERE [GroupBy1].[A1] > 5

JOIN

Cross Joins

Inner Joins

Left Outer Joins

Right Outer Joins

Full Outer Joins

CASE語句

CASE WHEN THEN ELSE END

myContext context = new myContext();

string esql = "select it.ItemID, it.ItemValue ,(Case when it.ItemValue =1 then '差' when it.ItemValue between 2 and 4 then '好' else '其餘' end) as ItemValueRemarks from myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1},{2}", r["ItemID"], r["ItemValue"], r["ItemValueRemarks"]);

}

c,4,好

c,5,其餘

c,2,好

c,3,好

b,5,其餘

c,6,其餘

b,2,好

b,1,差

c,3,好

a,4,好

a,5,其餘

a,2,好

a,3,好

a,6,其餘

a,3,好

esql 類型

簡單類型

Null

is Null

is not Null

myContext context = new myContext();

ObjectQuery<typeTest> query = context.typeTest.Where("it.b is not Null");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

Boolean

True,False

myContext context = new myContext();

ObjectQuery<typeTest> query = context.typeTest.Where("it.e==True");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

Integer

Float,Double

Decimal

123

123.456

23.34

myContext context = new myContext();

ObjectQuery<typeTest> query = context.typeTest.Where("it.c==123");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

String

"abcd"

N"U字符"

'abcd'

myContext context = new myContext();

// ObjectQuery<typeTest> query = context.typeTest.Where("it.b==N'鼕鼕'");

ObjectQuery<typeTest> query = context.typeTest.Where("it.b==\"鼕鼕\" ");

// ObjectQuery<typeTest> query = context.typeTest.Where("it.b=='鼕鼕'");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

DateTime

DATETIME'2007-11-11 22:22'

DATETIME'2007-11-11 01:01:00.0000000'

myContext context = new myContext();

// ObjectQuery<typeTest> query = context.typeTest.Where("it.d==DATETIME'1977-11-11 00:00:00.000'");

ObjectQuery<typeTest> query = context.typeTest.Where("it.d==cast('1977-11-11' as System.DateTime)");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

Time

TIME'22:11'

TIME'01:02:03.1234567'

DateTimeOffset

DATETIMEOFFSET'2007-11-11 22:11 +02:00'

DATETIMEOFFSET'2007-11-11 01:01:00.0000000 -02:00'

Binary

Binary'00ffaabb'

X'ABCabc'

BINARY '0f0f0f0F0F0F0F0F0F0F'

X'' –空

Guid

Guid'0321AF86-0AA5-4a86-A086-1D789FA54AA3'

GUID '0321AF86-0AA5-4a86-A086-1D789FA54AA3'

myContext context = new myContext();

ObjectQuery<typeTest> query = context.typeTest.Where("it.a==Guid'0321af86-0aa5-4a86-a086-1d789fa54aa3'");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

REF

myContext context = new myContext();

//string esql = "SELECT it.ItemID FROM DBItem as it";

string esql = "SELECT REF(it).ItemID FROM DBItem as it";

ObjectQuery<DbDataRecord> v = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in v)

{

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

}

ROW

myContext context = new myContext();

string esql = "select value row( it.ItemValue ,it.NameID,'wxd' as wxwinter) from myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1},{2}", r["ItemValue"], r["NameID"], r["wxwinter"]);

}

myContext context = new myContext();

string esql = "select row( it.ItemValue ,it.NameID) as wxd ,it.ItemID from myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

DbDataRecord v = r["wxd"] as DbDataRecord;

Console.WriteLine("{0},{1},{2}", r["ItemID"],v["ItemValue"],v["NameID"]);

}

集合

MULTISET(1,2,3,4)

{1,2,3,4}

SELECT VALUE it FROM [DBItemList] AS it WHERE it.ItemValue IN {1,2,3}

myContext context = new myContext();

string esql = "{1,2,3} ";

ObjectQuery<int> query = context.CreateQuery<int>(esql);

foreach (int r in query)

{

System.Console.WriteLine(r);

}

SELECT

[UnionAll2].[C1] AS [C1]

FROM (SELECT

[UnionAll1].[C1] AS [C1]

FROM (SELECT

1 AS [C1]

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

UNION ALL

SELECT

2 AS [C1]

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

UNION ALL

SELECT

3 AS [C1]

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

myContext context = new myContext();

string esql = "{row(1 as a,'wxd' as wxwinter),row(2 as a,'lzm' as wxwinter),row(3 as a,'wxwinter' as wxwinter)} ";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

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

}

1,wxd

2,lzm

3,wxwinter

SELECT

1 AS [C1],

CASE WHEN ([UnionAll2].[C1] = 0) THEN 1 WHEN ([UnionAll2].[C1] = 1)THEN 2 ELSE 3 END AS [C2],

CASE WHEN ([UnionAll2].[C1] = 0) THEN 'wxd' WHEN ([UnionAll2].[C1] = 1)THEN 'lzm' ELSE 'wxwinter' END AS [C3]

FROM (SELECT

[UnionAll1].[C1] AS [C1]

FROM (SELECT

0 AS [C1]

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

UNION ALL

SELECT

1 AS [C1]

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

UNION ALL

SELECT

2 AS [C1]

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

Object 返回對像

Select 選出的值能夠直接建立爲對像後,將對像放入字段中返回

myContext context = new myContext();

string esql = "SELECT [WindowsFormsApplication8].[DBItemEx](it.ItemID + 'b') as myObject FROM DBItem as it";

ObjectQuery<DbDataRecord> v = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in v)

{

DBItemEx obj = r["myObject"] as DBItemEx;

Console.WriteLine("{0}", obj.ItemID);

}

CAST 類型轉換

myContext context = new myContext();

string esql = "select value CAST(it.ItemValue as System.String) from myContext.DBItemList as it";

ObjectQuery<string> query = context.CreateQuery<string>(esql);

foreach (string r in query)

{

Console.WriteLine(r);

}

myContext context = new myContext();

string esql = "using System;select value CAST(it.ItemValue as String) from myContext.DBItemList as it";

ObjectQuery<string> query = context.CreateQuery<string>(esql);

foreach (string r in query)

{

Console.WriteLine(r);

}

CAST( d as Edm.Decimal(16, 2) )

OFTYPE

OFTYPE ( expression, [ONLY] test_type )

myContext context = new myContext();

string esql = "OFTYPE(((SELECT VALUE it FROM DBItem as it) ),[WindowsFormsApplication8].[DBItemEx])";

ObjectQuery<DBItemEx> v = context.CreateQuery<DBItemEx>(esql);

與以下效果相同

myContext context = new myContext();

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

TREAT

myContext context = new myContext();

string esql = "SELECT TREAT(it AS [WindowsFormsApplication8].[DBItemEx]) FROM DBItem AS it";

ObjectQuery<DbDataRecord> v = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in v)

{

DBItemEx obj = r[0] as DBItemEx;

if (obj != null)

{

Console.WriteLine("{0}", obj.ItemID);

}

與以下效果相似

myContext context = new myContext();

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

IS 類型判斷

myContext context = new myContext();

string esql = "SELECT TREAT(it AS [WindowsFormsApplication8].[DBItemEx]) FROM DBItem AS it WHERE it IS OF ([WindowsFormsApplication8].[DBItemEx])";

ObjectQuery<DbDataRecord> v = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in v)

{

DBItemEx obj = r[0] as DBItemEx;

// if (obj != null)

{

Console.WriteLine("{0}", obj.ItemID);

}

與以下效果相似

myContext context = new myContext();

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

esql Namespace

使用SqlServer函數

using SqlServer;

myContext context = new myContext();

string esql = "using SqlServer;select it.ItemValue ,LEN(it.NameID) as NameIDLEN from myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1}",r["ItemValue"],r["NameIDLEN"]);

}

SqlServer.函數

myContext context = new myContext();

string esql = "select it.ItemValue ,SqlServer.LEN(it.NameID) as NameIDLEN from myContext.DBItemList as it";

ObjectQuery<DbDataRecord> query = context.CreateQuery<DbDataRecord>(esql);

foreach (DbDataRecord r in query)

{

Console.WriteLine("{0},{1}",r["ItemValue"],r["NameIDLEN"]);

}

SELECT

1 AS [C1],

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

LEN([Extent1].[NameID]) AS [C2]

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

使用NET的數據類型

myContext context = new myContext();

string esql = "using System;select value CAST(it.ItemValue as String) from myContext.DBItemList as it";

ObjectQuery<string> query = context.CreateQuery<string>(esql);

foreach (string r in query)

{

Console.WriteLine(r);

}

myContext context = new myContext();

// ObjectQuery<typeTest> query = context.typeTest.Where("it.d==DATETIME'1977-11-11 00:00:00.000'");

ObjectQuery<typeTest> query = context.typeTest.Where("it.d==cast('1977-11-11' as System.DateTime)");

foreach (typeTest r in query)

{

Console.WriteLine("{0},{1},{2},{3},{4},{5}",r.a,r.b,r.c,r.d,r.e,r.值);

}

esql關係,導航

KEY

myContext context = new myContext();

string esql="SELECT VALUE [TargetEntity] FROM (SELECT VALUE x FROM [myContext].[FK_DBItemList_DBItem] AS x WHERE Key(x.[DBItem]) = ROW(@EntityKeyValue1 AS EntityKeyValue1)) AS [AssociationEntry] INNER JOIN [myContext].[DBItemList] AS [TargetEntity] ON Key([AssociationEntry].[DBItemList]) = Key(Ref([TargetEntity]))";

ObjectQuery<DBItemList> dbitemlist = context.CreateQuery<DBItemList>(esql, newObjectParameter("EntityKeyValue1", "a"));

foreach (DBItemList r in dbitemlist)

{

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

}

效果同下

myContext context = new myContext();

ObjectQuery<DBItemList> dbitemlist = context.DBItem.First(p => p.ItemID =="a").DBItemList.CreateSourceQuery();

foreach (DBItemList r in dbitemlist)

{

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

}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

Entity Framework 基本概念

概念

ADO.NET Entity Framework

架構

說明

EntityConnection

EntityCommand

經過EntityDataReader 方式的數據訪問

經過ObjectContext返回ObjectQuery<T> 方式的數據訪問

模型結構

模型關係說明

模型設計器結構說明

EDM

Model設計器

edmx文件

Context

實體類

使用

使用嚮導建立模型

映射基本規則

映射條件

繼承

多表聯合

關聯

[(1)—(*)] 關聯

表

設置

操做數據

[(1)—(1)]關聯

表

設置

操做數據

[(1)—(0..1)]關聯

[(*)—(*)]關聯

表

顯示中轉方式

隱示中轉方式

操做數據

映射存儲過程與函數

返回表型存儲過程

存儲過程

使用嚮導生成映射

代碼實現

命令型存儲過程

存儲過程

使用嚮導生成映射

代碼實現

參數返回值型存儲過程

存儲過程

使用嚮導生成映射

代碼實現

說明

Context操做數據

AddObject 添加實體

DeleteObject 刪除實體

Detach 分離實體

修改實體

ApplyPropertyChanges 修改實體

Attach / AttachTo 附加實體

CreateEntityKey 建立EntityKey

EntityKey

GetObjectByKey/TryGetObjectByKey 經過EntityKey獲得實體

CreateQuery 建立查詢

狀態管理

EntityState 狀態枚舉

Context.ObjectStateManager 管理記錄的狀態

GetObjectStateEntry 根據實體對象或實體主鍵獲得狀態實體

TryGetObjectStateEntry 根據實體對象或實體主鍵獲得狀態實體

GetObjectStateEntries 根據狀態類型獲得狀態實體集合

ObjectStateManagerChanged 事件

ObjectStateEntry 對象

基本屬性

State 狀態屬性

CurrentValues 當前值

OriginalValues 原始值

GetModifiedProperties 獲得被修改的屬性

SetModified,SetModifiedProperty 標記爲修改

Delete 標記爲刪除

AcceptChanges 方法

保存修改到數據庫

[()—()]關聯