Entity Framework

17.01.2012

1/47

Despre ce vom discuta? Entity Framework Notiuni introductive despre modele de programare cu baze de date; Notiuni introductive despre Entity Framework Anatomia unei aplicatii cu EF Exemple

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

2/47

Modele de programare cu baze de date

1. Aplicatie centrata pe baza de date - Baza de date este in centrul aplicatiei 2. Aplicatie centrata pe model modelul este in centrul aplicatiei. Accesul la date si memorare este facut pe baza modelului conceptual, model ce reflecta obiectele problemei de rezolvat. 3. ADO.NET clasic presupune DataReader / DataAdapter pentru a citi inf din bd si Command pentru a executa insert, update, delete, etc. 4. Cu EF randurile si coloanele din tabele sunt returnate ca obiecte si nu mai folosim in mod direct Command, se translateaza datele din forma tabelara in obiecte. EF foloseste un model numit Entity Data Model (EDM), dezvoltat din Entity Relationship Modeling (ERM). ERM defineste o schema a entitatilor si a relatiilor dintre acestea. Entitatile definesc schema unui obiect, dar nu si comportarea. Entitatea este asemanatoare cu schema unei tabele din baza de date numai ca aceasta descrie schema obiectelor problemei de rezolvat (schema obiectelor afacerii). ERM apare pentru prima data in lucrarea lui Dr. Peter Chen: The Entity-Relationship ModelToward a Unified View of Data (http://csc.lsu.edu/news/erd.pdf) 1976. EDM este un model pe partea de client si constituie fundamentul pentru EF. In EF, EDM este reprezentat de un singur fisier XML in timpul proiectarii, din care la runtime se creeaza trei fisiere : csdl, msl, ssdl. Articolele descrise de un EDM se numesc entitati. Clasele ce sunt generate din entitatile modelului precum si obiectele instantiate din acestea se numesc de asemenea entitati sau clase entitati sau obiecte entitati. Intre entitati pot exista relatii, identificate prin proprietati de navigare.

Sursa de date (Baza de date)

Baza de date pe care o folosim nu are impact asupra modelului. Putem folosi Oracle, SqlServer, Firebird, etc. Comunicarea cu baza de date se face prin furnizorii de ADO.NET pentru baza de date respectiva. Avem nevoie sa identificam providerul si stringul de conexiune la baza de date ; cu aceste informatii EF va reactualiza baza de date.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

3/47

Trasaturi EF : API si utilitare Metadata 1. Proiectare mai intai baza de date

Wizard pentru EDM pleaca de la bd existenta si creaza un model. Se pot selecta tabelele ce vor fi incluse in model.

2. Proiectare modelul mai inati si apoi baza de date ASP.NET cu MVC foloseste acest model care nu e definitivat complet.
VS 2010 permite crearea modelului mai intai si apoi generarea bazei de date. Vom discuta in continuare numai despre metoda de creare a bazei de date ca fiind prima etapa si apoi proiectarea modelului conceptual. Schema de mai jos arata relatiile dintre diferitele componente ale unei aplicatii ce foloseste EF. Object Services

ObjectServices furnizeaza functionalitatea necesara de a lucra cu obiecte din entitati. Clasa EntityObject gestioneaza orice clasa mostenita din aceasta: rezultate cereri ; gestionare modificari si relatii dintre obiecte ; salvarea modificarilor in baza de date ; serializare (XML si binar).

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

4/47

Jurnalizare modificari
Dupa ce a fost instantiat un obiect entitate, ObjectServices gestioneaza toate modificarile suferite de acesta si le va folosi atunci cand se cere salvarea datelor in baza de date. ObjectServices construieste comenzile Insert, Update, Delete pentru fiecare obiect adaugat, modificat sau sters.

Gestiune relatii si chei straine (Foreign Keys)

EDM designer genereaza aceste relatii plecand de la structura bazei de date.

Data Binding
Entitatile pot fi utilizate ca surse de date pentru contraole din Windows Forms si WPF.

Dezvoltare n-Tier EntityClient

EntityClient este API principal din EF. Furnizeaza functionalitatea de a lucra cu cereri si comenzi, regasire rezultate. EntityClient este folosit in special pentru a obtine date folosite in rapoarte. Datele raportate de EntityClient sunt in forma tabelara (read only) in timp ce Object Services va transforma aceste date create de EntityClient in obiecte.

EF si servicii WCF Dataset

EF foloseste DataReader in forma EntityDataReader ce mosteneste DbDataReader. O cerere cu EntityClient returneaza un DataReader. Clasele EntityConnection, EntityCommand, EntityDataReader asemanatoare cu DbConnection, DbCommand, DbDataReader.

Entity Data Model (EDM)

Un EDM poate fi vazut ca legatura dintre aplicatie si baza de date. EDM ne da posibilitatea de a lucra cu modelul conceptual al datelor si nu cu schema bazei de date. EDM este folosit pentru orice interactiune cu baza de date pentru a regasi date sau a le salva. Modelul conceptual, modelul de memorare si maparile dintre cele doua sunt definite in fisiere bazate pe scheme XML si au urmatoarele extensii:

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

5/47

Conceptual schema definition language (CSDL) defineste modelul conceptual. CSDL este implementarea EF pentru Entity Data Model (EDM). Extensia fisierului este .csdl. Store schema definition language (SSDL) defineste modelul de memorare, care mai este numit si modelul logic. Extensia fisierului este .ssdl. Mapping specification language (MSL) defineste maparile dintre modelul de memorare sic el conceptual. Extensia fisierului este .msl.

Observatie Modelul de memorare si maparile pot fi schimbate fara a fi nevoie sa schimbam modelul conceptual, clasele de date sau cod din aplicatie. Din cauza ca modelul de memorare este specific furnizorului bazei de date, se poate lucra cu modelul conceptual pe diferite tipuri de surse de date. EF foloseste acest model si fisierele de mapare pentru operatii de creare, citire, actualizare si stergere plecand de la entitati spre sursa de date.

Maparea obiectelor la date

In general unei tabele ii corespunde o singura clasa si relatiile dintre clase sunt reprezentate adesea in mod diferit fata de relatiile dintre tabele. De exemplu pentru a reprezenta un client pentru o comanda, clasa Order poate sa foloseasca o proprietate ce contine o referinta la clasa Customer, in timp ce o inregiustrare din baza de date din tabela Order contine o coloana foreign key cu o valoare ce corespunde la valoarea unei chei primare din tabela Customer. Clasa Customer poate sa aiba o proprietate numita Orders, ce contine o colectie de instante a clasei Order, in timp ce in tabela Customer din baza de date nu exista o asemenea coloana. O rezolvare a acestei probleme o constituie maparea claselor si proprietatilor la tabelele si coloanele tabelelor. EF mapeaza tabelele relationale, coloanele si cheile straine din modelul logic la entitati si relatii in modelul conceptual. Utilitarele pentru EDM (Entity Data Model) genereaza clase extensibile bazate pe modelul conceptual. Acestea sunt clase partiale si pot fi extinse de catre dezvoltator. Implicit, clasele care sunt generate pentru un model conceptual particular sunt derivate din clasele de baza ce furnizeaza servicii pentru materializarea entitatilor ca obicte si pentru gestionarea si salvarea modificarilor effectuate. Dezvoltatorul foloseste aceste clase pentru a lucra cu entitatile si relatiile ca obiecte relationate prin asocieri. Aceste clase pot fi personalizate de catre dezvoltator.

Accesare si modificare date din entitati

EF foloseste informatiile din model si fisierele de mapare pentru a translata cererile asupra obiectelor din modelul conceptual in cereri specifice sursei de date. EF furnizeaza urmatoarele modalitati de a interoga modelul conceptual si a returna obiecte: Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

6/47

LINQ to Entities. Furnizeaza suport pentru Language-Integrated Query (LINQ) in vederea interogarii tipurilor de entitati definite in modelul conceptual. Entity SQL. Un dialect SQL independent de mediul de memorare ce lucreaza direct cu entitatile in modelul conceptual. Metode de constructie a cererilor folosind LINQ.

EF include furnizorul de date EntityClient, furnizor ce gestioneaza conexiunile, parseaza cererile asupra entitatilor in cereri specifice sursei de date si returneaza un data reader folosit de EF pentru a materialize datele din obiecte. Urmatoarea diagrama (MSDN) ilustreaza arhitectura EF pentru accesarea datelor:

Utilitarele pentru EDM pot genera o clasa derivata din ObjectContext ce reprezinta un container in modelul conceptual. ObjectContext furnizeaza facilitate pentru gestionarea si salvarea modificarilor din entitati, concurenta si relatiile dintre obiecte. Metoda SaveChanges din aceasta clasa efectueaza operatiile de insert, update si delete asupra sursei de date.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

7/47

Furnizori de date
Provider-ul EntityClient extinde modelul ADO.NET prin accesarea datei in termenii modelului conceptual al entitatilor si relatiilor. In final EntityClient comunica cu baza de date.

Utilitar pentru Entity Data Model

Impreuna cu EF runtime, .NET 4.0 include un utilitar EDM Generator (EdmGen.exe) ce permite conectarea la baza de date si genereaza modelul si fisierele de mapare bazate pe o mapare de 1la-1 intre entitati si tabele. Fisierul .csdl (modelul conceptual) este folosit pentru a genera clasele ce reprezinta tipurile de entitati si ObjectContext.

Entity Data Model - Concepte

Entity Data Model (EDM) foloseste urmatoarele concepte pentru a descrie structura datei: tip entitate (entity type); tip asociere (association type); proprietate (property). Entity type descrie structura datei cu EDM sunt construite din proprietati si constituie un template pentru entitati (definitia unei clase este un template pentru instantele clasei). Fiecare entitate trebuie sa aiba o cheie unica. O multime de entitati este o colectie a instantelor tipului entitatii specificate. Multimile de entitati sunt grupate in mod logic intr-un container entity container. Mostenirea este suportata intre tipurile de entitati. Tipul asociere Un tip asociere (association type) numit simplu si asociere descrie relatiile din EDM. Asocierea reprezinta o relatie intre doua tipuri de entitati (ex. Customer si Order). Multiplicitatea unei asocieri poate fi 0..1 sau mai multe. Entitatile ce folosesc asocieri pot fi accesate prin proprietatile de navigare sau prin foreign key. Instantele asocierilor sunt grupate in mod logic in entity container. Proprietate Tipurile entitati contin proprietati ce definesc structura acestora. Ex. entitatea Customer poate avea proprietatile CustomerId, Name, Address. O proprietate poate contine tipuri primitive (string, int, Boolean, etc.) sau tipuri structurate (tipuri complexe). Reprezentari ale modelului conceptual Un model conceptual este o reprezentare specifica a structurii unor date vazute ca entitati si relatii. Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

8/47

In VS 2010 avem o reprezentare vizuala a EDM-ului si a membrilor sai. In spatele acestei reprezentari vizuale exista un fisier XML. Exemplu cu clasele generate din tabelele Customer, Order si OrderDetails. Descrierele tabelelor sunt (Firebird server baze de date):
CREATE TABLE CUSTOMER ( CUSTOMERID SMALLINT NOT NULL, "NAME" CHAR(20) CHARACTER SET ISO8859_1 DEFAULT '[n/a]' NOT NULL COLLATE ISO8859_1, ADRESA CHAR(30) CHARACTER SET ISO8859_1 DEFAULT '[n/a]' COLLATE ISO8859_1); ALTER TABLE CUSTOMER ADD CONSTRAINT PK_CUSTOMER PRIMARY KEY (CUSTOMERID); CREATE TABLE "ORDER" ( ORDERID SMALLINT NOT NULL, DATA DATE DEFAULT 'NOW' NOT NULL, CUSTOMERID SMALLINT NOT NULL, VALOARE DECIMAL(12, 2) DEFAULT 0.0); ALTER TABLE "ORDER" ADD CONSTRAINT PK_ORDER PRIMARY KEY (ORDERID); ALTER TABLE "ORDER" ADD CONSTRAINT FK_ORDER FOREIGN KEY (CUSTOMERID) REFERENCES CUSTOMER(CUSTOMERID); CREATE TABLE ORDERDETAILS ( ORDERID SMALLINT NOT NULL, PRODUS CHAR(20) CHARACTER SET ISO8859_1 DEFAULT '[n/a]' NOT NULL COLLATE ISO8859_1, VALOARE DECIMAL(12, 2) DEFAULT 0.0 NOT NULL, SERIAL SMALLINT DEFAULT 0 NOT NULL); ALTER TABLE ORDERDETAILS ADD CONSTRAINT PK_ORDERDETAILS PRIMARY KEY (ORDERID,SERIAL);

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

9/47

ALTER TABLE ORDERDETAILS ADD CONSTRAINT FK_ORDERDETAILS FOREIGN KEY (ORDERID) REFERENCES "ORDER"(ORDERID);

O parte din fisierul edmx ce descrie modelul conceptual:

<edmx:StorageModels> <Schema Namespace="Model1.Store" Alias="Self" Provider="FirebirdSql.Data.FirebirdClient" ProviderManifestToken="2.5" xmlns:store="http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreS chemaGenerator" xmlns="http://schemas.microsoft.com/ado/2009/02/edm/ssdl"> <EntityContainer Name="Model1StoreContainer"> <EntitySet Name="CUSTOMER" EntityType="Model1.Store.CUSTOMER" store:Type="Tables" Schema="Firebird" /> <EntitySet Name="ORDER" EntityType="Model1.Store.ORDER" store:Type="Tables" Schema="Firebird" /> <EntitySet Name="ORDERDETAILS" EntityType="Model1.Store.ORDERDETAILS" store:Type="Tables" Schema="Firebird" /> <AssociationSet Name="FK_ORDER" Association="Model1.Store.FK_ORDER"> <End Role="CUSTOMER" EntitySet="CUSTOMER" /> <End Role="ORDER" EntitySet="ORDER" /> </AssociationSet>

De observat cele trei tabele si entitati precum si modul de descriere a unei relatii data de foreign key. Entitatea Customer din acest fisier arata astfel :
<EntityType Name="CUSTOMER"> <Key> <PropertyRef Name="CUSTOMERID" /> </Key> <Property Name="CUSTOMERID" Type="smallint" Nullable="false" /> <Property Name="NAME" Type="char" Nullable="false" MaxLength="20" /> <Property Name="ADRESA" Type="char" MaxLength="30" /> </EntityType>

Faceti comparatie cu descrierea tabelei Customer din Firebird. Parte din fisierul .csdl pentru acest model conceptual:
<?xml version="1.0" encoding="utf-8"?> <Schema Namespace="Model1" Alias="Self" xmlns:annotation="http://schemas.microsoft.com/ado/2009/02/edm/annotat ion" xmlns="http://schemas.microsoft.com/ado/2008/09/edm"> <EntityContainer Name="EntitiesCustomer" annotation:LazyLoadingEnabled="true"> <EntitySet Name="CUSTOMERs" EntityType="Model1.CUSTOMER" /> <EntitySet Name="ORDERs" EntityType="Model1.ORDER" /> <EntitySet Name="ORDERDETAILS" EntityType="Model1.ORDERDETAIL" />

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

10/47

<AssociationSet Name="FK_ORDER" Association="Model1.FK_ORDER"> <End Role="CUSTOMER" EntitySet="CUSTOMERs" /> <End Role="ORDER" EntitySet="ORDERs" /> </AssociationSet> <EntityType Name="ORDER"> <Key> <PropertyRef Name="ORDERID" /> </Key> <Property Name="ORDERID" Type="Int16" Nullable="false" /> <Property Name="DATA" Type="DateTime" Nullable="false" /> <Property Name="CUSTOMERID" Type="Int16" Nullable="false" /> <Property Name="VALOARE" Type="Decimal" Precision="12" Scale="2" /> <NavigationProperty Name="CUSTOMER" Relationship="Model1.FK_ORDER" FromRole="ORDER" ToRole="CUSTOMER" /> <NavigationProperty Name="ORDERDETAILS" Relationship="Model1.FK_ORDERDETAILS" FromRole="ORDER" ToRole="ORDERDETAILS" /> </EntityType> <Association Name="FK_ORDER"> <End Role="CUSTOMER" Type="Model1.CUSTOMER" Multiplicity="1" /> <End Role="ORDER" Type="Model1.ORDER" Multiplicity="*" /> <ReferentialConstraint> <Principal Role="CUSTOMER"> <PropertyRef Name="CUSTOMERID" /> </Principal> <Dependent Role="ORDER"> <PropertyRef Name="CUSTOMERID" /> </Dependent> </ReferentialConstraint> </Association> </Schema>

Partial .ssdl (cuvantul store ne arata ca e vorba de modelul de memorare, baza de date, legatura intre tabele si entitati, etc.).
<?xml version="1.0" encoding="utf-8"?> <Schema Namespace="Model1.Store" Alias="Self" Provider="FirebirdSql.Data.FirebirdClient" ProviderManifestToken="2.5" xmlns:store="http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreS chemaGenerator" xmlns="http://schemas.microsoft.com/ado/2009/02/edm/ssdl"> <EntityContainer Name="Model1StoreContainer"> <EntitySet Name="CUSTOMER" EntityType="Model1.Store.CUSTOMER" store:Type="Tables" Schema="Firebird" /> <EntitySet Name="ORDER" EntityType="Model1.Store.ORDER" store:Type="Tables" Schema="Firebird" /> <EntitySet Name="ORDERDETAILS" EntityType="Model1.Store.ORDERDETAILS" store:Type="Tables" Schema="Firebird" />

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

11/47

<EntityType Name="ORDER"> <Key> <PropertyRef Name="ORDERID" /> </Key> <Property Name="ORDERID" Type="smallint" Nullable="false" /> <Property Name="DATA" Type="date" Nullable="false" /> <Property Name="CUSTOMERID" Type="smallint" Nullable="false" /> <Property Name="VALOARE" Type="decimal" Precision="12" Scale="2" /> </EntityType>

Si in final .msl. Maparea intre entitati si tabele, intre proprietati si coloane, etc.
<?xml version="1.0" encoding="utf-8"?> <Mapping Space="C-S" xmlns="http://schemas.microsoft.com/ado/2008/09/mapping/cs"> <EntityContainerMapping StorageEntityContainer="Model1StoreContainer" CdmEntityContainer="EntitiesCustomer"> <EntitySetMapping Name="CUSTOMERs"> <EntityTypeMapping TypeName="Model1.CUSTOMER"> <MappingFragment StoreEntitySet="CUSTOMER"> <ScalarProperty Name="CUSTOMERID" ColumnName="CUSTOMERID" /> <ScalarProperty Name="NAME" ColumnName="NAME" /> <ScalarProperty Name="ADRESA" ColumnName="ADRESA" /> </MappingFragment> </EntityTypeMapping> </EntitySetMapping> </Mapping>

Metadata modelului (vezi cele trei fisiere)

Baza de date Maparea

Alte denumiri utile Conceptual Schema Definition Language (CSDL) Conceptual layer Conceptual schema Conceptual model C-side Store Schema Definition Language (SSDL) Store/storage layer Store/storage schema Store/storage model Store/storage metadata Store/storage metadata schema S-side Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

12/47

Mapping Specification Language (MSL) Mapping layer Mapping specification C-S mapping (referring to conceptual to store)

Ce este in fisierul XML ce descrie EDM? Doua sectiuni principale : informatii pentru runtime ; o modelul de memorare ; o modelul conceptual ; o maparea ; informatii pentru Designer.

CSDL: SChema conceptuala

EntityContainer EntitySet EntityType

EntityContainer
Constituie punctul principal pentru a executa cereri asupra modelului. Expune EntitySet care dau acces la obiectele pe care le contin.

EntityContainer are un atribut:LazyLoadingEnabled="true" ce indica modul de creare al modelului (de la baza de date la model sau invers), folosit numai in fisierul EDMX. Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

13/47

EntitySet
Un EntitySet este un container de tip entitate si are atributele Name si EntityType.
<EntitySet Name="Addresses" EntityType="SampleModel.Address" /> <EntitySet Name="Contacts" EntityType="SampleModel.Contact" />

EntityType
EntityType este tipul de data din model.
<EntityType Name="Address"> <Key> <PropertyRef Name="addressID" /> </Key> <Property Name="addressID" Type="Int32" Nullable="false" annotation:StoreGeneratedPattern="Identity" /> <Property Name="Street1" Type="String" MaxLength="50" Unicode="true" FixedLength="true" />

Etc

Elementul Key
identificator unic pentru entitate.

Elementele Property
sunt tipuri simple (tipuri primitive).

Proprietati de navigare sunt legate de asocieri.

Asocierile definesc relatiile dintre tipurile entitate. Nu definesc o relatie completa, acestea definesc numai endpoint-urile, adica entitatile implicate in relatie si multiplicitatea lor.

Proprietatea Referential Constraint

Intr-un model ce contine chei straine, Referential Constraint defineste dependenta dintre entitatile relationate.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

14/47

MSL: The Mappings Nivelul de mapare este situat intre modelul conceptaul si cel de memorare (baza de date). In Designer putem vedea aceste informatii.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

15/47

Cereri cu EDM

Cereri asupra modelului nu direct asupra bazei de date

private static void QueryContacts() { using (var context = new SampleEntities()) { var contacts = context.Contacts; foreach (var contact in contacts) { Console.WriteLine("{0} {1}", contact.FirstName.Trim(), contact.LastName); } } Console.Write("Press Enter..."); Console.ReadLine(); }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

16/47

Cereri cu Object Services si Entity SQL namespace: System.Data.Objects Cerere cu Entity SQL
var queryString = "SELECT VALUE c " + "FROM SampleEntities.Contacts AS c " + "WHERE c.FirstName='Robert'"; ObjectQuery<Contact> contacts = context.CreateQuery<Contact>(queryString);

Explicatie

Cea mai simpla cerere

ObjectSet<Contact> contacts = context.Contacts;

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework Exemplu complet (cu Firebird) Analiza codului si modalitati de lucru.

17.01.2012

17/47

In aplicatie s-a plecat de la baza de date si VS 2010 a construit modelul conceptual pentru tabelele selectate in momentul proiectarii aplicatiei. Atentie ! In acest cod nu trebuie sa facem modificari pentru ca acest fisier se regenereaza la diverse modificari facute asupra modelului. Deoarece toate clasele sunt definite ca partial putem dezvolta clasa in alt fisier. Atentie de asemenea la metodele partiale pe care le propune designerul.
//-----------------------------------------------------------------------------// <auto-generated> // This code was generated from a template. // // Manual changes to this file may cause unexpected behavior in your application. // Manual changes to this file will be overwritten if the code is regenerated. // </auto-generated> //-----------------------------------------------------------------------------using using using using using using using System; System.Data.Objects; System.Data.Objects.DataClasses; System.Data.EntityClient; System.ComponentModel; System.Xml.Serialization; System.Runtime.Serialization;

[assembly: EdmSchemaAttribute()] #region EDM Relationship Metadata [assembly: EdmRelationshipAttribute("Model1", "FK_ORDER", "CUSTOMER", System.Data.Metadata.Edm.RelationshipMultiplicity.One, typeof(Entity.CUSTOMER), "ORDER", System.Data.Metadata.Edm.RelationshipMultiplicity.Many, typeof(Entity.ORDER), true)] [assembly: EdmRelationshipAttribute("Model1", "FK_ORDERDETAILS", "ORDER", System.Data.Metadata.Edm.RelationshipMultiplicity.One, typeof(Entity.ORDER), "ORDERDETAILS", System.Data.Metadata.Edm.RelationshipMultiplicity.Many, typeof(Entity.ORDERDETAIL), true)] #endregion namespace Entity { #region Contexts /// <summary> /// No Metadata Documentation available. /// </summary> public partial class EntitiesCustomer : ObjectContext { #region Constructors /// <summary> /// Initializes a new EntitiesCustomer object using the connection string found in the 'EntitiesCustomer' section of the application configuration file. /// </summary> public EntitiesCustomer() : base("name=EntitiesCustomer", "EntitiesCustomer") { this.ContextOptions.LazyLoadingEnabled = true; OnContextCreated();

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework
}

