Entity Framework High Level Architecture

With Entity Framework, you can build some sophisticated applications elegantly. What’s the magic under the hood? Below is the Entity Framework Architecture

 
 

 
 

Data Provider

The lowest layer in the Entity Framework is data provider. It translates the common SQL languages such as LINQ via command tree to the native SQL expression, then execute it against the specific DBMS system. Currently only SQL Server Provider is available. The rumor said the Oracle provider is under development. In the future version, Microsoft will develop more data providers to support other data sources such as web services.

 
 

EntityClient Provider.

The EntityClient provider exposes the entity layer to the upper layer. It allows you to write code to query data base using Entity SQL, an entity ware language. The entity model is mapped to the database table via the mapping specification language (MSL ) and mapping engine.

The query pipeline of EntityClient provider compiles the entity sql text to the command tree, then pass it to the data provider.

EntityClient doesn’t materialize object from the data set. Some data intensive application such as Reporting application can leverage the performance benefit of EntityClient layer.

 
 

Object Services.

Object Service is ORM layer of Entity Framework. It materializes the data result to the object instances of entities. Object Service provides rich ORM features such as change tracking, lazy loading and primary key mapping. Both LINQ and Entity SQL could be used to write query.

 
 

Metadata Service

Metadata Service provides centralized API to access the metadata stored in the CSDL, MSL, SSDL and assembly files. Metadata such as entities, associations, entityset is essential for building highly flexible and powerful runtime applications and design-time tools.

 
 

Design Tools.

The Entity Framework provides many tools integrated with visual studio 2008 to improve productivity.

 
 

Entity Framework Tools

Creating entity data model, entity class and mapping the entity layer ( CSDL ) to the source layer (SSDL) could be a labor intensive work for a large enterprise application. ADO.Net 3.5 provides several tools to make you more productive while working with the Entity Framework in the design time.
Entity Data Model Wizard
Generate edmx file which is used by Entity Data Model Designer to display the model graphically. Generate entity classes; You start the wizard by adding an ADO.Net Entity Data Model to your project.
Entity Data Model Designer
Add/Delete/Modify Entities; Properties; Association of the conceptual model. Validate model and mapping; Report Error;

Entity Mapping Details
Map entity types or associations to database tables and columns.
Add a condition. It’s important to create table-per-hierarchy ( TPH ) inheritance mapping.
Entity Model Browser
View the Entity Data Model in tree view style.
EdmGen.exe
A command-line used for working with the Entity Data Model (EDM).
C:\WINDOWS\Microsoft.NET\Framework\v3.5\edmgen.exe
Microsoft (R) EdmGen version 3.5.0.0

Copyright (C) Microsoft Corporation 2007. All rights reserved.

EdmGen Options

/mode:EntityClassGeneration Generate objects from a csdl file

/mode:FromSsdlGeneration Generate msl, csdl, and objects from an ssdl file

/mode:ValidateArtifacts Validate the ssdl, msl, and csdl files

/mode:ViewGeneration Generate mapping views from ssdl, msl,and csdl files

/mode:FullGeneration Generate ssdl, msl, csdl, and objects from the database

/project:<string> The base name to be used for all the artifact files (short form: /p)

/provider:<string> The name of the Ado.Net data provider to be used for ssdl generation. (short form: /prov)

/connectionstring:<connection string> The connection string to the database that you would like to connect to (short form: /c)

/incsdl:<file> The file to read the conceptual mode from

/refcsdl:<file> A csdl file that contains types that the /incsdl file is dependent upon

/inmsl:<file> The file to read the mapping from

/inssdl:<file> The file to read the storage model from

/outcsdl:<file> The file to write the generated conceptual model to

/outmsl:<file> The file to write the generated mapping to

/outssdl:<file> The file to write the generated storage model to

/outobjectlayer:<file> The file to write the generated object layer to

/outviews:<file> The file to write the pre generated view objects to

/language:CSharp Generate code using the C# language

/language:VB Generate code using the VB language

/namespace:<string> The namespace name to use for the conceptual model types

/entitycontainer:<string> The name to use for the EntityContainer in the conceptual model

/help Display the usage message (short form:

/?)

/nologo Suppress copyright message

Examples

To generate a full Entity Model from the Northwind sample database.

EdmGen /mode:FullGeneration /project:Northwind /provider:System.Data.SqlClient /connectionstring:”server=.\sqlexpress;integrated security=true;

