Professional LINQ phần 10 ppsx

The following example illustrates how to use the entity data model to update and insert data: string ln = "Kleinerman"; productSalesContext = new AdventureWorksEntities; Contact con = pr

foreach (SalesOrderHeader order in query.First().SalesOrderHeader)

}

}

Querying the entity data model is quite easy and efficient

Wor king with Objects

Let’s take a look at working with objects that represent entity types defined by an entity data model

The following example illustrates how to use the entity data model to update and insert data:

string ln = "Kleinerman";

productSalesContext = new AdventureWorksEntities();

Contact con = productSalesContext.Contact.Where("it.LastName = @lastname",

new ObjectParameter("lastname", ln)).First();

As you saw earlier, you can also bind objects to controls, like this:

ObjectQuery<Contact> salesPerson = productSalesContext.Contact.Where

("it.ContactID < 5000").OrderBy("it.LastName");

this.cbosalesPerson.DataSource = salesPerson.Include("SalesOrderHeader

this.cbosalesPerson.DisplayMember = "LastName";

A best practice is to detach objects from theObjecContextwhen they are no longer needed Object

Services lets you accomplish this via theDetachmethod This decreases the amount of memory

being used

Object Services, implemented via theSystem.Data.ObjectsandSystem.Data.Objects.DataClasses

namespaces, is a component of the NET Entity Framework that enables you to perform CRUD operations

that are expressed as strongly typed CLR objects These objects are instances of entity types Supporting

both LINQ and Entity SQL queries, Object Services lets you query against defined types as well as track

changes and bind objects to controls

productSalesContext.Detach(Contact.SalesOrderHeader);

Another good practice is to manage concurrency conflicts in an object context Making changes back to

the database could cause conflicts, so those need to be handled In the following example, the

SaveChanges()method is called to save any changes back to the database If there are any conflicts,

they are caught, the object context is refreshed, andSaveChanges()reapplied

Hopefully, you can see that working with objects is just as simple as working with LINQ to SQL

Entity Data Model Generator

The Entity Data Model Generator tool is one of the options available to the developer for generating the

entity data model It is a command-line tool that provides the following functionality:

❑ Create.csdl,.ssdl, and.mslfiles that are used by the entity data model

❑ Validate existing models

❑ Generate source code files containing object classes generated from a.csdlfile

❑ Generate source code files containing generated views from the.ssdl,.csdl, and.mslfiles

The Entity Data Model Generator tool is located in\Windows\Microsoft.NET\Framework\v3.5

Its general syntax is:

EdmGen /mode:choice [options]

The following table lists the available modes for the EdmGen tool You must specify one of them

Mode Description

ValidateArtifacts Validates the.cdsl,.ssdl, and.mslfiles Requires at least one

/inssdlor/incsdlargument If/inmslis specified, the/inssdland

/incsdlarguments are also required

FullGeneration Generates.cdsl,.ssdl, and.msl, object layer and view files Updates

the database connection information in the/connectionstringoption

Requires a/connectionstringargument and either a/p argumentor

/outssdl,/outcsdl,/outmsdl,/outobjectlayer,/outviews, and

/entitycontainerarguments

FromSSDLGeneration Generates.cdsl, and.msl, files Requires the/inssdlargument and

either a/pargument or/outcsdl,/outmsl,/outobjectlayer,/outviews, and/entitycontainerarguments

EntityClassGeneration Creates a source code file that contains generated classes from the

.csdlfile Requires the/incsdlargument and either a/por

/outobjectlayerargument

ViewGeneration Creates a source code file containing views generated from the.ssdl,

.csdl, and.mslfiles Requires the/inssdl,/incsdl,/inmsl, andeither the/por/outviewsarguments

Along with the modes, you can specify one or more of the following options

Option Description

/p[roject]: String value that specifies the object name

/prov[ider]: String value that specifies the name of the ADO.NET data provider The

default isSystem.Data.Sqlclient(the NET Framework Data Providerfor SQL Server)

/c[onnection]: String value that specifies the string used to connect to the data source

/incsdl: Specifies the.csdlfile or a directory where the.csdlfiles are located

Argument can be specified multiple times

/refcsdl: Specifies additional.csdlfiles used to resolve.csdlsource file references

specified by the/incsdloption

/inmsl: Specifies the.mslfile or a directory where the.mslfiles are located

Argument can be specified multiple times

/inssdl: Specifies the.ssdlfile or a directory where the.ssdlfile is located

/outcsdl: Specifies the name of the.csdlfile to be created

/outmsl: Specifies the name of the.mslfile to be created

/outssdl: Specifies the name of the.ssdlfile to be created

/outobjectlayer: Specifies the name of the source code file containing the generated objects

fro the.csdlfile

Option Description

/outviews: Specifies the name of the source code file containing the generated views

/language: Specifies the language for the generated source code files Options are VB

and C# Default is C#

/namespace: Specifies the namespace to use and set in the.csdlfile when running in

FullGenerationorFromSSDLGenerationmode Not used in the

EntityClassGenerationmode

/entitycontainer: Specifies the name to apply to the<EntityContainer>element in the

EDM file

The following examples show how the EdmGen tool can be used The first example uses the

FullGenerationmode to generate all necessary files:

edmgen /mode:fullgeneration /c:"Data Source=AvalonServer;Initial

Catalog=AdventureWorks; Integrated Security=SSPI" /p:LINQProject

In this example, a C# object source code file is created from the.csdl:

edmgen /mode:entityclassgeneration /incsdl:c:\wrox\Appendix\LINQ\

AdventureWorksModel.csdl /outobjectlayer: c:\wrox\Appendix\LINQ\

AdventureWorksModel.cs /language:csharp

The ADO.NET Entity Framework clearly helps you work with relational databases as well as model

entities and relationships

LINQ to XSD

Any programming language that supports the NET Framework will support LINQ LINQ to XML

is LINQ-enabled, meaning that you have access to all of the functionality of LINQ such as the

standard query operators and the LINQ programming interface Because of the integration into the

.NET Framework, LINQ to XML can take advantage of functionality the NET Framework provides,

such as compile-time checking, strong typing, and debugging

LINQ to XML makes working with XML much easier by providing a simple way to work directly

with methods and properties, by programming against XML tree components such as elements and

attributes, but in an untyped manner This is where LINQ to XSD comes in LINQ to XSD lets you

work with typed XML

Although LINQ to XSD is in its early stages, it’d be a shame not to include it in this book It will

probably change somewhat, but the purpose of this appendix is to provide you with an introduction

to LINQ to XSD and show you some of its capabilities This is a cool technology and makes working

with XML a pleasure

LINQ to XSD has been scheduled to release after the release of Visual Studio 2008 At the time of this

writing the current release of LINQ to XSD is the LINQ to XSD Preview 0.2 that works with Beta 1

of Orcas To work with the examples in this appendix, you need to install Beta 1 of Visual Studio

codenamed Orcas.

LINQ to XSD Over view

LINQ to XSD is a new technology aimed at enhancing the great LINQ to XML technology by

providing NET developers support for typed XML programming For example, in typical LINQ

to XML programming, you would work with an XML tree as follows:

var total = (from item in SalesOrderHeader.Elements("Item")

select (double)item.Element("UnitPrice")

* (int)item.Element("OrderQuantity")).Sum();

In this example, the developer is working with untyped XML, accessing the elements and attributes of

the XML directly However, LINQ to XSD lets you work with typed XML, like this:

var total = (from item in SalesOrderHeader.Item

select item.UnitPrice * item.OrderQuantity).Sum();

Working with typed XML is made possible by XML schemas that are mapped automatically to defined

object models Through this mapping XML data can be manipulated just like other object-oriented

models The result is that you are working directly with classes that can enforce validation through

the use of the schema, plus you are working with XML objects generated from the XML schemas that

provide a much more efficient XML development platform

The benefit of working with typed XML is that it makes working with XML-related programming tasks

much easier and makes for much more efficient code

Installing LINQ to XSD

For now, LINQ to XSD is not installed when you install any beta of Visual Studio It is a completely

separate install and is currently found at the following location:

http://www.microsoft.com/downloads/details.aspx?FamilyID=e9c23715

-9e71-47a7-b4db-363c2a68fab4&DisplayLang=en

At a mere 1.6 megabytes, it’s a quick download The install is simple At the Welcome screen, click Next

On the License Agreement screen, select the I Agree option to continue with the installation, then click

the Next button The final screen of the installation wizard lets you know that the installer is ready to

install LINQ to XSD Click Next to begin the install

Once the installation is complete, you’ll notice a new Start menu option called LINQ to XSD Preview You

can tell that Microsoft is serious about this technology because not only does the LINQ to XSD installation

install the necessary support files for LINQ to XSD, but it also installs several support documents along

with a couple of great LINQ to XSD Visual Studio example projects How cool is that?

LINQ to XSD Example

The easiest way to get a feel for LINQ to XSD and to understand what it can do is to tackle an example

You’re going to need Beta 1 as stated earlier, but before you fire up Visual Studio, a little prep work needs

to be done

In the Wrox directory on your local hard drive, create a folder calledAppendixC.Next, open your favorite

text editor and enter the following XML Save the file asOrders.xml.The data that this XML uses comes

from theSalesOrderDetailtable in the AdventureWorks database Obviously it is not all the records

from that table, but only a small subset of orders from a specific customer

<Order>

<OrderDetail>

<CustID>676</CustID>

Once you have created theOrders.xmlfile, fire up Visual Studio and create a new C# Windows project.

In the Project types section, expand the C# node Select the LINQ to XSD Preview project type, and thenchoose the LINQ to XSD Windows Application from the list of project templates (see Figure C-1)

Name the project LINQ, specifying the appropriate location in which to create the project Click OK

Now open the Solution Explorer and expand the References node Besides the typical LINQ reference of

System.Xml.Linq, you’ll see a new reference toMicrosoft.Xml.Schema.Linq, shown in Figure C-2 Thisnamespace contains all the XML classes that provide the LINQ to XSD mapping functionality and XSDschema definition support

Next, openForm1in design mode and drop a couple of buttons and a text box on the form Set theText

property of button1 toUntyped, and then double-click the button to view itsClickevent Enter the

following code in the button1Clickevent:

var order = XElement.Load("C:\\Wrox\\AppendixC\\Orders.xml");

var total = (from salesOrder in order.Elements("OrderDetail")

from item in salesOrder.Elements("Item")

select (double)item.Element("UnitPrice")

* (int)item.Element("OrderQuantity")).Sum();

textBox1.Text = total.ToString();

Figure C-1

Figure C-2

From the Build menu, select Build Solution to ensure that the project compiles Then run the applicationand click the Untyped button The text box should be populated with the value of 2280.63, as shown inFigure C-3.

Figure C-3

This example is similar to the examples you worked with in the Chapters 5 through 9 in the LINQ to

XML section It uses theLoadmethod of theXElementmethod to load an XML document into memory

A LINQ query expression is then executed against the XML document, using thesum( ) query operator tosum all the order totals The results are the displayed in the text box

Notice that because the XML document is untyped, the use of theElementsmethod is needed to specifythe element you’re looking for Because no mapping taking place, you have to physically specify the

element name

Wouldn’t it be nice to be able to use typed XML programming? Ah, yes, you can First, open the

Orders.xmlfile and add the following highlighted namespace to it:

Next, highlight the entire XML tree and copy it to the Clipboard Go back to your Visual Studio project,

and in the Solution Explorer window right-click the solution and select Add ➪ New Item from the context

menu In the Add New Item dialog, select XML File in the Templates section (see Figure C-4)

Figure C-4For the purposes of this example, you can keep the name ofXMLFile1.xml.Click Add

XMLFile1.xmlopens in the IDE and contains a single header line Delete the XML that is there, and paste

the XML that you copied fromOrders.xmlto the Clipboard Save the newXMLFile.xmlfile

Next, return to Solution Explorer and add a new item, this time selecting an XML Schema template

from the Add New Item dialog When the schema opens, delete the default contents of the file, add the

following XML, and save it:

<xs:element name="ProductID" type="xs:string"/>

<xs:element name="UnitPrice" type="xs:double"/>

<xs:element name="OrderQuantity" type="xs:int"/>

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:schema>

You’re not quite done yet Once you have created the schema, a property needs to be changed on it

Return to the Solution Explorer window, right-click on theXMLSchema1.xsdfile, and select Properties

from the context menu, as shown in Figure C-5

Figure C-5

In the Properties window for the schema, select the property called Build Action The default value for

this property isNone; change it toLinqToXsdSchema, as shown in Figure C-6 This property informs theproject that the schema will be included in the project’s build process

Figure C-6The final step is to add some code behind the form Set the Text property of the second button to Typed,

and double-click the button to display theClickevent code for that button

Before you add the code to theClickevent, scroll to the top of the code and add the following

using statement:

using www.AdventureWorks.com.Orders;

Finally, in theClickevent forbutton2, add the following:

var ord = Order.Load("C:\\Wrox\\AppendixC\\Orders.xml");

var total = (from purchaseOrder in ord.OrderDetail

from item in purchaseOrder.Itemselect item.UnitPrice * item.OrderQuantity).Sum();

textBox1.Text = total.ToString();

Notice that as you type, IntelliSense kicks in and displays the mapping between the XML and the XSD

You know typed XML programming is here, and now you only need to typeorder.OrderDetail

Now, compile and run the application, and click the Typed button You will get the same results in the

text box that you did when you click the Untyped button

Cool, huh? But wait What is thisOrderobject in the first line that theLoadmethod uses? Where did that

come from? Put your mouse cursor over the word Order and right-click From the context menu, select

Go To Definition (see Figure C-7)

A file calledLinqToXsdSourcesopens, as shown in Figure C-8.

This file is an external mapping file created by LINQ to XSD when the project is compiled As you can

see, it is a fairly lengthy file, but it contains all the necessary mapping information to effectively providetyped XML programming

An instance of LINQ to XSD is a set of classes that form wrappers around an instance of the LINQ to

XMLXElementclass

Mapping Rules

When a schema is mapped to an object type, LINQ to XSD requires that the mapping meet

several constraints:

❑ The mapping is understandable to the developer

❑ The mapping does not rely on any customization by default

❑ The mapping must derive classes that are close to the expectation of an OO programmer

❑ The mapping facilitates round-tripping of instance data

❑ The mapping conveys, where possible, most schema objectives into the object models

This systematic rule mapping ensures a clean, precise mapping, and is assumed by LINQ to XSD The

following is a list of most of the mapping rules that are utilized by LINQ to XSD to map XML schemas to

.NET object models:

❑ Global element declarations are mapped to classes

❑ Complex-type definitions are mapped to classes

❑ Local declarations of elements, attributes, and references are mapped to properties

❑ Named and anonymous types by default are not mapped to classes

❑ Simple-type references are mapped to CLR value types or strings

❑ Anonymous complex types for local elements by default are mapped to inner classes

❑ Simple-type restrictions are mapped to element property preconditions

❑ Complex-type derivation is mapped to object-oriented subclassing via extension and restriction

❑ Substitution grouping is mapped to object-oriented subclassing

❑ Redefinitions are carried out before mapping as applied bySystem.Xml.Schemarules

LINQ to XSD-Generated API Class Methods

This section briefly discusses the methods of the API classes that LINQ to XSD generates from XML

schemas These methods should seem familiar because they are also methods within LINQ to XML

However, they are the typed version of the methods

The current release of LINQ to XSD is in its early stages, so these API methods could change

Load Method

You’ve seen theLoadmethod used a couple of times in the example in this appendix The first was the

LINQ to XML’sLoadmethod on theXElement The second time it was used was on the typed version of

a generated class

Loadcreates an instance of the generated class, letting the newly created instance serve as a typed view on

anXElementinstance Take a look at the various overloads for theLoadmethod First, here’s an examplethat takes a URI string as the data source:

public static val Load(string uri);

The next example is the same as the first, but it includes a parameter to control the preservation

of whitespace

static val Load(string uri, bool preserveWhitespace);

Here’s how to use a TextReader as the data source:

static val Load(TextReader tr);

The following example is the same as the previous example except that it includes a parameter to controlthe preservation of whitespace Notice that this example also uses a TextReader as the data source

static val Load(TextReader tr, bool preserveWhitespace);

Here’s how to use an XmlReader as the data source

static val Load(XmlReader xr);

The following example, taken from earlier in the appendix, shows how the Load method is used on a

typedXElement

var ord = Order.Load("C:\\Wrox\\AppendixC\\Orders.xml");

Keep in mind that these overloads may change in the actual release of LINQ to XSD

Parse

TheParsemethod of a generated class is the typed version of the LINQ to XMLXElement Parsemethod.This method takes an XML string and parses it into anXElementinstance, casting that instance into therequested type of the static method call.Parsehas two overloads The first takes a string parameter, asshown here:

public static XElement Parse(string text);

An optional parameter can be passed to preserve the whitespace:

public static XElement Parse(string text, bool preserveWhitespace);

The following example shows how to use the typed version of theParsemethod

var ord = Order.Parse("C:\\Wrox\\AppendixC\\Orders.xml");

Save

TheSavemethod of a generated class is the typed version of the LINQ to XMLXElement Savemethod

As with the LINQ to XMLSavemethod, the typed version of theSavemethod takes the source XML tree

and forwards it to the wrappedXElementinstance for saving

Savehas several overloads This first example shows the syntax to save the output to a text file:

public void Save(string filename);

The following example is the same as the first example but includes a parameter to control the

preservation of whitespace:

public void Save(string filename, bool preserveWhitespace);

Here’s an example that shows the syntax to save the output to a TextWriter:

public void Save(TextWriter tw );

The following example from earlier in the appendix shows how theSavemethod is used on a typed

XElement

public void Save(TextWriter tw, bool preserveWhitespace);

Here’s how to write the output to an XmlWriter:

public void Save(XmlWriter xw );

The following example shows how to use the typed version of theSavemethod to save the output to a

text file

var ord = Order.Load("C:\\Wrox\\AppendixC\\Orders.xml");

// process the xml tree

order.Save("C:\\Wrox\\AppendixC\\Orders2.xml");

Clone

TheClonemethod clones the entire underlying untyped XML tree The capability to clone is provided by

the generated classes’ base class,XTypedElement TheClonemethod is quite simple to use, but the result

of a clone is weakly typed and therefore a cast must be used to access the intended type

For example, the following code shows the original XML tree being cloned into a second XML tree whilebeing cast to the original type Once the cast and clone are executed, it can be used just like the originalXML tree.

var ord = Order.Load("C:\\Wrox\\AppendixC\\Orders.xml");

var ord2 = (Order)ord.Clone();

var total = (from purchaseOrder in ord2.OrderDetail

from item in purchaseOrder.Itemselect item.UnitPrice * item.OrderQuantity).Sum();

textBox1.Text = total.ToString();

Default Values

Default values affect the behavior of the getters for properties that implement declarations for elements

or attributes for defaults That is, when the element or attribute is not found in the XML tree, the getterfor either the attribute or element returns the default value

For example, the following XSD schema fragment contains an element declaration that also defines a

default value for theDepartmentelement

<xs: ComplexType name="EmployeeInfo">

<xs:Sequence>

<xs:element name="NationalIDNumber" type="xs:string" />

<xs:element name="LoginID" type="xs:string" />

<xs:element name="Title" type="xs:string" />

<xs:element name="Name" type="xs:string" />

<xs:element name="EmailAddress" type="xs:string" />

</xs:Sequence>

<xs:attribute name="Department" type="xs:string" default="Dev"/>

</xs:ComplexType>

You can build an XML tree that intentionally excludes the definition of aDepartmentelement:

var emp = new EmployeeInfo

Again, the current release of LINQ to XSD and the API of XML objects may, and probably will, change.

For example, the current release of LINQ to XSD does not support defaults for elements, but it does

support defaults for attributes (thus, the use of a default for an attribute in the previous example)

Also, the actual overloads for the API methods may differ

Index