17.01.2012

18/47

/// <summary> /// Initialize a new EntitiesCustomer object. /// </summary> public EntitiesCustomer(string connectionString) : base(connectionString, "EntitiesCustomer") { this.ContextOptions.LazyLoadingEnabled = true; OnContextCreated(); } /// <summary> /// Initialize a new EntitiesCustomer object. /// </summary> public EntitiesCustomer(EntityConnection connection) : base(connection, "EntitiesCustomer") { this.ContextOptions.LazyLoadingEnabled = true; OnContextCreated(); } #endregion #region Partial Methods partial void OnContextCreated(); #endregion #region ObjectSet Properties /// <summary> /// No Metadata Documentation available. /// </summary> public ObjectSet<CUSTOMER> CUSTOMERs { get { if ((_CUSTOMERs == null)) { _CUSTOMERs = base.CreateObjectSet<CUSTOMER>("CUSTOMERs"); } return _CUSTOMERs; } } private ObjectSet<CUSTOMER> _CUSTOMERs; /// <summary> /// No Metadata Documentation available. /// </summary> public ObjectSet<ORDER> ORDERs { get { if ((_ORDERs == null)) { _ORDERs = base.CreateObjectSet<ORDER>("ORDERs"); } return _ORDERs; } }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

19/47

private ObjectSet<ORDER> _ORDERs; /// <summary> /// No Metadata Documentation available. /// </summary> public ObjectSet<ORDERDETAIL> ORDERDETAILS { get { if ((_ORDERDETAILS == null)) { _ORDERDETAILS = base.CreateObjectSet<ORDERDETAIL>("ORDERDETAILS"); } return _ORDERDETAILS; } } private ObjectSet<ORDERDETAIL> _ORDERDETAILS; #endregion #region AddTo Methods /// <summary> /// Deprecated Method for adding a new object to the CUSTOMERs EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead. /// </summary> public void AddToCUSTOMERs(CUSTOMER cUSTOMER) { base.AddObject("CUSTOMERs", cUSTOMER); } /// <summary> /// Deprecated Method for adding a new object to the ORDERs EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead. /// </summary> public void AddToORDERs(ORDER oRDER) { base.AddObject("ORDERs", oRDER); } /// <summary> /// Deprecated Method for adding a new object to the ORDERDETAILS EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead. /// </summary> public void AddToORDERDETAILS(ORDERDETAIL oRDERDETAIL) { base.AddObject("ORDERDETAILS", oRDERDETAIL); } #endregion }