database=northwind”
To generate an Entity Model starting from an ssdl file.
EdmGen /mode:FromSSDLGeneration /inssdl:Northwind.ssdl /project:Northwind

To validate an Entity Model.
EdmGen /mode:ValidateArtifacts /inssdl:Northwind.ssdl /inmsl:Northwind.msl

/incsdl:Northwind.csdl

 

Entity Mapping: Table-per-type and Table-per-hierarchy

In the object world, Inheritance is natural thing. However the flat data model cannot be easily mapped to the hierarchy object model. Entity Framework provide TPT and TPH to solve this problem.  

Below is a diagram I draw based on the MSDN Table-per-type sample. The right side is a list of entity types in the source layer while the left side is a list of entity types in the entity layer ( or conceptual layer). In the conceptual layer, the DeptMusic, DeptEnginerring and DeptBussiness are derived from base type Department. That is, four tables have corresponding entity types. Therefore this inheritance solution is called Table-per-type ( TPT ). Although the Department and DeptBusiness tables have no relationship with each other, the primary keys of these tables are mapped to the same DepartmentID of the Department base type.

 

Table-per-hierarchy ( TPH ) is another way to create inheritance entity model in the EDM. The MSDN sample uses one person to hold the persisted data from the Student, Administrator, instructor and Person entities. As you might notice, Person is the base type in the hierarchy while Student, Administrator and Instructor are derived types. The PersonCategory column of the Person table is called discriminator column. If the value of PersonCategory is 0 in the database, when the data is materialized to object via Entity Framework, a person object will be created. A value of 1,2,3 indicate the Student, Instructor and Administrator types respectively. You can use Entity Mapping Detail window to specify discriminator columns and values.

Resolve WCSF installation issues on VS.Net 2008

I installed Web Client Software Factory (WCSF)  June 2007 successfully on VS.Net 2005 in Vista. Later on I try to see if it’s possible to install it against VS.Net 2008, then I got a variety of issues during uninstallation and installation. Here is a list of issues.

1. Uninstall WCSF error:“Unable to get installer types in the C:\Program Files\Microsoft Visual Studio 8\Common7\IDE\PublicAssemblies\WebClientFactoryPackageInstaller.dll assembly. –> Unable to load one or more of the requested types. Retrieve the LoaderExceptions property for more information.”
   
2. Uninstall GAX, GAT, Enterprise Library errors:The errors are very similar. During uninstallation, a blank dialog box is popped up and no message. Click Ok button, uninstallation fails.
3. Cannot install VS.Net 2008 OrcasCurrently there is no official WCSF installer available for VS.Net 2008 .After googling around and trying different approaches, I found Sebastinan Iacomuzzi and Mariano Szklanny posts are very helpful to resolve the first and the second issues. Basically, if you follow the procedure 1) uninstall Enterprise Library; 2) uninstall WCSF; 3) uninstall GAT; 4) uninstall GAX sequencially and use the original installers, you probably have no problem to uninstall WCSF.

   In case you cannot uninstall WCSF or GAX/GAT, you can use Window Install clean up utility to remove them first, then follow Sebastinan’s blog to remove some junk guidance package registry data, which could be found under HKLM\Software\Microsoft\VisualStudio\8.0. 1) Packages\{77d93a80-73fc-40f8-87db-acd3482964b2}\Templates 2) Languages\CodeExpansions\CSharp\Paths 3) Menus; 4) NewProjectTemplates\TemplateDirs.

   As far as to install it on VS.Net 2008 Beta 2, Exeauiel Jadib post saves my days to figure it out, first use Orca MSI table editor to modify the WCSF msi installer, then search 8.0, and replace it to 9.0  in the Registry Locator table.

   It’s also a good idea to keep these installers around when you need to uninstall them in the near future.  

Import flat file using BizTalk

Recently I worked with a client to implement a solution to import data from an Excel file to SQL Server database. In order to provide a seamless user experience, we created a web page to allow user to upload file to server, then use BizTalk server to convert Excel file to XML file and call a web service to upload data into the SQL Server database.

 

By leveraging BizTalk server, we built a highly scalable and available data processing system for my client. Since my goal in this post is to introduce some core tools in the BizTalk, I simplify the real issue by 1) Changing the Excel file to the flat file, 2) the uploaded data is saved into a file.

 

