SQL Server Compact - Compact & Capable : ADO.NET

After moving the database from one platform to other, the first SqlCeConnection.Open() takes more time

SQLCEBLOG — Wed, 01 Apr 2009 15:16:00 GMT

If you move a SQLCE database from one platform to other, it's first SqlCeConnection.Open() takes more time and also increases the database file size.

The Reason: For an index on string type columns, SQLCE uses LCMapString API to get the normalized sort key. LCMapString API behavior will be different for different NLS sort versions. NLS sort version is different for Desktop Windows OS and WM/WCE. During the first database connection open, SQLCE rebuilds all indexes if there is a NLS sort version mismatch with the last accessed OS platform. Index recreation requires space on database file and hence the database file size will be increased. You can use Compact()/Shrink() API to get the database file with approximately old file size. Because of this index recreation, first database connection open takes more time as it has to rebuild all indexes.

Note: If your database doesn’t have any indexes you will not see above mentioned symptoms on first connection open.

Don’t inter-op SQLCE 3.0 databases between devices and desktop:

SQLCE started supporting desktops only from SQLCE 3.1 (3.0.5300.0) release. SQLCE 3.0 doesn’t have index rebuilding logic and the index re-creation was added during SQLCE 3.1 (3.0.5300.0) release as it is required to support platform inter-op for SQLCE databases. On desktop you can open SQLCE 3.0 databases, which were created on devices. Again If you open these databases on SQLCE 3.0 devices, your device app might receive an error/exception.

For example: Opening a SQLCE 3.0 database with SSMS will use SQLCE 3.1 bits on desktop and hence it would drop and recreate index data. When this file is copied back to device, index data may not be valid and receive an error/exception.

Namaskaram!

Manikyam Bavandla

Sync Services optimizations

SQLCEBLOG — Mon, 06 Oct 2008 15:40:00 GMT

There are some optimizations that can be done for an "Sync Services" sync scenario. These are, (might not be an exhaustive list)

Small sync chunks (using smaller SyncGroups which are only absolutely necessary)
Index creation on tracking and filtering columns
Transfer encryption of data payload on web
Batching the changes
Filtering the data at various stages to reduce network load

    Sync (synonym for "Sync Services sync", in this post) interfaces with the providers using DataSet objects. That is, sync uses DataSet to store and retrieve changes happening at client and server. DataSets are known to be not very memory efficient, and the amount of memory consumed by these, is a bit of a concern when one is using these in device clients in Sync Services.

    Sync happens in chunks, using the SyncGroups that one supplies. That is, all data in a SyncGroup is logically one sync, and corresponds to one DataSet. Since sync DataSets are one per SyncGroup, and these are needed only till the corresponding SyncGroup commits, we can optimize the memory taken by DataSets, using smaller SyncGroups. Divide sync tables into various SyncGroups, so that, each group has it’s own (smaller) DataSet, and it is disposed (by garbage collector) once the SyncGroup changes are committed. However, to ensure logical consistency, you should always keep the tables which are related (by a foreign key constraint, for example), in the same SyncGroup.

Example:
Tables Order and OrderDetails are related.
Tables Customers and ShippingDetails are related. But, these are unrelated to the first set.

SyncGroup customerSyncGroup = new SyncGroup("Customers");

SyncTable customerSyncTable = new SyncTable("Customer");
customerSyncTable.CreationOption = TableCreationOption.DropExistingOrCreateNewTable;
customerSyncTable.SyncDirection = SyncDirection.DownloadOnly;
customerSyncTable.SyncGroup = customerSyncGroup;

SyncTable orderShipSyncTable = new SyncTable("ShippingDetails");
orderShipSyncTable.CreationOption = TableCreationOption.DropExistingOrCreateNewTable;
orderShipSyncTable.SyncDirection = SyncDirection.DownloadOnly;
orderShipSyncTable.SyncGroup = customerSyncGroup;

SyncGroup orderSyncGroup = new SyncGroup("Orders");