#endregion #region Entities /// <summary> /// No Metadata Documentation available. /// </summary> [EdmEntityTypeAttribute(NamespaceName="Model1", Name="CUSTOMER")] [Serializable()] [DataContractAttribute(IsReference=true)]

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

20/47

public partial class CUSTOMER : EntityObject { #region Factory Method /// <summary> /// Create a new CUSTOMER object. /// </summary> /// <param name="cUSTOMERID">Initial value of the CUSTOMERID property.</param> /// <param name="nAME">Initial value of the NAME property.</param> public static CUSTOMER CreateCUSTOMER(global::System.Int16 cUSTOMERID, global::System.String nAME) { CUSTOMER cUSTOMER = new CUSTOMER(); cUSTOMER.CUSTOMERID = cUSTOMERID; cUSTOMER.NAME = nAME; return cUSTOMER; } #endregion #region Primitive Properties /// <summary> /// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=true, IsNullable=false)] [DataMemberAttribute()] public global::System.Int16 CUSTOMERID { get { return _CUSTOMERID; } set { if (_CUSTOMERID != value) { OnCUSTOMERIDChanging(value); ReportPropertyChanging("CUSTOMERID"); _CUSTOMERID = StructuralObject.SetValidValue(value); ReportPropertyChanged("CUSTOMERID"); OnCUSTOMERIDChanged(); } } } private global::System.Int16 _CUSTOMERID; partial void OnCUSTOMERIDChanging(global::System.Int16 value); partial void OnCUSTOMERIDChanged(); /// <summary> /// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=false, IsNullable=false)] [DataMemberAttribute()] public global::System.String NAME { get { return _NAME; } set { OnNAMEChanging(value);

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

21/47

ReportPropertyChanging("NAME"); _NAME = StructuralObject.SetValidValue(value, false); ReportPropertyChanged("NAME"); OnNAMEChanged(); } } private global::System.String _NAME; partial void OnNAMEChanging(global::System.String value); partial void OnNAMEChanged(); /// <summary> /// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=false, IsNullable=true)] [DataMemberAttribute()] public global::System.String ADRESA { get { return _ADRESA; } set { OnADRESAChanging(value); ReportPropertyChanging("ADRESA"); _ADRESA = StructuralObject.SetValidValue(value, true); ReportPropertyChanged("ADRESA"); OnADRESAChanged(); } } private global::System.String _ADRESA; partial void OnADRESAChanging(global::System.String value); partial void OnADRESAChanged(); #endregion #region Navigation Properties /// <summary> /// No Metadata Documentation available. /// </summary> [XmlIgnoreAttribute()] [SoapIgnoreAttribute()] [DataMemberAttribute()] [EdmRelationshipNavigationPropertyAttribute("Model1", "FK_ORDER", "ORDER")] public EntityCollection<ORDER> ORDERs { get { return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedCollection<ORDER>("Model1. FK_ORDER", "ORDER"); } set { if ((value != null)) { ((IEntityWithRelationships)this).RelationshipManager.InitializeRelatedCollection<ORDER>(" Model1.FK_ORDER", "ORDER", value); } }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework
} #endregion }