After completing this tutorial, you will be able to create flat file schema, convert flat file to XML file, build pipeline , build map, create orchestration and call web service in a BizTalk application.

 

Step One Create Flat File Schema

BizTalk provides utilities to easily create flat file or XML file schema from scratch or from a wizard.

1. First you need to create a new flat file and save it as product.txt

   1, Adjustable Race, AR-5381

   2, Bearing Ball, BA-8327

   3, BB Ball Bearing, BE-2349

   4,Headset Ball Bearings, BE-2908
    

   The schema for this file should be ProductId, Name, ProductNumber.
    

2. Create an empty BizTalk project, ImportProduct.
    

   
    

3. Once the project is created, right-click the project and add a new item. Select Flat File Schema Wizard in the new item window and name the file as products_FF.xsd.
    

   
    

4. In the Flat File Schema Information window, specify the location of product.txt file and record name Products.
    

   
    

5. The next screen is “Select Document Data”. Read the description in the dialog and ensure all content is selected.
    

   
    

6. Choose “By delimiter symbol” in the Select Record Format screen.
7. Select {CR}{LF} as Child delimiter because I used a carriage return and line feed
    

   
    

8. Once the Child Elements window appears, ensure you change the Element Name of the first row to be readable ProductItem and Element Type of the first row to Repeating Record. For other rows, you just set the Element Type to Ignore because other rows just simply repeat the first row.
    

   
    

9. The next screen basically gives you a chance to review schema and decide if I want to manually change schema or continue to configure the child element. Highlight productItem and click Next button.
    

   
    

10. Select comma in the Child delimiter of the Delimited Record screen.
     

    
     

11. Modify the Element Name, Element Type and Data Type as the following screenshot.
     

    
     
     

12. Right-click the Product_FF.xsd file, you can validate schema ( useful if you change schema manually ), validate instance and generate instance through the context menu.
     
13. Next, you need to create a key file to assign a strong name to the assembly. If you have a key file, you can skip this step. Open Visual Studio 2005 Command Prompt, type sn -k product.snk, then press ENTER. Then set key file in the ImportProduct project property page. Click OK to close the Property dialog.
     

    
     

    You also need to assign application name, ImportProudct under Configuration Properties.

14. Right-click the ImportProduct project to build and deploy it.
     

    
     

    If you’re using Vista like me and you get “Access is denied” error, ensure that you run the Visual Studio as the Administrator.
     

    Step Two Create Pipeline
    
     

    After completing schema file, you need to create a pipeline to disassemble the flat file messages.
     

    Understanding Pipeline
    

    A pipeline is an infrastructure that is responsible to process inbound and outbound messages from the BizTalk message box. A pipeline is commonly used to parse, decode and disassemble message. Pipelines divide processing into stages. Abstractions that describe a task. Pipelines also determine the task sequence. Pipeline could be applied to receive message or send messages, where the corresponding pipeline are called receive pipeline and send pipeline. There are up to four stages for a receive pipeline, Decode, Dissemble, Validate and Resolve Party.
     

    A pipeline component is a piece of software developed using .Net or COM technology to process message inside a pipeline. You usually use Pipeline Editor utility to create pipeline.
     
     

15. Add a new empty project, then add receive pipeline using Receive Pipeline template.
     

    
     

16. Drag and drop the Flat File Disassembler component from the toolbox to the pipeline and drop it into the disassemble stage. This component will convert the flat message to XML message.
     

    

17. Add a reference to the schema project, then choose ImportProduct.FlatFileProduct in the Document schema dropdown list of the property window of the flat file disassembler
     

    
     

18. Build and deploy the pipeline project by following the item 13 and 14. Now you can test your pipeline by creating receive port and send port.
19. Create receive port using File transport type and specify the receive pipeline as FlatFileReceivePipeline. If you’re not sure what is receive port, please check my previous blog.
     

    
     

20. Create send port and specify the send file location as c:\BizTalkApp\Send. You also need to specify the filter to connect the receive port and send port.
     