SyncTable orderSyncTable = new SyncTable("Order");
orderSyncTable.CreationOption = TableCreationOption.DropExistingOrCreateNewTable;
orderSyncTable.SyncDirection = SyncDirection.DownloadOnly;
orderSyncTable.SyncGroup = orderSyncGroup;

SyncTable orderDetailSyncTable = new SyncTable("OrderDetails");
orderDetailSyncTable.CreationOption = TableCreationOption.DropExistingOrCreateNewTable;
orderDetailSyncTable.SyncDirection = SyncDirection.DownloadOnly;
orderDetailSyncTable.SyncGroup = orderSyncGroup;

    Rather than having a single SyncGroup with all 4 tables, one can create two sync groups. One for the first set, and the second for the other set.

    Also, to increase the performance of enumerating process at server, one can create indexes on the tracking and filtering columns. As an example, let us say one has two tracking timestamp columns __CreateTime and __UpdateTime. Since, our server side changes enumerating queries always have filtering based on these columns, one should create indexes on these, so that, enumerating server changes becomes faster, and, sync performance increases.

    In case of device syncs, transferring the data on the network/internet is also going to cost more time/resources. Since, transfer of data from a web service/server machine to a device is time/bandwidth consuming, one should look at compressing data sent/received. This is mostly the case, when data being synched is large (Something like, initial synching SQL Compact with SQL Server). One can use System.IO.Compression or your own implementation of compression/decompression algorithm. (More details at http://msdn.microsoft.com/en-us/library/system.io.compression.aspx). Another blog post that refers to this issue and proposes solutions is at, (http://blogs.msdn.com/mahjayar/archive/2008/10/01/dbsyncprovider-improving-memory-performance-in-wcf-based-synchronization.aspx)

    Sync Services Server side supports batching. Please refer to http://msdn.microsoft.com/en-us/library/bb902828.aspx for more details.

    Sometimes, we may have server tables holding and synching data, that is alien to clients. For example, server table has a large GPS map of some place (in custom format) per row, that is associated with the data in other columns in the row. The map is stored as an image at client side. But, since, the data is of proprietary format, client can’t interpret the data, and it is not used anyway at client side. And also, since, it is large data, lot of network bandwidth is consumed and response time is compromised for transferring this across. It is better, if one can filter these columns out at server side, rather than sending to client.

    Another scenario is as follows: The client devices of a Sync application are used by Salesmen of a company, and the server side is the company office, where data pertaining to each salesman is stored in a SQL Server database. When the client devices sync, they are mostly concerned about the data relevant to them alone, and not to other sales persons. Here also, one needs to filter rows from the table.

    To facilitate filtering of rows/columns at client/server sides, one can use a number of strategies. For filtering data sent from client (or at the client side), one can use the callback architecture of "Sync Services". For server side, since you have more control there, one can choose to strip down the DataSet, when one is sending it over the wire/use callbacks to strip off DataSet data/client can supply queries to server side adapters, which filter data.

Explaining each of these options:

Callback architecture of sync: Sync provides various callbacks during the process of Synching. One can hook in the callbacks for accessing/modifying the dataset generated at every stage of sync. For example, one can add/drop some columns to the dataset, after changee enumeration is done at client side. After changing the dataset, effectively, the changes being applied to client database are changed. The same provision is present at server side also.

This callback architecture can be used to modify the DataSet applied/sent to server, on the fly. This is one type of filtering, possible at both client and server.

Server side gives more options when sending data over the wire. First of all, server chnages are enumerated within the "Sync Services" application itself. That is because, server change enumeration is done by queries supplied by the Sync Services client. So, which columns to select from server, can be controlled from the client side, when specifying queries like, SelectIncrementalInserts etc... This is another way of programmatically filtering server data.

One more option to filter data in a N-tier architecture is that, filtering the wire transferred content. In an N-tier architecture, client and server are in two different, but connected machines. Typically, client machine has a proxy server provider, which delegates calls to enumeraion/application of changes etc... to a web service. Web service talks to a backend data store, and services the data and operation requests. In this setting, interesting possibilities like, use of compression over the wire, and filtering over the wire etc... come up. When server side data store gives data, it can do some filtering. Also, the client side proxy can be used to filter irrelevant data. This is another type of filtering.

Example for callback architecture:
For client side DataSet filtering (client side), use SelectingChanges before the enumeration and ChangesSelected after the enumeration
For server’s data set filtering (client side), ApplyingChanges before the application of changes and ChangesApplied after the application
For filtering server side changes (at server side):SelectingChanges before the enumeration and ChangesSelected after the enumeration
For client’s data filtering (at server side):ApplyingChanges before the application of changes and ChangesApplied after the application

In every one of these methods, eventArgs.GroupMetadata and eventArgs.Context.DataSet are the ones need to be changed.

Thanks

Udaya Bhanu,

SDE II, SQL Compact

My First Entity Application Against SQLCE

SQLCEBLOG — Fri, 07 Mar 2008 19:36:00 GMT

Now that SQL Server Compact 3.5 SP1 Beta is released it's time to take the first step, making your first entity application using SQLCE as a backend.

In his previous post, Ambrish gave steps on how to install SQL Server Compact SP1 Beta, along with Ado.Net Entity Framework Beta 3 and writing a small program to query the Northwind Database via LINQ.

In this post, I will briefly walk you through what Entity Framework Beta 3 has offer to, and how can we leverage it to write different types of entity queries against SQL Server Compact.

Going by EF Definition at: http://msdn2.microsoft.com/en-us/library/bb399572.aspx

The most unique selling point in my opinion becomes the part where you can run the same program/application against any backend (assuming the database schema is same), you have to just modify connection strings. Let's say even if the schema is little different, you can get that easily fixed in your metadata files, and boom, your app works.

I am including few screenshots which will guide you on how to go by making your own application and the complete program.

Please do read the previous post (by Ambrish) carefully as I will assume that you are done with the setup and we are ready to go. For those who could get things set up I am posting some screen shots to help you with that.

First step is to include an Ado.Net Entity Data Model into your project, give it a name that makes sense, I gave it SSCNorthwind.

The screenshot below, shows the database file that we selected, its connection string that will go into your App.config file and also the name you want to give it. For simplicity I chose NorthwindEntities.

The screenshot below shows you how to include the database file that you placed in your project root for generating data model.

The wizard below allows you to choose the tables that you want to be part of entity set, as SQL CE does not support stored procedures and views as of now, we will ignore those two options.

The red box in below shows the change that we have to make in App.Config to make this working J i.e. renaming the provider:

provider=Microsoft.SqlServerCe.Client.3.5 to provider=System.Data.SqlServerCe.3.5

This is being fixed, so in RTM version you won't have to do this manual step.

You can see that the name of Entity set is NortwindEntities, so whenever we make connection to this set, the connection string provided in App.Config file will be used.

Before:

After:

This is how the solution explorer should look now:

If you face any error while adding Northwind.sdf file into your project, just ignore it for now.

I have tried to include some comments in my program below to help you understand what's going on.

Points to notice:

To connect to a Database using an Entity Connection, you can do it in two ways.

First way is to specify your own connection string, like I have done at the start of program. Using that you can directly create an Entity Connection and work in the same way you used to work with SqlCeConnection and SqlCeCommand. That way can be seen in ESQL Query region.
The second approach is using Contexts or what we call here NorthwindEntities, (remember at top we renamed Entities to this for better understanding). For using context, you can do that in multiple ways

First, you can give a connection string and it will create the set.
Second, you can also first create an Entity Connection like above and then pass it on the NorthwindEntities, which is what I have done in Object Query section.
And the last approach for which we created App.Config in first place. You don't specify anything at all, the entity set (NorthwindEntities) picks up your connection string from App.Config and creates a connection. LINQ to Entites Query section is done using this approach.

Program (Contents of Program.cs):

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Data.EntityClient;

using NorthwindModel;

using System.Data;

namespace MyFirstEntityApplicationForSSC

{

class Program

{

#region Static Declarations

//SQLCE Connection string for the sample database Northwind.sdf

static string _sqlCeConnnectionString = @"Data Source = Northwind.sdf";

//entityConnectionString: If your metadata(CSDL, SSDL and MSL, or in this case EDMX) files lie in the same place as application, you can use "."

static string _entityConnectionString =

String.Format(@"metadata=.;Provider=System.Data.SqlServerCe.3.5;provider connection string=""{0}""", _sqlCeConnnectionString);

//New Values that you might want to use for changing the data

static string _newFirstName = "AGENT";

static string _newLastName = "SMITH";

static string _newCountry = "MATRIX";

#endregion Static Declarations

#region Main

/// <summary>

/// MAIN: It calls the three different functions for following type of queries

/// Description in layman language

///

/// ESQL - This takes you back to old .Net 2.0 days where you used to set T-SQL statements and execute them, just that it here works on entities now instead of tables

/// Example Demonstrates: Simple Select Query using Entity SQL.

///

/// Object Query - Working on Data Objects was never so easy. This type of queries give you the power to work on data objects and most of all intellisense helps with things you can do

/// Example Demonstrates: Query and Updation of data and then Re-Querying

///

/// LINQ to Enity - LINQ means Language Integrated Query. This is a new and powerful way of writing queries that are checked for syntax at compile time itself. So, chances of failing in query logic at runtime become minimal

/// Example Demostrates: Query the data using default settings for connection in App.Config that was configured via EF Designer.

/// </summary>

/// <param name="args"></param>

static void Main(string[] args)

{

Console.WriteLine("SQL CE Northwind Entity App:");

try

{

EntityConnection entityConnection = new EntityConnection(_entityConnectionString); //Creating a new entity connection using the entity connection string

entityConnection.Open();

Console.WriteLine("\nESQL Query:");

ESQL_Query(entityConnection); //This does not use context, it's a simple esql command execution

Console.WriteLine("\nLINQ To Entity Query:");

LINQ_To_Entity_Query(); //This will make a new connection using the connection string in the App.Config file

Console.WriteLine("\nObject Query:");

ObjectQuery(entityConnection); //This will create the context with existing connection

entityConnection.Close();

}

catch (Exception ex)

{

Console.WriteLine("\nFAIL! Oops, it was not expected, an exception has been thrown, details below:\n");

Console.WriteLine(ex.Message);

}

Console.WriteLine("\nPress a Key to exit...");

Console.ReadKey();

}

#endregion Main

#region ESQL_Query

/// <summary>

/// ESQL_Query

/// (Executing a simple ESQL query against Northwind Entity Set)

/// Using the entity connection which is passed on as parameter

/// it executes a simple entity command on the Employees entity set in the Northwind Context.

/// The result of that query is later on printed on the screen using a data reader.

/// </summary>

/// <param name="entityConnection"></param>

private static void ESQL_Query(EntityConnection entityConnection)

{

EntityCommand entityCommand = entityConnection.CreateCommand();

entityCommand.CommandText = @"Select Emp.Employee_Id as Id, Emp.First_Name as Name from NorthwindEntities.Employees as Emp order by Emp.Employee_Id";

EntityDataReader entityDataReader = entityCommand.ExecuteReader(CommandBehavior.SequentialAccess);

//Note: You have to use CommandBehavior as SequentialAccess, otherwise an exception will be thrown

while (entityDataReader.Read())

{

for (int i = 0; i < entityDataReader.FieldCount; i++)

Console.Write(entityDataReader[i].ToString() + "\t");

Console.WriteLine();

}

#endregion ESQL_Query

#region LINQ_To_Entity_Query

/// <summary>

/// LINQ_To_Entity_Query

/// (Executing a simple LINQ query against Northwind Entity Set)

/// This function creates a new Northwind Context based on the setting provided for it in the App.Config File

/// It executes a simple LINQ query on the Employees entity set in the Northwind Context.

/// The result of that query is later on printed on the screen using the IQueryable structure.

/// </summary>

private static void LINQ_To_Entity_Query()

{

NorthwindEntities nwind = new NorthwindEntities(); //Uses the settings for connection string in App.Config File

IQueryable<string> emps = from e in nwind.Employees where (e.Employee_ID%2)==0 select e.First_Name; //Even Number Employee Ids

foreach (string e in emps)

{

Console.WriteLine(e);

}

#endregion LINQ_To_Entity_Query

#region ObjectQuery

/// <summary>

/// ObjectQuery

/// (Executing a simple Object query against Northwind Entity Set and Updating the data)

/// This function creates a new Northwind Context based on the entity connection thas has been passed to it as parameter

/// It executes a simple Object query on the Employees entity set in the Northwind Context.

/// The result of that query is later on printed on the screen and some changes are made to it.

/// The changes are then saved using SaveChanges on Context and then re-querying them to see if things went fine.

/// </summary>

/// <param name="entityConnection"></param>

private static void ObjectQuery(EntityConnection entityConnection)

{

NorthwindEntities nwind = new NorthwindEntities(entityConnection);

var emps = nwind.Employees.Where((delegate(Employees e)

{

return e.Employee_ID > 5;

}

));

//var emps = nwind.Employees.Where("it.Employee_ID > 5"); //This query is also equivalent to above one and will give same results

//var emps = nwind.Employees.Where("it.Employee_ID > @empid",new ObjectParameter("@empid",5)); //This query is also equivalent to above one, but it uses parameters for the values

foreach(Employees e in emps)

{

Console.WriteLine(e.Employee_ID + "\t" + e.First_Name + "\t" + e.Last_Name + "\t" + e.Country);

if (e.Employee_ID == 10) //As soon as we encounter employee id as 10, we want to change some data

{

Console.WriteLine("Changing Data");

e.First_Name = _newFirstName;

e.Last_Name = _newLastName;

e.Country = _newCountry;

}

Console.WriteLine("Saving Data Changes");

nwind.SaveChanges(); //Any changes made to the context are saved using this command

emps = nwind.Employees; //This is simplest way to select all employees. If you happen to choose particular data you may modify the query accordingly, like nwind.Employees.Where("it.Employee_ID = 10")

Console.WriteLine("Display Data Again:");

foreach (Employees e in emps)

{

Console.WriteLine(e.Employee_ID + "\t" + e.First_Name + "\t" + e.Last_Name + "\t" + e.Country);

}

#endregion ObjectQuery

}

The output of the program would look like this:

SQL CE Northwind Entity App:

ESQL Query:

1 Nancy

2 Andrew

3 Janet

4 Margaret

5 Steven

6 Michael

7 Robert

8 Laura

9 Anne

10 Albert

11 Tim

12 Caroline

13 Justin

14 Xavier

15 Laurent

LINQ To Entity Query:

Andrew

Margaret

Michael

Laura

Albert

Caroline

Xavier

Object Query:

6 Michael Suyama UK

7 Robert King UK

8 Laura Callahan USA

9 Anne Dodsworth UK

10 Albert Hellstern USA

Changing Data

11 Tim Smith USA

12 Caroline Patterson USA

13 Justin Brid France

14 Xavier Martin France

15 Laurent Pereira France

Saving Data Changes

Display Data Again:

1 Nancy Davolio USA

2 Andrew Fuller USA

3 Janet Leverling USA

4 Margaret Peacock USA

5 Steven Buchanan UK

6 Michael Suyama UK

7 Robert King UK

8 Laura Callahan USA

9 Anne Dodsworth UK

10 AGENT SMITH MATRIX

11 Tim Smith USA

12 Caroline Patterson USA

13 Justin Brid France

14 Xavier Martin France

15 Laurent Pereira France

Press a Key to exit...

If you want your changes to persist or not to persist, modify the properties for the Northwind.sdf file in your solution properties as per your desire. By default it is "copy if newer" which means the database file in your execution folder will retain the changes. By changing it to "copy always" you can refresh your database each time.

I hope now you can now go back and start writing advanced programs using various techniques available.

Ado.Net Entity Framework is a new weapon to the list of a current developer's arsenal, opening multiple ways in which he can write his programs without worrying about the under lying intricacies.

The shift to entity plane seems very lucrative, easy and promising. And what more, all of this comes with handy tools which make life easy. Writing your code from the word Go!

The above topic was in relation to LINQ to Entities, if you are looking for LINQ to SQL refer to this blog post: http://blogs.msdn.com/sqlservercompact/archive/2007/08/21/linq-with-sql-server-compact-a-ka-dlinq-over-sql-ce.aspx

Happy Programming!

Ravi Tandon

SDET, SQL Server Compact

Download available for SQL Server Compact 3.5 SP1 Beta for ADO.Net Entity Framework Beta 3

SQLCEBLOG — Thu, 21 Feb 2008 09:30:00 GMT

The SQL Server Compact 3.5 SP1 Beta for ADO.Net Entity Framework Beta 3 is available for download at Microsoft Download Center.

To install SQL Server Compact 3.5 SP1 Beta Release for ADO.NET Entity Framework Beta 3

Install ADO.NET Entity Framework Beta 3 from Microsoft Download Center. You must ensure that the pre-requisites specified on the download page are installed before installing ADO.NET Entity Framework Beta 3.
In Control Panel, double-click Add or Remove Programs. Uninstall SQL Server Compact 3.5 or SQL Server Compact 3.5 SP1 Beta.
Install SQL Server Compact 3.5 SP1 Beta Release for the ADO.NET Entity Framework Beta 3 (SSCERuntime-ENU.msi) from the Microsoft Download Center. Note that administrator rights are required on a computer to install SQL Server Compact 3.5 SP1 Beta Release for ADO.NET Entity Framework Beta 3.

To install ADO.NET Entity Framework Tools December 07 Community Technology Preview (CTP)

Install the ADO.NET Entity Framework Beta 3 and SQL Server Compact 3.5 SP1 Beta Release for the ADO.Net Entity Framework Beta 3 as specified above. Install ADO.NET Entity Framework Tools December 2007 CTP from the Microsoft Download Center. You must ensure that the pre-requisites specified on the download page are installed before installing ADO.NET Entity Framework Tools December 2007 CTP. The CTP installs on a Visual Studio 2008 installation.
Copy the SQL Server Compact 3.5 SP1 Design Tools Beta (SSCEVSTools-ENU.exe) to your computer by clicking on Save or Save this program to disk and after the download is complete install SSCEVSTools-ENU.exe by double-clicking it. Do not install the SSCEVSTools-ENU.exe by clicking on the Run. While running the SSCEVSTools-ENU.exe file, Microsoft.SqlServerCe.Client.dll is extracted to %ProgramFiles%\Microsoft Visual Studio 9.0\Common7\IDE folder. The SSCEVSTools-ENU.exe will create a backup of the existing DLL at the location %ProgramFiles%\Microsoft Visual Studio 9.0\Common7\IDE.

For uninstalling SQL Server Compact 3.5 SP1 Beta refer to the read me.

The steps to create a sample application are as given below:

1. Start Visual Studio 2008 and create a console project by clicking on the menu item File à New à Project. In the New Project window expand Visual Basic or Visual C#, select Windows and then select Console Application. For the project the .Net Framework version should be .Net Framework 3.5. Name the project as SQLCompactEDMProject. On clicking OK the project is created

2. To generate the Entity Data Model for the Northwind.sdf, copy the Northwind.sdf from the folder %Program Files%\Microsoft SQL Server Compact Edition\v3.5\Samples to the users folder like C:\Users\<login name>\Documents\Visual Studio 2008\Projects\SQLCompactEDMProject\SQLCompactEDMProject. Select the SQLCompactEDMProject in the Solution Explorer and right-click, point to Add, and then click New Item. Select ADO.NET Entity Data Model in the Templates pane. Enter Northwind.edmx for the model name and click Add. The opening page of the Entity Data Model Wizard is displayed.

3. Select Generate from database in the Choose Model Contents dialog box and click Next. Click the New Connection button. The Connection Properties dialog box is displayed.

4. In the Connection Properties dialog click the button Change in the Data Source. In the Change Data Source dialog box select Microsoft SQL Server Compact 3.5 and click OK. Click the radio button My Computer in the Data Source. In the Connection Properties browse to the Northwind.sdf and click OK in the Connection Properties dialog. The Choose Your Data Connection screen in the Entity Data Model Wizard comes up.

5. The checkbox in front of Save entity connection settings in App.Config as: will be clicked by default. Change the name in the dialog from Entities to NorthwindEntities. Click Next to continue.

6. The Choose Your Database Objects dialog box is displayed. By default all the tables in the database are selected and will be included in the EDM. Uncheck the box next to Tables. This deselects all the tables in the database. Expand the Tables node and select the Customers, Orders, and Products tables. Change the Model Namespace: from Model to NorthwindModel

7. Click Finish to complete the wizard.

a. The wizard does the following:

b. Adds references to the System.Data, System.Data.Entity, System.Core, System.Security, and System.Runtime.Serialization assemblies.

c. Generates an .edmx file which encapsulates the information from the EDM mapping files.

d. Creates an App.Config file.

8. Double click the App.Config file in the Solution Explorer to open it. Change the provider entry from provider=Microsoft.SqlServerCe.Client.3.5 to provider=System.Data.SqlServerCe.3.5

9. Add an Imports (Visual Basic) or using (C#) statement at the beginning of the file to reference the EDM created from the Northwind database. (The name of the model corresponds to the value of the namespace attribute in your .edmx file).

Visual Basic

Imports SQLCompactEDMProject.NorthwindModel

using NorthwindModel;

10. Add the following code to the Main subroutine (Module1.vb or Program.cs)

Visual Basic

Using db As NorthwindEntities = New NorthwindEntities

Dim customers = From c In db.Customers _

Where c.City = "London" _

Order By c.Company_Name Select c

For Each c As Customers In customers

Console.WriteLine(c.Company_Name)

Console.ReadLine

End Using

using (NorthwindEntities db = new NorthwindEntities())

{

var customers = from c in db.Customers

where c.City == "London"

orderby c.Company_Name

select c;

foreach (Customers c in customers)

{

Console.WriteLine(c.Company_Name);

}

Console.ReadLine ();

}

11. Press CTRL+F5 to run the application. After the results display on the console screen press enter to exit the application

For more information and samples please see the ADO.NET Entity Framework Beta 3 Documentation and ADO.NET Entity Framework Samples

Regards,

Ambrish Mishra

Program Manager - SQL Server Compact

SqlCeDataReader.GetSchemaTable - Sample

SQLCEBLOG — Wed, 07 Feb 2007 07:58:00 GMT

I have written a cute sample to show how different fields change with different constraints and indexes on a table. If you are wondering how each of these flags IsUnique, IsKey, IsRowVersion change, have a quick look at sample application which is attached to this blog post.

Thanks,

Vamshi Krishna B

Provider Independent Programming

SQLCEBLOG — Tue, 23 Jan 2007 21:23:00 GMT

Have you heard of Provider Agnostic Programming aka Base Class Provider Model aka Provider Independent Programming?

If not, read it out here: http://msdn2.microsoft.com/en-us/library/t9f29wbk.aspx

Well why am I writing about that article on this blog?

SQL Server Compact Edition supports this (rather adheres to these guidelines). The invariant names for different releases/versions of SQL Server Compact Edition are:

Version	Invariant Name	Supported .NET Frameworks
3.1	System.Data.SqlServerCe	.NET FX 2.0
3.5	System.Data.SqlServerCe.3.5	.NET FX 2.0, .NET FX 3.5
4.0	System.Data.SqlServerCe.4.0	Not yet released and tentative

Thanks,

Laxmi Narsimha Rao ORUGANTI