17.01.2012

22/47

/// <summary> /// No Metadata Documentation available. /// </summary> [EdmEntityTypeAttribute(NamespaceName="Model1", Name="ORDER")] [Serializable()] [DataContractAttribute(IsReference=true)] public partial class ORDER : EntityObject { #region Factory Method /// <summary> /// Create a new ORDER object. /// </summary> /// <param name="oRDERID">Initial value of the ORDERID property.</param> /// <param name="dATA">Initial value of the DATA property.</param> /// <param name="cUSTOMERID">Initial value of the CUSTOMERID property.</param> public static ORDER CreateORDER(global::System.Int16 oRDERID, global::System.DateTime dATA, global::System.Int16 cUSTOMERID) { ORDER oRDER = new ORDER(); oRDER.ORDERID = oRDERID; oRDER.DATA = dATA; oRDER.CUSTOMERID = cUSTOMERID; return oRDER; } #endregion #region Primitive Properties /// <summary> /// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=true, IsNullable=false)] [DataMemberAttribute()] public global::System.Int16 ORDERID { get { return _ORDERID; } set { if (_ORDERID != value) { OnORDERIDChanging(value); ReportPropertyChanging("ORDERID"); _ORDERID = StructuralObject.SetValidValue(value); ReportPropertyChanged("ORDERID"); OnORDERIDChanged(); } } } private global::System.Int16 _ORDERID; partial void OnORDERIDChanging(global::System.Int16 value); partial void OnORDERIDChanged(); /// <summary>

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

23/47

/// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=false, IsNullable=false)] [DataMemberAttribute()] public global::System.DateTime DATA { get { return _DATA; } set { OnDATAChanging(value); ReportPropertyChanging("DATA"); _DATA = StructuralObject.SetValidValue(value); ReportPropertyChanged("DATA"); OnDATAChanged(); } } private global::System.DateTime _DATA; partial void OnDATAChanging(global::System.DateTime value); partial void OnDATAChanged(); /// <summary> /// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=false, IsNullable=false)] [DataMemberAttribute()] public global::System.Int16 CUSTOMERID { get { return _CUSTOMERID; } set { OnCUSTOMERIDChanging(value); ReportPropertyChanging("CUSTOMERID"); _CUSTOMERID = StructuralObject.SetValidValue(value); ReportPropertyChanged("CUSTOMERID"); OnCUSTOMERIDChanged(); } } private global::System.Int16 _CUSTOMERID; partial void OnCUSTOMERIDChanging(global::System.Int16 value); partial void OnCUSTOMERIDChanged(); /// <summary> /// No Metadata Documentation available. /// </summary> [EdmScalarPropertyAttribute(EntityKeyProperty=false, IsNullable=true)] [DataMemberAttribute()] public Nullable<global::System.Decimal> VALOARE { get { return _VALOARE; } set { OnVALOAREChanging(value); ReportPropertyChanging("VALOARE");

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