21. Now start the receive and send port, and drop the product.txt file in the receive location, you will notice the file is removed after a while and new file is created in the send port. Open the file, the file content is.
     

    <Products xmlns=”http://ImportProduct.FlatFileProduct“>

    <ProductItem xmlns=”">

    <ProductId>1</ProductId>

    <Name> Adjustable Race</Name>

    <ProductNumber>AR-5381</ProductNumber>

    </ProductItem>

    <ProductItem xmlns=”">

    <ProductId>2</ProductId>

    <Name> Bearing Ball</Name>

    <ProductNumber> BA-8327</ProductNumber>

    </ProductItem>

    <ProductItem xmlns=”">

    <ProductId>3</ProductId>

    <Name> BB Ball Bearing</Name>

    <ProductNumber> BE-2349</ProductNumber>

    </ProductItem>

    <ProductItem xmlns=”">

    <ProductId>4</ProductId>

    <Name>Headset Ball Bearings</Name>

    <ProductNumber> BE-2908</ProductNumber>

    </ProductItem>

    </Products>
     

    So far so good, the flat file is converted to XML file. Next, you need to create a web service which will be caused inside a BizTalk orchestration.

    Step Three Create a simple Web Service
    
     

    Launch Visual Studio and create a web service application. Name the web application as ImportProductWebService.
     

    

    Replace the service code with the following code, don’t forget to change the value of inherit attribute to ImportProductWebServie.ImportProductData in the web service asmx file.
     
     

    namespace ImportProductWebService
    

    {
    

    ///
    <summary>
    

    /// Summary description for Service1
    

    ///
    </summary>
    

    [WebService(Namespace = "http://tempuri.org/")]
    

    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    

    [ToolboxItem(false)]
    

    public
    class
    ImportProductData : System.Web.Services.WebService
    

    {
    
     

    [WebMethod]
    

    public
    void UploadData(List<Product> products)
    

    {
    

    StringBuilder sb = new
    StringBuilder();
    

    if ( products != null )
    

    {
    

    foreach(Product product in products)
    

    {
    

    sb.AppendLine(string.Format(“{0},{1},{2}”, product.ID, product.Name,product.Number));
    

    }
    

    }
    

    File.WriteAllText(@”c:\BizTalkApp\uploadFile.txt”, sb.ToString());
    

    }
    
     

    public
    class
    Product
    

    {
    

    public
    int ID;
    

    public
    string Name;
    

    public
    string Number;
    

    }
    

    }
    

    }
    
     

    After compiling the web service, you need to add a we reference in the importProduct schema project.
     

22. Right-click ImportProduct schema project, then click Add web reference.

    

23. Click Add Reference button, then you should see some files are created in the project.

    

24.  

    To simply the process, the data is not actually stored into the database, instead, it will be written into uploadFile.txt file. The end result is similar to the file copy. Please note the parameter passed to the UploadData method is a List of Product type. In order to call this web service, we need to pass a message from the BizTalk to web method, therefore we need to convert the original XML message to the message which could be used to construct the a List instance during object deserialization. To convert one format XML to another format XML message, BizTalk uses Schema Map or Map.
     

    Step Four Build Map
    
     

25. Right click the ImportProduct schema project , click add new item, then choose map template and name the map file as Products_FF_To_Reference_WSRequest.btm
     

    
     
     

26. Click Open Source Schema link, then choose Products_FF.xsd, then click Open Destination Schema and choose ImportProduct.localhost.Reference and click OK.
     

    
     

27. Drag ProductId in the left pane to the ID in the right pane, then follow this screen to finish the mapping.
     

    
     
     

    Step Five Create Orchestration
    
     

    After creating map, now you need to build Orchestration to transform the input message to the web service request message and call web service. Although it’s possible to call web service without using Orchestration, it would be useful when the business rules are introduced down the road.
     

    Understanding Orchestration
    
     

    Orchestration is a software application hosted by the BizTalk server. Orchestration consists of shapes. An orchestration shape is similar to a task in the Nant or Msbuild. You can create a sequence and/or parallel shapes. The commonly used shapes are Receive, Send, Transform, Construct Message, Decide, Parallel Actions and Loop. Some shapes are container shape such as Decide, Construct Message and Parallel Actions. I have borrowed all shaped description from MSDN BizTalk document.
     

    
     

    You can create an orchestration by using Orchestration Designer, a graphical user interface tool which allows you build orchestration easier. Whenever you create a new orchestration using Visual Studio, an odx file ( XML file ) is created which holds all configuration settings and some logics to drive the BizTalk engine. In the runtime, BizTalk engine will retrieve the variables, tasks defined in the XML file to run the orchestration application.
     

28. Right-click the solution and add new empty BizTalk project, then add new item by choosing BizTalk orchestration template. Now you should see the Orchestration Designer is opened.

    
     

29. Before dragging and dropping the shapes from the left side pane to the Orchestration, you need to define the message parameters used in the orchestration. Click View | Other Windows | Orchestration View. In the Orchestration View, right-click Messages, then create 3 messages, product, uploadDataParamWSRequest, uploadDataparamWSResponse. Please note ussually you should name the messages, variables, orchestration parameters etc. using camel case.
     

    
     

    Modify the property attributes Identifier and Message Type using the data value in this table.
     

Message name	Identifier	Message Type
product	product	ImportProduct. FlatFileProduct
uploadDataParamWSRequest	uploadDataParamWSRequest	ImportProduct. localhost. ImportProductData_. UploadData_request
uploadDataParamWSResponse	uploadDataParamWSResponse	ImportProduct. localhost. ImportProductData_. UploadData_response

 

1. Now you’re ready to design your orchestration. Right-click the Port Surface in the left side and choose the New Configured Port…, which will launch a wizard to help you configure the port easily. Once the wizard appears, click Next button, then specify the port name as ReceiveProductPort, then click Next button. In the Port Type screen, specify each item like the following screenshot.
    

   
    

   Clicking the next button will show the Port Binding window. Ensure you select I’ll always be receiving messages on this port and choose specify later in the port binding, then click Next and Finish button to complete the receive port configuration.
    

2. Drag and drop a Receive shape under the start node in the Orchestration Designer, then specify product as message. Ensure the Activate attribute is true.
3. Drag and drop a Transform shape under the Receive shape, then a Construct Message container shape is automatically created. Right-click the Transform shape, then click Configure Transform shape, select ImportProduct.Product_FF_To_Rference_WSRequest as the Map, then specify the source as product, the destination as uploadDataParamWSRequest.products. The purpose of this shape to transform the input XML message to the web service request XML message. Click Ok to complete the configuration.
    

   
    

4. Drag and drop a Send shape under the Construct Message shape, then specify unploadDataParamWSRequest in the Message attribute. Drag and drop a Receive shape under the Send shape, then specify unploadDataParamWSResponse in the Message attribute. Ignore operations at this point.
5. Right-click the Port Surface in the right pane, then click New Configured Port…, then specify the name as SendUploadDataWsPort in the port window, click next button, then choose Request-Response in the communication pattern in the port type window, then click next.
    
6. In the Port Binding window, select I’ll be receiving a request and sending a response in the port direction of communcation , then select port binding as Specify now. Ensure select Transport as SOAP, then specify the URI as http://localhost/ImportProductWebService/ImportProductData.asmx. Then click Next, Finish button to complete the Send port configuration.
    

   
    

7. Now drag the arrow of the request in the receive port to the Receive shape, then drag the arrow of the Send shape to the request of UploadData method in the Send port, then drag the arrow of the Response of the UploadData method in the Send port to the last Receive shape. The finished orchestration looks like
    

   
    

   Step Six Build, Deploy and Test
   
    

   Like any web application needed to deploy to the web server, the BizTalk application must be deployed to BizTalk server, in other word, you need to give a name for your BizTalk application. In addition to that, the BizTalk dlls are deployed to GAC, so you need to sign it using strong name.

8. Follow the step 13 and 14 to configure other two projects in this solution.
9. Build solution, then right-click each project to deploy them to the BizTalk server.
10. Open BizTalk Server Administration Console, then right-click ImportProduct application, then click start to launch your application.
     

    
     

    If you get the orchestration binding error, you need to specify the Bindings in the Orchestration Properties windows. Ensure you select the BizTalkServerApplication as Host.
     

    
     

11. Copy the product.txt file into the C:\BizTalkApp\Receive folder. If you see the uploadfile.txt is created in the C:\BizTalkApp folder and content is exactly the same as that of the product.txt, great!, the application works.
     

    Conclusion
    
     

    From this simple application, you learn how to create schema, map, pipeline and orchestration in BizTalk. In addition to that, you also learn how to pass a list parameter to the web service which is very useful feature to import file. Hopefully it will also convince you that BizTalk is a powerful tool to easily build high available and scalable application.

BizTalk Naming and Versioning