24/47

_VALOARE = StructuralObject.SetValidValue(value); ReportPropertyChanged("VALOARE"); OnVALOAREChanged(); } } private Nullable<global::System.Decimal> _VALOARE; partial void OnVALOAREChanging(Nullable<global::System.Decimal> value); partial void OnVALOAREChanged(); #endregion #region Navigation Properties /// <summary> /// No Metadata Documentation available. /// </summary> [XmlIgnoreAttribute()] [SoapIgnoreAttribute()] [DataMemberAttribute()] [EdmRelationshipNavigationPropertyAttribute("Model1", "FK_ORDER", "CUSTOMER")] public CUSTOMER CUSTOMER { get { return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<CUSTOMER>("Model 1.FK_ORDER", "CUSTOMER").Value; } set { ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<CUSTOMER>("Model 1.FK_ORDER", "CUSTOMER").Value = value; } } /// <summary> /// No Metadata Documentation available. /// </summary> [BrowsableAttribute(false)] [DataMemberAttribute()] public EntityReference<CUSTOMER> CUSTOMERReference { get { return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedReference<CUSTOMER>("Model 1.FK_ORDER", "CUSTOMER"); } set { if ((value != null)) { ((IEntityWithRelationships)this).RelationshipManager.InitializeRelatedReference<CUSTOMER> ("Model1.FK_ORDER", "CUSTOMER", value); } } } /// <summary> /// No Metadata Documentation available. /// </summary>

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

25/47

[XmlIgnoreAttribute()] [SoapIgnoreAttribute()] [DataMemberAttribute()] [EdmRelationshipNavigationPropertyAttribute("Model1", "FK_ORDERDETAILS", "ORDERDETAILS")] public EntityCollection<ORDERDETAIL> ORDERDETAILS { get { return ((IEntityWithRelationships)this).RelationshipManager.GetRelatedCollection<ORDERDETAIL>("M odel1.FK_ORDERDETAILS", "ORDERDETAILS"); } set { if ((value != null)) { ((IEntityWithRelationships)this).RelationshipManager.InitializeRelatedCollection<ORDERDET AIL>("Model1.FK_ORDERDETAILS", "ORDERDETAILS", value); } } } #endregion } /// <summary> /// No Metadata Documentation available. /// </summary> [EdmEntityTypeAttribute(NamespaceName="Model1", Name="ORDERDETAIL")] [Serializable()] [DataContractAttribute(IsReference=true)] public partial class ORDERDETAIL : EntityObject { #region Factory Method /// <summary> /// Create a new ORDERDETAIL object. /// </summary> /// <param name="oRDERID">Initial value of the ORDERID property.</param> /// <param name="pRODUS">Initial value of the PRODUS property.</param> /// <param name="vALOARE">Initial value of the VALOARE property.</param> /// <param name="sERIAL">Initial value of the SERIAL property.</param> public static ORDERDETAIL CreateORDERDETAIL(global::System.Int16 oRDERID, global::System.String pRODUS, global::System.Decimal vALOARE, global::System.Int16 sERIAL) { ORDERDETAIL oRDERDETAIL = new ORDERDETAIL(); oRDERDETAIL.ORDERID = oRDERID; oRDERDETAIL.PRODUS = pRODUS; oRDERDETAIL.VALOARE = vALOARE; oRDERDETAIL.SERIAL = sERIAL; return oRDERDETAIL; } #endregion

Observati ca anumite lucruri se repeta. Am omis, partial, codul de la OrderDetails. Codul ce foloseste acest model poate fi urmatorul : Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework
using using using using using

17.01.2012

26/47

System; System.Collections.Generic; System.Linq; System.Text; System.Data;

namespace Entity { class Program { static void Main(string[] args) { // insert in tabela Customer & afisare AddCustomer(); PrintCustomer(); PrintSpecialCustomer(); // modificare Name in Customer UpdateNameCustomer(); // Sterge Customer cu id = 2 DeleteCustomer(); Console.WriteLine("Dupa DeleteCustomer id = 2"); PrintCustomer(); Console.Read(); // insert in tabela Order & afisare AddOrder(); PrintOrderForCustomer(); PrintAllOrderWithCustomerInfo(); // OrderDetails AddOrderDetails(); PrintOrder(); Console.WriteLine("Pres Enter to exit..."); Console.ReadKey(); } // Metode pentru Customer private static void AddCustomer() { EntitiesCustomer ec = new EntitiesCustomer(); // iau max customerid din colectie int maxid = (from x in ec.CUSTOMERs select x.CUSTOMERID).Max(); Console.WriteLine("Tastati id Customer. Maxim CustomerId = {0}", maxid); short id = Convert.ToInt16(Console.ReadLine()); CUSTOMER ct = new CUSTOMER(); ct.CUSTOMERID = id;

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

27/47

if (ec.CUSTOMERs.Where(x => x.CUSTOMERID == ct.CUSTOMERID).Count() <= 0) { ct.NAME = "Name " + id.ToString(); ct.ADRESA = "Adresa " + id.ToString(); ec.AddToCUSTOMERs(ct); ec.SaveChanges(); } else Console.WriteLine("Exista CUSTOMERID = {0}", ct.CUSTOMERID); CUSTOMER cust = CUSTOMER.CreateCUSTOMER((short)(ct.CUSTOMERID + 1), "Name id = " + (ct.CUSTOMERID + 1).ToString()); cust.ADRESA = "Adresa " + cust.CUSTOMERID.ToString(); if (ec.CUSTOMERs.Where(x => x.CUSTOMERID == cust.CUSTOMERID).Count() <= 0) { ec.AddObject("EntitiesCustomer.CUSTOMERs", cust); try { ec.SaveChanges(); } catch (OptimisticConcurrencyException oex) { Console.WriteLine( "Exceptie OptimisticConcurencyException : {0} ", oex.InnerException); } catch (UpdateException uex) { Console.WriteLine( "Exceptie UpdateException :{0} ", uex.InnerException); } } else Console.WriteLine("Exista CUSTOMERID = {0}", cust.CUSTOMERID); } private static void PrintCustomer() { EntitiesCustomer ec = new EntitiesCustomer(); foreach (CUSTOMER c in ec.CUSTOMERs) { Console.WriteLine(c.CUSTOMERID + " -> " + c.NAME + " adr. " + c.ADRESA); } }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

28/47

private static void PrintSpecialCustomer() { EntitiesCustomer ec = new EntitiesCustomer(); var items = from x in ec.CUSTOMERs where (x.CUSTOMERID % 2 == 0) select new { x.CUSTOMERID, x.NAME, x.ADRESA }; Console.WriteLine("Cerere ..."); foreach (var x in items) Console.WriteLine("{0}, {1}, {2}", x.CUSTOMERID, x.NAME, x.ADRESA); } private static void UpdateNameCustomer() { EntitiesCustomer context = new EntitiesCustomer(); EntityKey contactKey = new EntityKey("EntitiesCustomer.CUSTOMERs", "CUSTOMERID", (short)1); var customer = context.GetObjectByKey(contactKey); ((CUSTOMER)customer).NAME = "Nume modificat iar"; context.SaveChanges(); /* // O alta varianta EntitiesCustomer context = new EntitiesCustomer(); CUSTOMER ct = context.CUSTOMERs .First(i => i.CUSTOMERID == (short)2); ct.NAME = "Modificare nume"; context.SaveChanges(); // End * */ } /// <summary> /// Daca CUSTOMERID este folosit drept Foreign Key intr-o alta tabela /// atunci definitia pentru ForeignKey trebuie sa fie: /// /// ALTER TABLE "ORDER" ADD CONSTRAINT FK_ORDER FOREIGN KEY (CUSTOMERID) /// REFERENCES CUSTOMER(CUSTOMERID) ON DELETE CASCADE; /// /// </summary> private static void DeleteCustomer() { EntitiesCustomer context = new EntitiesCustomer(); CUSTOMER ct = context.CUSTOMERs .First(i => i.CUSTOMERID == (short)2); context.CUSTOMERs.DeleteObject(ct); context.SaveChanges(); }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

29/47

#region Order // pentru fiecare Customer adaug trei ordine ce au id = idcustomer *10 + i, i=1,2,3 private static void AddOrder() { EntitiesCustomer ec = new EntitiesCustomer(); foreach (CUSTOMER c in ec.CUSTOMERs) { for (int i = 1; i < 4; i++) { ORDER o = new ORDER(); o.ORDERID = (short)(c.CUSTOMERID * 10 + i); o.VALOARE = o.ORDERID * 10; o.DATA = DateTime.Now.AddDays(1); o.CUSTOMERID = c.CUSTOMERID; if (ec.ORDERs.Where(x => x.ORDERID == o.ORDERID).Count() <= 0) { ec.AddToORDERs(o); ec.SaveChanges(); } } } } private static void PrintOrderForCustomer() { Console.WriteLine("\nSe face join intre Customer si Order\n"); EntitiesCustomer ec = new EntitiesCustomer(); var items = from c in ec.CUSTOMERs from o in ec.ORDERs where c.CUSTOMERID == o.CUSTOMERID select new { c.CUSTOMERID, c.NAME, o.ORDERID, o.DATA, o.VALOARE}; foreach(var x in items) Console.WriteLine("{0}, {1}, {2}, {3}, {4}",x.CUSTOMERID, x.ORDERID, x.NAME, x.DATA, x.VALOARE); } private static void PrintAllOrderWithCustomerInfo() { Console.WriteLine("\nPrintAllOrderWithCustomerInfo\n Se pleaca de la Order si se ajunge la Customer\n"); Console.WriteLine("\nvar items = from o in ec.ORDERs\n " + " where o.CUSTOMER.CUSTOMERID > (short)4\n " + " select new { o.ORDERID, o.CUSTOMER };\n"); EntitiesCustomer ec = new EntitiesCustomer(); var items = from o in ec.ORDERs where o.CUSTOMER.CUSTOMERID > (short)4

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

30/47

select new { o.ORDERID, o.CUSTOMER }; foreach (var x in items) { Console.WriteLine("{0}, {1}, {2}", x.CUSTOMER.CUSTOMERID, x.ORDERID, x.CUSTOMER.NAME); } } #endregion Order #region OrderDetails private static void AddOrderDetails() { EntitiesCustomer ec = new EntitiesCustomer(); foreach (ORDER o in ec.ORDERs) { for (int i = 1; i < 4; i++) { ORDERDETAIL od = new ORDERDETAIL(); od.ORDERID = o.ORDERID; od.PRODUS = "Produs " + i.ToString() + o.ORDERID.ToString(); od.VALOARE = i + o.ORDERID * 10; od.SERIAL = (short)i; if (ec.ORDERDETAILS.Where(x => x.ORDERID == od.ORDERID && x.SERIAL == od.SERIAL).Count() <= 0) { ec.AddToORDERDETAILS(od); ec.SaveChanges(); } } } } private static void PrintOrder() { EntitiesCustomer ec = new EntitiesCustomer(); foreach(ORDER o in ec.ORDERs) PrintAllDetailsForOrder(o); } private static void PrintAllDetailsForOrder(ORDER o) { EntitiesCustomer ec = new EntitiesCustomer(); Console.WriteLine("\nPrintAllDetailsForOrder: param ORDER = {0}", o.ORDERID); var items = from x in ec.ORDERDETAILS where x.ORDERID == o.ORDERID select new { o.CUSTOMER.CUSTOMERID,

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

31/47

o.CUSTOMER.NAME, o.ORDERID, x.PRODUS }; foreach (var x in items) Console.WriteLine("{0}, {1}, {2}, {3}", x.CUSTOMERID, x.NAME, x.ORDERID, x.PRODUS); } #endregion OrderDetails } }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

32/47

Entity Framework Terminology - MSDN

This topic defines terms frequently referenced in Entity Framework documentation. Links are provided to relevant topics where additional information is available.
Term association Definition The definition of a relationship between entity types. For more information, see Association Element (CSDL) and association type (Entity Data Model).

association set

A logical container for instances of associations of the same type. For more information, see AssociationSet Element (CSDL) and association set (Entity Data Model).

command tree

A common, programmatic representation of all Entity Framework queries that are composed of one or more expressions.

complex type

A .NET Framework class that represents a complex property as defined in the conceptual model. Complex types enable scalar properties to be organized within entities. Complex objects are instances of complex types. For more information, see ComplexType Element (CSDL) and complex type (Entity Data Model).

ComplexType

The specification for a data type that represents a non-scalar property of an entity type that does not have a key property.

conceptual model

An abstract specification for the entity types, complex types, associations, entity containers, entity sets, and association sets in the domain of an application in the Entity Framework. The conceptual model is defined in CSDL in the .csdl file.

.csdl file

An XML file that contains the conceptual model, expressed in CSDL.

conceptual An XML-based language that is used to define the entity types, associations, entity schema definition containers, entity sets, and association sets of a conceptual model. language (CSDL) For more information, see CSDL Specification.

container

A logical grouping of entity and association sets.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

33/47

concurrency

A process that allows multiple users to access and change shared data at the same time. By default, the Entity Framework implements an optimistic concurrency model.

direction

Refers to the asymmetrical nature of some associations. Direction is specified with FromRole and ToRole attributes of a NavigationProperty orReferentialConstraint element in a schema. For more information, see NavigationProperty Element (CSDL) and navigation property (Entity Data Model).

.edmx file

An XML file that contains the conceptual model (in CSDL), the storage model (in SSDL), and the mappings between them (in MSL). The .edmx file is created by the Entity Data Model Tools. For more information, see .edmx File Overview (Entity Framework).

end

A participating entity in an association. For more information, see End Element (CSDL) and association end (Entity Data Model).

entity

A concept in the domain of an application from which a data type is defined. For more information, see EntityType Element (CSDL) and entity type (Entity Data Model).

EntityClient

A storage-independent ADO.NET data provider that contains classes such as EntityConnection, EntityCommand, and EntityDataReader. Works with Entity SQL and connects to storage specific ADO.NET data providers, such as SqlClient. For more information, see EntityClient Provider for the Entity Framework.

entity container

Specifies entity sets and association sets that will be implemented in a specified namespace.

Entity Data Model (EDM)

A set of concepts that describe the structure of data, as entities and relationships, regardless of its stored form.

Entity Framework A set of technologies that supports development of data-oriented software applications by enabling developers to work with conceptual models that are mapped to logical schemas in data sources. For more information, see Entity Framework Overview.

entity set

A logical container for entities of a given type and its subtypes. Entity sets are mapped to tables in a database.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

34/47

Entity SQL

A storage-independent dialect of SQL that works directly with conceptual entity schemas and that supports conceptual model concepts such as inheritance and relationships. For more information, see Entity SQL Language.

entity type

A .NET Framework class that represents an entity as it is defined in the conceptual model. Entity types may have scalar, complex, and navigation properties. Objects are instances of entity types. For more information, see Object Services Overview (Entity Framework).

EntityType

The specification for a data type that includes a key and a named set of properties and represents a top-level item in a conceptual model or storage model. For more information, see EntityType Element (CSDL) and entity type (Entity Data Model).

explicit loading

When objects are returned by a query, related objects are not loaded at the same time. By default, they are not loaded until explicitly requested using the Load method on a navigation property. For more information, see Loading Related Objects (Entity Framework).

foreign key association

An association between entities that is managed through foreign key properties. For more information, see Defining and Managing Relationships (Entity Framework).

identifying relationship

A relationship where the primary key of the principal entity is part of the primary key of the dependent entity. In this kind of relationship, the dependent entity cannot exist without the principal entity. For more information, see Defining and Managing Relationships (Entity Framework).