Maintaining BizTalk application could be challenging for the developer and administrator since the application usually consists of many parts. Like any .Net application, BizTalk application should follow some naming and veining convention to facilitate the application maintenance.  I suggest the following rules summarized based upon George Dunphy and Ahmed Metwally’s excellent book Pro BizTalk 2006.
 

1. Name solution using MyCompany.MyProject.BizTalk.
2. Name shared artifact assemblies using MyCompany.MyProject.Core.Orchestrations.dll, MyCompany.MyProject.Core.Schemas.dll, MyCompany.MyProject.Core.Pipelines.dll
3. Name feature or subsystem artifact assemblies using MyCompany.MyProject.Core.Orchestrations.dll, MyCompany.MyProject.Core.Schemas.dll, MyCompany.MyProject.Core.Pipelines.dll
4. Stamp all assemblies with same version in the build process.
5. Version send and receive ports by suffixing the port name with the assembly version. Please note, if third parties are sending or receiving messages these ports, consider keeping the port names but using versioned schema namespace. http://Microsoft.BizTalk/service/v1.0.0.0
6. Update each binding file associated with the BizTalk modules in the build process.
7. Consider versioned deployment by filtering when orchestrations are not required to initialize a correlation set.
8. Schema File: Name schema file <RootNode>_<Standard>.xsd. <Standard> includes XML or flat file ( FF ) or other custom formats. ( e.g., PurchaseOrder_FF.xsd).
9. Schema Target Namespaces: Match schema target namespaces to assembly name. ( e.g. http://Microsoft.E-Commerce.PurchaseOrder).
10. Property Schema Files:Name Property Schema file <PropSchema>_PropSchema.xsd.
11. Maps: Name Maps <SourceSchema>_To_<DestinationSchema>.btm(e.g., PurchaseOrder_FF_To_PurchaseOrderAcknowledge_XML.btm).
12. Orchestrations: Use <Verb><Noun> pattern to name orchestrations. ( e.g. EvaluateCredit.odx).
13. Receive Pipelines: Use rcv<SchemaName>.btp or rcv<ProjectName>.btp or rcv<Function>.btpto name receive pipelines(e.g., rcvPOAckPipelineFF.btp).
14. Send Pipelines: Use snd<SchemaName>.btp or snd<ProjectName>.btp or snd<Function>.btpto name send pipelines(e.g., sndPaymentPipeline.btp).
15. Receive Ports: Use rcv<InputSchema>To<OutputSchema>Port or rcv<Functional Description>Portto name receive port ( e.g., rcvPurchaseOrderToPOAckPort, rcvERPStatusPort).
16. Receive locations: Use <ReceivePortName>_<Transport>to name Receive location ( e.g., rcvERPStatusPort_File ).
17. Send Port Groups: Use <BizApp>_<FunctionalDescript> to name send port groups.
18. Send Ports: similar to receive port. Replace prefix rcv with snd.
19. Use <ShapeName>_<Description> pattern to name Orchestration Functional Shapes ( similar to function call or language logical control in the program ): for most of shapes, Scope, Recive, Send, Decide, If/Else, Call, Throw, Parallel, Delay, Listen, Loop, Suspend, Terminate, CallRule, and Compensate shapes ( e.g. Parallel_CreditVendorCalls, Receive_CrditReport, Send_poAck, If_ApprovalRequired).
20. Use camel case to name Orchestration Variable Shapes( similar to define variables in the program ). Message, Variable, correlation set, orchestration parameter ( e.g. puchaseOrderAck).
21. Use meaningful upper case name for Construct Message, Expression, Multi-Part Message Type, Port and Correlation Type.
     For detail rational behind these rules, please check Pro BizTalk 2006
     

Entity Framework Sample Query Explorer

 

The Sample Query Explorer, an open source project in the CodePlex, provides us a variety of Entity SQL and LINQ to Entities Sample where we can learn how to build simple and effective queries. Below is the screenshot of this nice little tool. Of course, you can extend it by adding your more advanced queries.
 

 

You can download Query Explorer here. Before running it, you need to install VS.Net 2008 beta2, Entity Framework beta2, and Entity Framework tools Aug 2007 CTP. The Sample Query Explorer uses Northwind sample database but you don’t have to download or install it since the Northwind database is included in the Query Explorer. Once unzip the download file, you can follow the readme file to set it up in your computer. First open the solution file using VS.net 2008, then attach database to your instance. You might need to change the connection string in the app.config file to match your environment.