key

The attribute of an entity type that specifies which property or set of properties is used to identify unique instances of the entity type. Represented in the object layer by the EntityKey class.

lazy loading

When objects are returned by a query, related objects are not loaded at the same time. Instead they are loaded automatically when the navigation property is accessed. For more information, see Loading Related Objects (Entity Framework).

LINQ to Entities

A query syntax that defines a set of query operators that allow traversal, filter, and projection operations to be expressed in a direct, declarative way in Visual C# and Visual Basic. For more information, see LINQ to Entities.

mapping

A specification of the correspondences between items in a conceptual model and items

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

35/47

in a storage model.

.msl file

An XML file that contains the mapping between the conceptual model and the storage model, expressed in MSL.

mapping specification language (MSL)

An XML-based language that is used to map items defined in a conceptual model to items in a storage model.

multiplicity

The number of entities that can exist on each side of a relationship, as defined by an association. Also known as cardinality.

navigation property

A property of an entity type that represents a relationship to another entity type, as defined by an association. Navigation properties are used to return related objects as an EntityCollection or an EntityReference, depending on the multiplicity at the other end of the association. For more information, see NavigationProperty Element (CSDL) and navigation property (Entity Data Model).

query path

A string representation of a path that specifies which related objects to return when an object query is executed. A query path is defined by calling the Include method on an ObjectQuery. For more information, see Loading Related Objects (Entity Framework).

object context

Represents the entity container defined in the conceptual model. It contains a connection to the underlying data source and provides services such as change tracking and identity resolution. An object context is represented by an instance of the ObjectContext class.

object layer

The entity types and object context definitions that are used by the Entity Framework.

object query

A query executed within an object context against a conceptual model that returns data as objects. For more information, see Object Queries (Entity Framework).

object-relational mapping

A technique for transforming data from a relational database into data types that can be used in object-oriented software applications. The Entity Framework provides object-relational mapping services by mapping relational data, as defined in the storage model, to data types, as defined in the conceptual model.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

36/47

For more information, see Object Services Overview (Entity Framework).

Object Services

Services provided by the Entity Framework that enable application code to operate on entities like .NET Framework objects.

referential constraint

A constraint that is defined in a conceptual model that indicates that an entity has a dependent relationship to another entity. This constraint means that an instance of a dependent entity cannot exist without a corresponding instance of the principle entity For more information, see ReferentialConstraint Element (CSDL) and referential integrity constraint (Entity Data Model).

relationship

A logical connection between entities.

role

The name given to each End of an association to clarify the semantics of the relationship. For more information, see End Element (CSDL) and association end (Entity Data Model).

scalar property

A property of an entity that maps to a single field in the storage model.

simple type

A primitive type that is used for defining properties in the conceptual model. For more information, see Conceptual Model Types and Entity Data Model: Primitive Data Types.

storage model

A definition for the logical model of data in a supported data source, such as a relational database. The storage model is defined in SSDL in the .ssdl file. For more information, see Modeling and Mapping (Entity Framework) and SSDL Specification.

.ssdl file

An XML file that contains the storage model, expressed in SSDL.

store schema definition language (SSDL)

An XML-based language that is used to define the entity types, associations, entity containers, entity sets, and association sets of a storage model that frequently corresponds to a database schema. For more information, see SSDL Specification.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

37/47

C14_2012_Entity Framework (Continuare) Object Services (OS)

OS reprezinta nivelul cel mai de sus pentru EF. Object Services lucreaza direct cu obiectele instantiate (namespace System.Data.Objects) si furnizeaza functionalitatea necesara pentru a genera si a interactiona cu obiectele din modelul conceptual ce isi extrag datele din baza de date. OS proceseaza cereri Linq To Entities (LtE) si ObjectQuery rezultand obiecte. Clasa de baza ObjectContext.

Ce face Object Services? Proceseaza cereri; Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

38/47

Returneaza obiecte; Gestioneaza obiecte; Gestioneaza obiectele relatii; Gestioneaza starea obiectelor; Trimite schimbarile catre baza de date; Implementeaza serializarea, asocierea datelor (data binding), etc.

Procesare cereri
OS foloseste functionalitatea data de EntityClient. Procesarea cererii implica translatare cereri Linq To Entities sau Linq Sql in cereri SQL pe care baza de date le poate executa. La nivelul de jos fiecare cerere este parsata intr-o comanda arbore (command tree) a lui LINQ sau Linq SQL. Providerii (Oracle, Sql Server, etc.) transforma aceste comenzi in comenzi specifice dialectului SQL recunoscut de baza de date. Command tree se exprima cu entitati din modelul conceptual. Urmatoarea figura schematizeza modul de tratare al unei cereri.

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

39/47

Observatie De remarcat cele trei posibilitati de realizare a unei cereri si modul de executie in fiecare din cazuri. Vom analiza in continuare clasele importante din EF din care enumeram : ObjectContext, ObjectSet, EntityObject, ObjectQuery.

Clasa ObjectContext
Furnizeaza facilitate pentru cereri si lucrul cu date ca obiecte ce sunt instante ale tipurilor entitate definite in modelul conceptual. O instanta a clasei ObjectContext contine urmatoarele : Conexiune la bd in forma unui obiect EntityConnection ; Metadata ce descrie modelul, obiect MetadataWorkspace ; Un obiet ObjectStateManager ce gestioneaza obiectele din cache.
EntityConnection : Contine o referinta la modelul conceptual si o conexiune la sursa de

date. Este ceva asemanator cu obiectele Connection, Command din ADO.NET.

MetadataWorkspace : poate fi folosita pentru a interactiona cu modelul conceptual in contextual unei aplicatii date. Se pot obtine o multime de informatii la runtime.
Exemplu :

private static void MetadataWorkspaceExemplu() { Console.WriteLine("MetadataWorkspace... CSpace"); EntitiesCustomer ent = new EntitiesCustomer(); MetadataWorkspace mw = ent.MetadataWorkspace; var items = mw.GetItems<EntityType>(DataSpace.CSpace); foreach (var i in items) { Console.WriteLine("Table Name: {0}", i.Name); Console.WriteLine("Keys:"); foreach (var key in i.KeyMembers) { Console.WriteLine("{0} ({1})", key.Name, key.TypeUsage.EdmType.FullName); } } Console.WriteLine("Metadata CSpace members..."); foreach (var i1 in items) { Console.WriteLine("Table Name: {0}", i1.Name); foreach (var key in i1.Members) { Console.WriteLine("{0} ({1})", key.Name, key.TypeUsage.EdmType.FullName); } } }

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework
Rezultatul : MetadataWorkspace... CSpace Table Name: CUSTOMER Keys: CUSTOMERID (Edm.Int16) Table Name: ORDER Keys: ORDERID (Edm.Int16) Table Name: ORDERDETAIL Keys: ORDERID (Edm.Int16) SERIAL (Edm.Int16) Metadata CSpace members... Table Name: CUSTOMER CUSTOMERID (Edm.Int16) NAME (Edm.String) ADRESA (Edm.String)

17.01.2012

40/47

ORDERs (Transient.collection[Model1.ORDER(Nullable=True,DefaultValue=)]) Table Name: ORDER ORDERID (Edm.Int16) DATA (Edm.DateTime) CUSTOMERID (Edm.Int16) VALOARE (Edm.Decimal) CUSTOMER (Model1.CUSTOMER) ORDERDETAILS (Transient.collection[Model1.ORDERDETAIL(Nullable=True,DefaultVal ue=)]) Table Name: ORDERDETAIL ORDERID (Edm.Int16) PRODUS (Edm.String) VALOARE (Edm.Decimal) SERIAL (Edm.Int16) ORDER (Model1.ORDER)

Observatie Examinati si alte posibilitati oferite de DataSpace

var items = mw.GetItems<EntityType>(DataSpace.CSpace);

ObjectStateManager :
Mentine starea obiectelor si identitatea managementului pentru instantele tipului entitate si a instantelor relatiilor. Este folosita de ObjectContext si nu in mod direct in aplicatie. Revenire la ObjectContext Clasa ce reprezinta EntityContainer este derivata din ObjectContext.

Exemplu (vezi cursul anterior):

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

41/47

public partial class EntitiesCustomer : ObjectContext { // cod public ObjectSet<CUSTOMER> CUSTOMERs { get { if ((_CUSTOMERs == null)) { _CUSTOMERs = base.CreateObjectSet<CUSTOMER>("CUSTOMERs"); } return _CUSTOMERs; } } private ObjectSet<CUSTOMER> _CUSTOMERs; // cod }

Metode - MSDN
Name AcceptAllChanges AddObject Attach
Description Accepts all changes made to objects in the object context. Adds an object to the object context. Attaches an object or object graph to the object context when the object has an entity key. Creates the entity key for a specific object, or returns the entity key if it already exists. Creates and returns an instance of the requested type . Creates a new ObjectSet <TEntity > instance that is used to query, add, modify, and delete objects of the specified entity type. Creates an ObjectQuery <T > in the current object context by using the specified query string. Marks an object for deletion. Removes the object from the object context. Ensures that ObjectStateEntry changes are synchronized with changes in all objects that are tracked by theObjectStateManager. Executes a stored procedure or function that is defined in the data source and

CreateEntityKey

CreateObject <T > CreateObjectSet <TEntity >() CreateQuery <T >

DeleteObject Detach DetectChanges

ExecuteFunction

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework
(String, ObjectParameter []) ExecuteStoreCommand

17.01.2012

42/47

expressed in the conceptual model; discards any results returned from the function; and returns the number of rows affected by the execution. Executes an arbitrary command directly against the data source using the existing connection.

ExecuteStoreQuery Executes a query directly against the data source that returns a sequence of typed <TElement >(String,Obj results. ect []) GetObjectByKey GetObjectType
Returns an object that has the specified entity key. Returns the entity type of the POCO entity associated with a proxy object of a specified type. Updates a collection of objects in the object context with data from the data source. Updates an object in the object context with data from the data source.

Refresh(RefreshMode, IEnumerable) Refresh(RefreshMode, Object) SaveChanges ()

Persists all updates to the data source and resets change tracking in the object context. Persists all updates to the data source with the specified SaveOptions.

SaveChanges( SaveOptions)

Proprietati
Name CommandTimeout
Description Gets or sets the timeout value, in seconds, for all object context operations. A null value indicates that the default value of the underlying provider will be used. Gets the connection used by the object context. Gets the ObjectContextOptions instance that contains options that affect the behavior of the ObjectContext.

Connection ContextOptions

DefaultContainerName Gets or sets the default container name. MetadataWorkspace ObjectStateManager

Gets the metadata workspace used by the object context. Gets the object state manager used by the object context to track object changes. Gets the LINQ query provider associated with this object context.

QueryProvider

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework Evenimente

Name
Description

17.01.2012

43/47

ObjectMaterialized Occurs when a new entity object is created from data in the data source as
part of a query or load operation.

SavingChanges

Occurs when changes are saved to the data source.

Clasa ObjectSet
Reprezinta o entitate tipizata folosita pentru operatii de creare, citire, actualizare si stergere. Metode (MSDN): selectie Metodele extinse nu sunt discutate.
Name AddObject Attach
Description Adds an object to the object context in the current entity set. Attaches an object or object graph to the object context in the current entity set. Creates a new entity type object. Creates an instance of the specified type.

CreateObject () CreateObject <T >() DeleteObject Detach Execute

Marks an object for deletion. Removes the object from the object context. Executes the object query with the specified merge option. (Inherited from ObjectQuery <T >.) Groups the query results by the specified criteria. (Inherited from ObjectQuery <T >.) Specifies the related objects to include in the query results. (Inherited from ObjectQuery <T >.) Limits the query results by including only the results that exist in another object query. (Inherited from ObjectQuery <T >.) Orders the query results by the specified criteria. (Inherited from ObjectQuery <T >.) Limits the query results to only the properties that are defined in the specified projection. (Inherited from ObjectQuery <T >.) Limits the query results to only the property specified in the

GroupBy

Include

Intersect

OrderBy

Select

SelectValue

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework
<TResultType > Skip

17.01.2012

44/47

projection. (Inherited from ObjectQuery <T >.) Orders the query results by the specified criteria and skips a specified number of results. (Inherited from ObjectQuery <T >.) Limits the query results to a specified number of items. (Inherited from ObjectQuery <T >.) Returns the commands to execute against the data source. (Inherited from ObjectQuery.) Combines the results of the query with the results of another object query, without any duplicates. (Inherited from ObjectQuery <T >.) Combines the results of the query with the results of another object query, including all duplicates. (Inherited from ObjectQuery <T >.) Limits the query to results that match specified filtering criteria. (Inherited from ObjectQuery <T >.)

Top

ToTraceString

Union

UnionAll

Where

Proprietati
Name CommandText Context
Description Returns the command text for the query. (Inherited from ObjectQuery.) Gets the object context associated with this object query. (Inherited from ObjectQuery.)

EnablePlanCaching Gets or sets a value that indicates whether the query plan should be
cached. (Inherited from ObjectQuery.)

EntitySet

Gets the metadata of the entity set represented by this ObjectSet <TEntity > instance. Gets or sets how objects returned from a query are added to the object context. (Inherited from ObjectQuery.) Gets or sets the name of this object query. (Inherited from ObjectQuery <T >.) Gets the parameter collection for this object query. (Inherited from ObjectQuery.)

MergeOption

Name

Parameters

ObjectQuery si LINQ to Entities

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

45/47

ObjectQuery este clasa ce furnizeaza toate informatiile de care contextul are nevoie pentru a executa cererea. ObjectSet este de tip ObjectQuery si implementeaza interfata IObjectSet ce furnizeaza functionalitatea asemanatoare colectiilor.

IObjectSet si ObjectQuery implementeaza IQueryable, ce este un tip de cerere LINQ. IQueryable contine metadata despre cerere (expresia cererii, provider).

Observatie : sagetile nu arata corect ordinea de derivare.

IQueryable este o legatura intre ObjectSet/ObjectQuery si cererile LINQ to Entities.

Dupa ce cererea a fost executata, IQueryable expune metadata cererii si rezultatul. Rezultatul din interiorul IQueryable este descris ca un tip enumerabil , bazat pe interfata IEnumerable. Pentru ObjectQuery in MSDN :

Constructors
Name ObjectQuery () Description Initializes a new instance of the ObjectQuery class with no initialized values. This is the default constructor. Initializes a new instance of the ObjectQuery class for a specific query string. Initializes a new instance of the ObjectQuery class for a specific query string

ObjectQuery(String)

ObjectQuery(String,

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

46/47

String)

and language.

Metode
Name Description ParseQuery Parses the query string and sets the property values accordingly. If the query is valid, the class name property and condition property of the query will be parsed. (Inherited from ManagementQuery.)

Proprietati
Name QueryString Description Gets or sets the query in text format. (Inherited from ManagementQuery.)

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi

Entity Framework

17.01.2012

47/47

Clasa EntityObject
Tipul de baza pentru clasele generate de EDM. MSDN

Constructors
Name Description EntityObject Initializes a new instance of the EntityObject class.

Metode
Name OnPropertyChanged OnPropertyChanging ReportPropertyChanged Description Raises the PropertyChanged event. (Inherited from StructuralObject.) Raises the PropertyChanging event. (Inherited from StructuralObject.) Notifies the change tracker that a property has changed. (Overrides StructuralObject .ReportPropertyChanged(String) .)

ReportPropertyChanging Notifies the change tracker that a property change is pending. (Overrides StructuralObject .ReportPropertyChanging(String).) SetValidValue <T >(T, T, String) Sets a complex object for the specified property. (Inherited from StructuralObject.)

Proprietati
Name EntityKey Description Gets or sets the key for this object.

EntityState Gets the entity state of the object.

Events
Name PropertyChanged Description Occurs when a property value has changed. (Inherited from StructuralObject.)

PropertyChanging Occurs when a property value change is a pending. (Inherited from StructuralObject.)

Ioan Asiminoaei Facultatea de Informatica, Universitatea Al. I. Cuza - Iasi