Steve Lasker's Web Log - www.SteveLasker.com/Blog

New year, new gig, new blog. Moving to the cloud…

2009-02-27T07:55:00Z

I've moved... Here's the new blog with details on why and what...

Demos, Presentations, Links, Screencasts and Videos for SQL Server Compact

2008-11-26T00:57:00Z

I often find it hard to find my own demos scattered throughout my blog, so figured I'd just create a single posting that had all my current demos and powerpoints.

Recent Presentations at PDC and Tech Ed

SQL Server Compact Overview (lots of demos with supporting slides)
This was a very demo heavy deck with supporting slides. Covers many of our SQL Server Compact goals and non-goals, including the tooling scenarios, split between VS and Management Studio. Slides and demo on ASP.NET soft block, programming models with DataSet and SqlCeResultSet. (This deck was before we had LINQ to Entity support available). Covers a quick overview of optimized online, offline enabled architectures, with demos of Sync Services for ADO.NET, including 2 tier and N Tier. Then wraps up with Logical Queuing as the overall architecture for client based apps. I had a lot of fun with this presentation, but it was hard to fit in an hour.

Unlocking the Power of SQL Server Compact (Tech Ed EMEA 08)
Covered several topics, such as the questions on how fast can SQL Server Compact insert data. For Tech Ed EMEA, I added the section discussing stored procedures, and how a common DAL layer can actually provide more functionality than sprocs for both local data and server data. (yes, I'm sure there will be lots more to debate on this topic, but here's our thought process J)

With some coverage on private deployment, including 64bit, deep dive on perf and the managed sprocs demos, I bubbled back up to cover several interesting aspects for using SQL Server Compact, including a TraceListener to capture information from the field and sync it back with Sync Services for ADO.NET. Then covered read only databases on DVD's and using Compact as a custom Document format.

Associated Demos:

SQL Server Compact Bulk Insert Performance Test Harness (Compares Compact & Express)
Demonstrates the power of an embedded database and how much faster it can run than SQL Server for many operations. By implementing a few things, such as "connection pooling" and caching your SqlCeCommand objects, you can achieve similar functionality provided by SQL Server's connection pooling and Query Plan caching. However, because Compact is "in-proc" with your application, you can get the benefits of not having to work through additional networking, process and security layers required by SQL Server which is designed to work over the network.
Managed Stored Procedures (A Common DLL for data access to Compact and SQL Server)
SQL Server Compact Trace Listener
Demo for using Compact as a TraceListener to capture the output of System.Diagnostics.Trace.WriteLine and then synchronize that info back to the server providing visibility into what's happening out on the client. This deck includes animation, which looks a bit like Missile Command, demonstrating how this sample works.
Running Compact from Read Only Media (DVD, CD, Locked USB Key)
Using Compact as a Custom Doc Format (Recipe Manager)

Managing and Versioning Client Databases (Tech Ed EMEA 08)

Discusses the pros and cons of managing database deployment on the client. Why deploying databases as files, through MSI's, ClickOnce or other technologies can be easy for V1, but could lead to data loss in V2. Why a little investment up front can yield you productive results long term, and make for a better user experience.

Associated Demos:

Creating & Managing Local Database Versions through Scripts
When deploying applications with a local database, deploying the database with the app can seem easy at first, but once the user starts making changes to the local database, it gets messy quickly. If you're not careful, you can even lose the local data created/updated by the user. In this presentation, I created several animated slides that explain the complications and why script based deployment and versioning is the only practical way to manage local databases. This sample walks through the creation and versioning of local tables. To focus on the script based versioning aspects, I excluded any interaction with synchronized tables as that just gets even more complicated.
Versioning Local Databases with Scripts when using Sync Services for ADO.NET
In this demo we see how to version schemas when using Sync Services for ADO.NET. This includes two projects. One for the initial installation of V1, and another for the upgrade, or initial creation of V2. V1 includes creating a set of tables that aren't synchronized, such as state management for submitting orders to an existing service. Once sync completes, there are a set of additional scripts to create foreign keys between the synched tables, and between the synched tables and the local tables.
V2 enhances the synchronized tables with additional columns. The setup of this demo is a bit more complex as I've configured the server side sync components in a dll, then hosted the dll in a WCF Web Project. The WCF Web Project is published to an IIS instance, but uses different sub directories: for V1-http://localhost/VersionSchema/V1/LookupSyncService.svc, for V2-http://localhost/VersionSchema/V2/LookupSyncService.svc. Using this versioning scheme we can publish V2, allowing apps to slowly migrate over to V2, while the V1 apps continue to function and the business continues to function. The animation in this presentation helps explain this somewhat complex subject.

Just the demos, and nothing but the demos...

SQL Server Compact Trace Listener
Demo for using Compact as a TraceListener to capture the output of System.Diagnostics.Trace.WriteLine and then synchronize that info back to the server providing visibility into what's happening out on the client. This deck includes animation, which looks a bit like Missile Command, demonstrating how this sample works.
Using SQL Server Compact under ASP.NET
Demonstrates how to "unblock" SQL Server Compact for usage under ASP.NET. I discussed our reasoning in this post. A quick recap: The reason we blocked Compact for ASP.net scenarios was simply to not set expectations Compact is meant to be a replacement for SQL Server. It performs better than Jet. For the most part, we unblocked it for pre-building a SQL Server Compact database for sync scenarios where it's faster to download the database as a stream, then to sync the initial snapshot of data. It's also perfectly fine for small websites or other services. The main intention is strictly to make sure developers know, this is not meant to compete with SQL Server. There are coding differences between Compact and SQL Server, so we really didn't want developers to start with Compact, only to later find out it doesn't scale to thousands of concurrent website/service users for updating data. As long as developers understand the scope, it's perfectly fine to use for ASP.NET, WCF, or other service scenarios...
SqlCeResultSet Demos - Scrollable, Updateable, ISAM like cursors
Demonstrates how developers can take advantage of embedded a database directly into your app. The best thing about the SqlCeResultSet is it works directly over the data in your local database. No queries that bring the results into another copy in memory that you must mange potential conflicts with the local store, or potential conflicts between the local store and the remote server. With the SqlCeResultSet you can scroll directly over the local table, even setting the index to filter and order the rows you're viewing. The SqlCeResultSet is a scrollable, updateable cursor and can really improve the perf and overall working set of your application.

Direct Access (ISAM) with the SqlCeResultSet
Why do we need to make copies of the data, update it, then send it back? In a shared database environment, where you're likely connecting to the database across the network, and sharing with potentially thousands of others, because it's the only way we can scale. However, when the database is local, in-proc with the app, things can be much simpler. In this demo, you can easily update data, and as soon as you move off the row, it's committed to the database. To get the most of this demo, run the same app twice (CTRL+F5). Make changes in one of the instances, move off the row. In the other instance, move to the row that was just updated, (note: if you're already on the row, you'll need to move off then back). You'll see the change made by the other app and can make the change back. The one piece missing from this scenario is an implementation of eventing so that instance 2 would see the changes made by instance one. This is why you must move off, then back to the row to see the change. As you move across the rows, the DataGridView requests the data. The data is fetched directly from the local database/table.
Another ISAM/SqlCeResultSet demo
In this demo we see how the index can be set to control the order of the data. Using a system view, we can populate the ListBox with the list of potential indexes. As you change the index, the view is updated to reflect the data sorted by that index. What isn't covered in this demo is the ability to "filter" the values using the SqlCeCommand.SetRange() api which uses the index to directly filter the visible rows.

SQL Server Compact Bulk Insert Performance Test Harness (Compares Compact & Express)
Demonstrates the power of an embedded database and how much faster it can run than SQL Server for many operations. By implementing a few things, such as "connection pooling" and caching your SqlCeCommand objects, you can achieve similar functionality provided by SQL Server's connection pooling and Query Plan caching. However, because Compact is "in-proc" with your application, you can get the benefits of not having to work through additional networking, process and security layers required by SQL Server which is designed to work over the network.
Privately deploying both the 32 and 64bit versions of SQL Server Compact with your app
Do your users know whether they have 32bit or 64bit machines? If they are 64bit, are they running a 64bit version of the OS? Should they have to figure this out? Using private deployment, developers can include both the 32 and 64bit versions of Compact so the user never has to make a choice. Yes, it's a bit more k to include in your app, but if it "just works", is that a small price to pay?
Running Compact from Read Only Media (DVD, CD, Locked USB Key)
Ever get a CD or DVD in the mail. Pop it in the drive to see what's on it, and it prompts you to install some software - yikes! Let's see if you can use this as a Frisbee and get it in the trash across the room, J With this demo, you can deploy a large amount of content, but stored in a Compact database so your users can run the app, search the data, and with private deployment, you can include the Compact engine so your users can "view the data" without having to install anything.
The demo is simply an extension of private deployment, but modifies the connection string to tell Compact to open the database in ReadOnly mode, and specifies a temp directory:
connStr = String.Format("Data Source = {0}\Northwind.sdf;Mode = Read Only;Temp Path={1} ", Windows.Forms.Application.StartupPath, My.Computer.FileSystem.SpecialDirectories.Temp)
Using Compact as a Custom Doc Format (Recipe Manager)
Need to save data from your app in a "document"? Want to post that "document" to a SharePoint site or email it to another team member? Want to double click your document and launch the associated app? Since SQL Server Compact uses a single file, code free, file format, and since it doesn't care what extension you use, developers can use custom extensions for the database file to launch their app. In this demo I use Click Once enhancements in .NET FX 3.5 SP1 to associate the custom extension with my ClickOnce installed application.
Managed Stored Procedures (A Common DLL for data access to Compact and SQL Server)
The great debate will forever continue on the debate of sprocs and its religion or science. I wrote about this here, but rather than debate the topic, here's a sample that shows how you can write a common data access layer to target against SQL Server (Express included) and Compact (SQLce) As outlined in this presentation, you can get far better scalability from your database by moving the logic out of the database as you can create several front end services to a single database, but you can only scale up a database so far before you need to scale out, which today is a difficult task.
Logical Queuing
In a service oriented world, is it really practical to assume all "services" can be synchronized? Or, is it a mixture of synchronizing some data, and submitting to existing, non synchable services that really touches on reality? In this demo, associated by this blog post, I demonstrate why using a database as your "queue" to services provides much more practical and realistic methods for working with existing services than expecting all the existing services to rev to support "sync". Sync is a very important technology, but no one technology serves all. In this blog post I noted down some thoughts, but not as polished as I was hoping to post.
Using Compact within Excel
Ginny Caughey and I co-presented at Tech Ed US in 08. Ginny assembled some great demos on using SQL Server Compact within VSTO, particularly within Excel.
Database Viewer
Every wanted to just look inside a SQL Server Compact Database, but didn't want to install Visual Studio or SQL Server Management Studio Express? With this little utility you can see the list of tables, and the data within each table. Not a full featured app, but rather a utility I use to show encryption or the ability to open a database across multiple users. It does show how to query the system views to get the list of tables.
Creating & Managing Local Database Versions through Scripts
When deploying applications with a local database, deploying the database with the app can seem easy at first, but once the user starts making changes to the local database, it gets messy quickly. If you're not careful, you can even lose the local data created/updated by the user. In this presentation, I created several animated slides that explain the complications and why script based deployment and versioning is the only practical way to manage local databases. This sample walks through the creation and versioning of local tables. To focus on the script based versioning aspects, I excluded any interaction with synchronized tables as that just gets even more complicated.
Versioning Local Databases with Scripts when using Sync Services for ADO.NET
In this demo we see how to version schemas when using Sync Services for ADO.NET. This includes two projects. One for the initial installation of V1, and another for the upgrade, or initial creation of V2. V1 includes creating a set of tables that aren't synchronized, such as state management for submitting orders to an existing service. Once sync completes, there are a set of additional scripts to create foreign keys between the synched tables, and between the synched tables and the local tables.
V2 enhances the synchronized tables with additional columns. The setup of this demo is a bit more complex as I've configured the server side sync components in a dll, then hosted the dll in a WCF Web Project. The WCF Web Project is published to an IIS instance, but uses different sub directories: for V1-http://localhost/VersionSchema/V1/LookupSyncService.svc, for V2-http://localhost/VersionSchema/V2/LookupSyncService.svc. Using this versioning scheme we can publish V2, allowing apps to slowly migrate over to V2, while the V1 apps continue to function and the business continues to function. The animation in this presentation helps explain this somewhat complex subject.

· Deploying Express with Scripts
Similar to the Compact deployment model, but with the additional steps required to create the physical mdf/ldf combination.

Private Deployment using the ADO.NET Entity Provider
One of the most popular features of SQL Server Compact is its ability to privately deploy the Compact runtime as a set of dlls directly within your application. But when using the ADO.NET Entity framework, things get a little more difficult as the Entity Framework uses the Provider Factory model for loading the individual data providers. I discussed this in more detail in this post, but here's a sample showing how to include the dlls and changes in app.config to work properly.
Common Programming between Desktop & Device
While SQL Server Compact provides the same apis between desktop and device (.NET Framework and the .NET Compact Framework), it can get a little more complex as the surrounding apis, such as the lack of the |DataDirectory| macro, and the lack of settings make it more difficult. This project shows a strategy for filling in the missing pieces of the .NET Compact framework so you can compile the same sourcecode for desktop, then device.

Some great partner tools

Data Port Console by Primeworks
Great tool for scripting tables from SQL Server Compact. For only $50, it's hard to beat
Remote SQLce
Great tool for managing a Compact database on the device, from the desktop
CodePlex
Codeplex is starting to collect several great code projects related to SQL Server Compact. I'm sure this will continue to grow, so it's a great place to look for what pain someone else has already endured

Great books

HitchhikerGuides.net - Bill Vaughn
Bill has a great, no BS style that just helps you get to the facts. It's a quick read, and at only $10, it's hard to pass up when you want to get up to speed quickly on Compact.
Microsoft SQL Server 2005 Compact - Prashant Dhingra
Prashant originally worked in the Compact team, and provides a great insiders look at SQL Server Compact
SQL Server Compact (In Spanish)- Jose M. Torres
If you're looking for a book on Compact in Spanish, here you go. I wish I could say I've read it, but, it's been years since I was at all fluent in Spanish. From what I have flipped through, it looks like it's covered all the topics. Jose has been active in the community, so I'd say it's a great bet.
Windows Mobile Data Synchronization - Rob Tiffany
Need some help, or want to know about Merge Replication? Might as well get it from the mast of Merge - Rob Tiffany. Rob spends his time traveling around the world helping customers scale and configure Merge. If it's been done, Rob has seen it, and likely has helped get it working.

Other Support/Info Channels

SQL Server Compact Blogs & Forums

Steve Lasker's Blog
The blog you got this document from, :) Lots of information on how we got here, demos and powerpoints. But, since I've moved off the team, won't be able to maintain the information going forward, so I'd recommend the following blogs going forward.

SQL Server Compact Team Blog
Where most of the team posts info. Everything from our encryption details, Entity support, query processor details, etc. You can think of it as the authoritative source. Even Laxmi posts to the Team Blog as well as his own...

Laxmi's Blog
One of great and passionate developers on the SQL Server Compact team. Be careful what you ask for, ‘cause Laxmi will tell you J. Seriously, Laxmi spends a lot of time in the forums listening and answering the issues and has a lot of experience with the product.

SQL Server Compact Forums
Where the team and our MVPs hang out to answer your questions. In addition to the product team, you'll also find answers from those that are actually using the product. We've gotten some great info here as well for how the product is actually used, as opposed to what we thought developers would do with Compact <g>

Sync Framework/Sync Services for ADO.NET Blogs & Forums

Sync Development Center
The home for the sync team and discusses the Sync Framework as well as Sync Services for ADO.NET.

Sync Team Blog
Less formal information on Sync Services and the Sync Framework

Sync Framework/Sync Services for ADO.NET Forums
A great place to post questions and find answers from the Sync team

Syncmaster Rafik website and Blog
Rafik Robeal was one of our core developers for Sync Services for ADO.NET and has all the nuts and bolts knowledge for what we originally built. Unfortunately, Rafik has moved onto other ventures. However, he's still got some great content on his site.

Enjoy the holidays,

Steve

Tech Ed EMEA 08 Powerpoints and Demos

2008-11-19T21:07:00Z

Another great year in Barcelona. In addition to the sessions below, we had several nights out on the town. As usual, we had the Microsoft Regional Director get togethers. It's always interesting when you have social geeks out on the town. Chris Menegay and I decided to make it a late night on Friday. I had to be ready to leave at 4:40am to catch my flight anyway. The bars down at the water front are always fun to "see the people".

I should also mention a great tasting menu restaurant that Shanku Niyogi introduced us to a few years ago Cinc Sentits. About 14 of us, including Pat Helland, Rocky Lhotka and his lovely wife, Brian Randell, Lisa Feigenbaum, David Hill, Kathy Kam, William Oellermann (an old friend from Dallas), Karen Liu all went. Great food and wine, and would highly recommend it to anyone visiting Barcelona.

Anyway, here's the demos and powerpoints...

DAT314 Unlocking the Power of SQL Server Compact 3.5
Powerpoint

Demos:

DAT405 Managing and Versioning Client Databases

Powerpoint

Demos:

Next year, Berlin. Hope to make the trip.

Steve

Heading to Tech Ed EMEA Barcelona

2008-11-09T02:19:00Z

I always love going to Barcelona. Sure, it's a great city, and loved riding motorcycles into the mountains last year with my wife; but it's just a great event to attend and present. It sort of like PDC and Tech Ed US wrapped into one event.

Anyway, I'll be giving two presentations this year, and attending a panel discussion. After the sessions, I'll post the samples and the deck...

DAT314 Unlocking the Power of SQL Server Compact 3.5
Tuesday, November 11, 5:00-6:15pm

With Visual Studio 2008, you can now embed SQL Server Compact as DLLs directly within your application. So you've seen the intro talks; now what? In this demo packed session we'll dig into the more advanced scenarios for how to take advantage of SQL Server Compact within your applications. Writing managed Stored Procedures; using SQL Server Compact as a custom document format; running the database directly from a DVD; and tips on maximizing performance - these are just some of the demos we'll show to maximize your end users productivity with Visual Studio 2008 and SQL Server Compact

DAT01-LNC Tell Us Where it Hurts! SQL Server Product Feedback Discussion

Thursday, November 13 12:20-1:10

Now that we've released SQL Server 2008, what would you like us to do next? SQL Server 2008 has great new developer functionality but we need you to tell us what we're missing. What are your pain-points as a developer and the scenarios that go with them? We may make some suggestions as to alternatives and workarounds, but primarily we'll take your feedback back to the SQL Server product group for analysis. After all, it is customer feedback that is the primary driver for getting new features into future versions of SQL Server. If you can't attend, please provide your feedback on SQL Server via the http://connect.microsoft.com/sqlserver site.

DAT405 Managing and Versioning Client Databases
Friday, November 14 3:15 - 4:30

Versioning a server database is challenging enough, but at least you can walk up to the Server. What do you do when you have thousands of desktop, laptop and mobile devices within your enterprise or deployed to consumers with several different versions of the app and database? In this session Steve will cover a strategy and implementation for versioning databases associated with your application that can be deployed via ClickOnce or any other based deployment technology.

If you're attending, come on by...

Steve

Compact Tips & Tricks at the Redmond We-Dig users group

2008-11-01T19:11:00Z

This Wednesday, November 5th 2008, I'll be giving doing a local users group presentation that will cover some of the perf tips from PDC and some client database deployment tips for deploying and versioning local databases. I'll be giving a talk on script based deployment at Tech Ed EMEA in 2 weeks, so this is a great chance to polish the demos.

You can get more info at: http://www.we-dig.org/default.aspx

Steve

PDC 2008 - Embedding SQL Server Compact In Desktop And Device Applications

2008-11-01T01:23:00Z

This week I presented a session on SQL Server Compact. Video Recording of the session is here. The session focused on 3 main topics:

Why SQL Server Compact "changes the game" for how you might think about leveraging a database in your app
Performance of SQL Server Compact
Interesting scenarios you can use a local database when it's as easy as Compact.

Powerpoint of the session

For the "why", I mostly focused on the deployment aspects of SQL Server Compact, including the new 64bit deployment scenarios.

For Performance, I took the previous per demo I've been showing and adding some more tests, including a comparison to SQL Server Express and inserts using the SqlCeResultSet. In the performance section I focused mostly on the architecture differences between SQL Server and Compact. SQL Server has a long running service and connection pooling. Compact doesn't. SQL Server caches query plans in the service, compact caches them in the SqlCeCommand object. By understanding the architectural differences, you can get a dramatic performance benefit by just doing a few simple steps.

A few performance comparisons

Connection Pooling

Test 1:
Traditional inserts, following the standard model of open/close connections as fast as possible. For this scenario, the developer assumes a connection pool, which is provided by the SqlClient (MDAC/SNAC) libraries installed on each users computer. The problem is Compact doesn't have built in connection pooling, so for each operation, Compact loads and unloads the engine. It's somewhat equivalent to attaching and detaching a SQL Server database (MDF), or starting/stopping the service.

public voidInsertCustomer(intcustomerId, string customerName) {
using (SqlCeConnection conn = new SqlCeConnection(_connectionString)) {
SqlCeCommand cmd = conn.CreateCommand();
cmd.CommandText = Queries.Sprocs.CustomerInsert;
cmd.Parameters.AddWithValue("Id", customerId);
cmd.Parameters.AddWithValue("Name", customerName);
conn.Open();
cmd.ExecuteNonQuery();
}
}

Test 2:
In Test 2, I simply modified the connection string for SQL Server to disable Connection Pooling (pooling=false) Figured it wasn't fair to stop and start the SQL Service or attach/detach. In reality, what we're really comparing is the cost of creating connections. For SQL Server, we're simply establishing the networking stack, which is a bit costly. For Compact, we're actually loading the engine.

Test 3:
Here I'm simply keeping the SqlCeConnection open. Since Compact doesn't have connection pooling, it means I do need to keep the connection open alive and open.

Table showing different tests, and the number of inserts per second.
Note: This isn't meant to be a defacto performance benchmark. Simply an example of how the archtiectural differences are targeted to different scenarios. Your test will vary based on CPU power, RAM, types of data, speed of hard drive, humidity in the air, oxidation on your fingernails and pins within the mother board, ...

Test #		SQL Server	SQL Server Compact
1	Default Open/Close	810	6
2	Open/Close w/o Connection Pooling	122	6
3	Open/Close w/Connection Pooling	810	2,839

In the above table, we can already start to see where Compact can jump ahead, quite significantly. When disabling Connection Pooling, SQL Server drops from 810 inserts/second to 122. While Compact jumps from 6 inserts/second to 2,839.

Query Plan Caching

The next area is comparing Command Caching between Compact and SQL Server. SQL Server caches query plans within the engine. This means that different threads, processes or completely different clients can benefit from each other. It also means the server is holding onto more resources, just in case someone might want them. This is where we really start to see the differences between Compact and Express. Compact, being an embedded database, optimizes for resource usage. It's not that you can't cache query plans, it's just that you, as the developer need to do this as it's not "by default".

Test 1:
Query Plan Caching w/Parameterized queries. I didn't take the time to invalidate the cache for SQL Server each time, so I'll just simply show that Inserts/Second take advantage of Command Caching as well

Test #		SQL Server	SQL Server Compact
1	Default, inserts per se	3859	3142
2	With Query Plan Caching	3859	6224

Source code for the Performance Test Harness

Trace Listener

To monitor what's happening in the field, I demonstrated how you can use a SqlCeTraceListener with sync to capture errors, KPIs or other interesting data in the field, and bring it "home"

Source code for the SqlCeTraceListener

Using SQL Server Compact as a Doc format

Source code

As always, PDC was a blast talking with customers. Lots of great sessions, and too many to list. Luckily, you can see them all at http://www.microsoftpdc.com/ Gotta run to a Halloween party, but wanted to get some info up quickly.

Steve

Privately Deploying SQL Server Compact with the ADO.NET Entity Provider

2008-10-22T04:03:00Z

When privately deploying SQL Server Compact you will need to take a few extra steps if you wish to use the ADO.NET Entity Model. Here's some info on how to do it.

Why the extra steps?
The ADO.NET Entity model was designed as a mid-tier solution. In the mid tier, IT owns the box and they can typically install the software needed. On the client, particularly in corporate environments, the end user doesn't have permission to "install" software. The Entity Framework was also designed to leverage the provider agnostic programming model. Since the System.Data.SqlClient.dll is GAC'd with the .NET Framework, and the DB Provider model was designed around machine.config, a number of assumptions were made. However, no fear, you can add new DbProvider entries, but it may not be as obvious, or what you think works may only work in certain situations. I'll explain as I walk through the steps.

To make this clear, I'll walk through the scenario from Create New Project. If you already have a project that privately deploys SQL Server Compact, jump ahead to Adding the Entity Provider entry

Create New Project
Before we jump into the deployment details, let's build a quick app as a baseline.

Create New Project
1. We'll start by creating a new WPF project. We'll use C#, but VB is just as well. To follow along, I've named it: CompactEntityProviderPrivateDeployment
  Yes, this works with WinForms as well, but I'll never really learn WPF if I keep using my old habits of WinForms...
Add a new Local Database
1. Add a new item to the project, and select Local Database. I've named it: LocalData.sdf
2. Hit cancel on the Choose Your Database Objects wizard.
  This is the default wizard for DataSets and we're focusing on the Entity Framework here...
Add a new table
Rather than do yet another Northwind sample, we'll create a single table database.
1. Double click the LocalData.sdf file to open the database within Server Explorer
2. Right click on the Tables node and select Create Table
3. Name the table Customers
4. Add a column: Name = Id, DataType = nChar, Length = 10, Allow Nulls = No, Primary Key = Yes
5. Add a column: Name = CompanyName
6. Press Ok, to complete the creation of the table
Add some data
1. Open the Tables node
2. Right click and select "Show Table Data"
3. Add a few entries (1, Acme | 2, Widgets | 2, Microsoft | ...)
Add the Entity Model to program against
1. Right Click on the project and select Add New Item
2. Select ADO.NET Entity Model
3. Name the item: LocalData.edmx
4. Choose Generate from Database
5. Accept the default for LocalData.sdf, click next
6. Check the Customers table and press finish
Viewing the data on the WPF form

Drag a ListBox to the Window1.xaml designer
Double click the title bar of the window to create the Window_Loaded event
Add a class instance of the Entity model outside of the Window_Loaded event
public partial class Window1 : Window {
LocalDataEntities _localDataContext;
In the Window_Loaded event, within a Try/Catch block, instance the Entity Model and load the listbox
private void Window_Loaded(object sender, RoutedEventArgs e) {
    try {
        _localDataContext = new LocalDataEntities();
        this.listBox1.ItemsSource = from c in _localDataContext.Customers select c;
        this.listBox1.DisplayMemberPath = "Name";
    }
    catch (Exception ex) {
        MessageBox.Show(ex.ToString());
    }
}
Run the app
All should work fine for now and your app should look as follows:

Deploying the SQL Server Compact Runtime
In the above app, we're working in our development environment with all the latest gadgets. So of course everything works fine, but what about your end users? Do they have everything you just used? While ClickOnce can help end users Pre-Requisite the additional components, this assumes end users have the rights to install software. With a focus on security, Microsoft has worked hard to convinced customers to lock down their PCs. Which means that unless IT does the rollout, you may not have what you need. If your one of those "bottom line affecting" apps that have IT sponsorship, you may be fine, and you can skip this section. If your one of those development/product teams that are working "against the grain" for the corporate mandate that "all apps must be web apps", or you simply want to enable a clean "install" experience for your app, you can take the following steps to assure your apps will "just work". If SQL Server Compact is centrally installed, great. The central version will be used. If there is no centrally installed version, or you need a newer version that what IT is ready to push out, no problem, just follow these steps. If/when IT catches up, the .NET Loader will simply switch to the central version.

Add the Assembly References
View References for your project - notice System.Data.SqlServerCe.dll isn't listed. This is because providers are loaded by the Entity framework at runtime based on the connection string in App.config. We'll need to manually add the references for VS to deploy these dlls.
1. Choose Add Reference and select System.Data.SqlServerCe from the first .NET tab and press Ok
2. Choose Add Reference, but this time choose Browse to find the Entity dll.
  It's not listed by default as it was assumed the Entity Framework would only be used when centrally installed.
  Browse to: C:\Program Files\Microsoft SQL Server Compact Edition\v3.5 and select System.Data.SqlServerCe.Entity.dll
  Note: on 64bit machines, it doesn't matter if you grab the Entity dll from the 32 or 64bit directory as the same "platform neutral" dll is used for both
Change the managed references to be "local"
1. In the References node, select System.Data.SqlServerCe and then select the property grid. Change Copy Local = True. This tells VS to copy the dll to the output directory, even though it's GACd on your development computer. When VS builds your project, it will copy the dll to your output directory, but it will also add it to the ClickOnce Application Files list.
2. Change the System.Data.SqlServerCe.Entity reference to Copy Local = True as well
Add the native runtime for SQL Server Compact
Similar to the .NET Framework, SQL Server Compact achieves its speed, reliability and compact size by using native code for the storage engine and query processor. As of 3.5 SP1, Compact added 64bit support. To avoid your end users from having to figure out whether they have 32 or 64bit machines, only to then choose a 32 or 64bit install, you can include both the 32 and 64bit runtimes directly within your application so end users can get a single "install/copy" of your app and it will "just work" regardless of their bit alignment

To add the 32bit runtime: Add a folder named X86 to your project
Select Add Existing Item and navigate to: C:\Program Files (x86)\Microsoft SQL Server Compact Edition\v3.5
Note: if your client is a 32bit client, simply remove the (x86) portion of the directory:
Using CTRL + Click, select sqlcese35.dll, sqlceqp35.dll, sqlceme35.dll and sqlcecompact35.dll, then choose the little down arrow on the Add button and choose Add As Link
This will make sure any updated installed on your client will be added to the project the next time you build
Select the 4 files within Solution Explorer and select Properties
Change Copy To Output Directory = Copy If Newer
Similar to the .NET References above, this tells VS to verify the date/time stamp at build time and only spend time copying the files if the source is newer than the output directory
Assuming you have a 64bit machine with SQL Server Compact 3.5 SP1 64bit installed you can add the 64bit binaries as well

Add a folder named AMD64 to your project
Select Add Existing Item and navigate to: C:\Program Files\Microsoft SQL Server Compact Edition\v3.5
Just as above, using CTRL + Click, select sqlcese35.dll, sqlceqp35.dll, sqlceme35.dll and sqlcecompact35.dll, then choose the little down arrow on the Add button and choose Add As Link

Remove the ClickOnce Pre Requisites
Now that you've included SQL Server Compact with your app, you no longer need the ClickOnce prerequisites. The Pre-Reqs require Admin rights to install, and this has been a blocker for many companies that have followed Microsoft's advice to lock down their computers.

Right click on the project and select Properties. You can also double click Project Properties for C# projects, or My Project for VB projects
Uncheck everything, but .NET Framework 2.0 as this will give you the cleanest Publish page.
Unless your clients have admin rights, none of the other pre-reqs will work anyways, so you might as well clean up the choices they can actually make. By choosing .NET FX 2.0, VS will generate some javascript that will collapse the region prompting installation of the .NET Framework.

Where are we?
At this point, we have a basic WPF app with some local data. We've including the SQL Server Compact runtime so we don't have to worry about whether it's installed or not. Are we ready to publish the app for ClickOnce installation - nope, not yet. This is the meat of the heading, the reason I've written all the above text. Just in case you don't believe me, try publishing with ClickOnce, shutting down VS, uninstalling SQL Server Compact (both 32 or 64), or simply installing on a machine without Compact installed. You'll notice you get a failure to load data as it can't resolve the Entity Provider.

Main Purpose of This Post

Adding the Entity Provider Entry
As I noted above, the Entity Framework was initial designed for mid tier solutions. This assumes that everything is centrally installed for all services to leverage. However, on clients, we may need to add additional functionality to the application that doesn't ship in the .NET Framework. When SQL Server Compact is centrally installed, the MSI will configure an entry into Machine.config. On clients that don't have SQL Server Compact centrally installed, you'll need to add the entry for the Provider Factory to find SQL Server Compact. But, you can't add it to Machine.config, because that's a central resource which requires Admin rights. Instead, we can add it to app.config, but there is a catch. It turns out database people (ADO.NET team) think about data integrity and constraints as a religion <g>. If you have a machine.config entry and then attempt to add an app.config entry the runtime will throw a constraint violation. We've discussed changing this in the future to simply merge the values (DataTable.Merge) to update any "primary keys" with the new value, but for SQL Server Compact 3.5 and FX 3.5, we need to do a little workaround.

Grab the XML fragment for the Compact DbProvider
Open machine.config from: C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG
Search for SQL Server Compact
Copy the entire XML fragment for <system.data>
Open app.config in your client app.
Note You must edit the hosting exe as dll's don't load unique app.config files. We recognize that most apps do their data access in dlls, and often the developer building the exe portion of the app shouldn't know or care what's in the dlls of the app, so this is why we know this is a bit painful and would like to find a better solution. But, this is where we are, so, blogging on...
Paste the XML fragment from machine.config, but trim it down to the following. Note, I've greyed out the other content that you likely have in app.config to show the positioning within the file:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
<connectionStrings>
    <add name="LocalDataEntities" connectionString="metadata=res://*/LocalData.csdl|res://*/LocalData.ssdl|res://*/LocalData.msl;provider=System.Data.SqlServerCe.3.5;provider connection string="Data Source=|DataDirectory|\LocalData.sdf"" providerName="System.Data.EntityClient" />
</connectionStrings>
<system.data>
    <DbProviderFactories>
      <remove invariant="System.Data.SqlServerCe.3.5"></remove>
      <add name="Microsoft SQL Server Compact Data Provider"
           invariant="System.Data.SqlServerCe.3.5"
           description=".NET Framework Data Provider for Microsoft SQL Server Compact"
           type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=3.5.1.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>
    </DbProviderFactories>
</system.data>
</configuration>

Notice two attributes for name and invariant. It turns out invariant is actually the "unique constraint/name".
If we were to run the app at this point, with Compact centrally installed, the app would fail to load with a duplicate config entry. It's a little vague as the exception is a bit buried in the inner exceptions of the top level exception.

Publish the application to see where we are
You're now finally ready to ClickOnce publish your application, with SQL Server Compact and the Entity Provider included
1. Right click on the project and choose "Publish..."
2. Enter an HTTP address for a webserver you have permissions to: http://localhost/CompactEntityProvider/
  If you've got Vista and don't know the additional settings, send me a comment below and I'll either add the steps, or point you to Saurabh Pant for the steps
3. Finish the wizard and you should now have a default web page with the ability to Install your app
Install the app
Before doing anything else, install the app and let it run. If you've placed the try/catch block around the instancing/loading of the entity model, you should get an exception
The exception is because of those darn DBA types that make sure things are accurate and don't want duplicate data <g>. So, how to work around this? We've played with a few things such as changing the invariant name to something unique, but that means you must correlate the change in the connection strings that VS automatically generates for you. Since this is just too easy to mess up, we've come up with the following recommendation:
Resolving the duplicates
The problem is essentially that we know we need an Entity provider for SQL Server Compact, but we don't know if one is already on the machine. Turns out one of the easiest ways to resolve duplicate data is to delete one. The Config framework does provide a nice way to do this.
1. In the app.config file, add the collored <remove...> XML fragment:
2. Republish and install the app
  1. Right click on the project and choose "Publish..." again. This time, just click finish as you should have everything configured properly
  2. Click Install, and voila, your app should now be running just fine.
    Regardless of a central install, without having to create unique invariant names, you now have Compact running within your app
The real test
Of course the real test is to deploy the app to a machine that doesn't have Compact installed. Now the Entity framework does require .NET FX 3.5 SP1, so your clients do need all those goody bits. But, you might get IT roll out the .NET Framework. It would be great to get them to deploy Compact as well, but IT folks get a little scared about deploying a SQL Server product to all their clients. Not sure why. Maybe we just need to wait a few years ‘till the new guys replace the old ones that remember...

To figure out if your app was loading Compact privately, I've written a lame (UI) about box that you can add to your project to see. The entire source to this walkthrough is below.

Sample Sourcecode

Hope this post was helpful. Would love to hear how many of you are using the Entity Framework with Compact. How many have been able to centrally deploy Compact, or you've gone the private deployment route. Was it because of the Admin rights issue, packaging of your app, or something else.

Thanks,

Steve

Evolution or Revolution for moving to offline architectures

2008-10-18T03:15:00Z

There's been a lot of talk, momentum and questioning for where and how occasionally connected designs fit into the application landscape. There have been a lot of questions for "if and how" developers can take their existing apps "offline". There have been a number of efforts for enabling offline apps and some longer term plans. In VS 2008 (Orcas) we introduced Sync Services for ADO.NET as a developer focused way to synchronize data. The roadmap continues with the Microsoft Sync Framework releases. We've started to show "Astoria Offline" as a means to enable sync over REST based HTTP protocols enabling more generic services. But do any of these "solve the problem". It's been a while since I've done a brain dump on some thoughts related to the evolution vs. revolution of app models, so what better way to dump thoughts than a blogicle.

Can you take your current app and make it offline?
The reality is "it depends". There are so many app designs, it's hard to say definitely what works and what doesn't. There are some well established things that have worked and haven't, but it's not fair to say these apply 100% of the time. One size doesn't fit all.

Intercept/fall back
Do you go with the intercept model? When online and connected, the app communicates directly to the service. (Note I'm using "service" here to represent any remote source. It could be a database "service" a Web Service, a WCF service, or some other API that's only available when your device is connected to "the network"). When the network falls away, the app "falls back" to a local "cache".

This is generally a bad (opinion), or complicated (fact) model. This assumes one of two things. Either your user knows they're going offline and they synchronize before they yank the cable or they predict when the network fails. Of course the application can constantly synchronizing data in the background. Crystal ball? When do you really know or have time to sync beforehand? You're working in your office, and Outlook pops up reminder. Or worse, you get an IM or Text message asking "where are you". You grab your laptop and run... oh, wait, you forgot to sync. Do you have the info needed for the meeting?

For the background sync, one of two things could be happening. When you "fall offline", your view of data suddenly changes because your local copy is so out of date compared to the data you were just looking at, or your synching often enough that there's no difference, asking why you're even trying to work online in the first place. Or, you've effectively created a denial of service attack by asking, has anything changed, has anything changed, has anything changed?

Outlook 2003 (I think that was the version) tried this fallback model. It was awful. You're sitting in your office, writing an email, looking at your inbox. The network goes down, your inbox view completely changes, or worse Outlook froze, and you lost that message you were carefully wording.

Always work locally
In this model, you synchronize everything you need, and make all your interactions against the local store. This is sort of the Outlook model today (Outlook 2007). There are equal problems here. Is it realistic to have all the data locally? Even Outlook data can be significantly large, and that's clearly your data. What about public folders? By default, these are only available online. If you're online, they work. If you're not, they don't. Fairly straight forward; but what about historical data for all the products the company has shipped? What about your list of customers, or the current list of stocks and their prices?

The reality is data volume is growing at an exponential rate. Storage continues to get cheaper and faster. 1TB disks and Solid State storage are becoming mainstream. The problem is while connectivity is getting better; the bandwidth isn't increasing at the same rate. And, even as it does, is it realistic to have everything local? Do you keep one of everything that Home Depot or Safeway keeps in stock? Would be really nice, but not all that practical.

One size fits nobody
The reality is there's no easy answer. This is really an architectural and user model change is required to make this happen. We've been through these before. In the "old times", families ate what they grew. Corn, milk, meat, etc. Others only had Ice or Milk that was delivered to their house daily. You could think of this as the "online model". Today, we go shopping to Safeway, D'Agostino, or your local grocery store. The stores don't grow anything locally. They stock goods they get from somewhere else. You take stuff home and stock it in your pantry, frig, freezer. When you throw out the garbage it goes into the can. The can gets picked up on Thursday. It gets taken to the transfer station, and then off to the dump. The point is we have lots of "store and forward"/sync models already in place. What's really interesting is the "online" things are actually more expensive. It turns out it's cheaper to stock goods that may be used, and accept a percentage of loss for things that don't sell than it is to create on demand. Why do we think electronic bits and bytes should be "online" only? Why are 1's and 0's more expensive than physical goods?

Evolutionary approach: Mapping concepts
If we look at the concepts we have today in web/service/stateless models, they break down into two common, and one advanced models:

Get
Get maps very easily to HTTP:Get. Essentially you make a request to a domain, application and method. You likely pass parameters and of course all the authentication goo. The result of the get is returned and you now have a copy of information relevant to that point in time, and the specific question you've asked. Most likely, but no guarantee it's accurate by the time you quickly display it on your 64bit, quad laptop with a gigabit connection to the internet. Even historical data is subject to "correctness"- remember the Florida elections J But, we live with "copies" all the time. Copies are tangible, things that are "just there". There's a separate question of how "out of date" the copy is.

Submit
You have some information you're sending back. You expect some action to be taken on the data you're submitting. That submit can be accepted, rejected or modified. You get an immediate response, but no guarantee what you've submitted will be accepted. That might happen later on, it might not. You hope, or expect to be notified if something changes. But is that concept built into our app models? Or, do we just assume the world is globally connected, and everything is always running so things can be asked and answered immediately, with 100% accuracy, in one big transaction so no two people can allocate the same "goods".... Whew, that's as ridiculous to assume as it is to type.

Can Get and Submit evolve?
With Get, you can implement a "caching" model. Rather than Get directly from the source, imagine you Get through an abstraction layer. For each Get the abstraction layer keys off the domain/app/method and name/value pairs for parameters. Let's say I make a service call to: http://AcmeServices.com/Books/GetBookByName.asmx. I pass in: Title=SQL Server Compact

In the GetCache, it looks for the service and name/value pairs that match. If it finds a result, it may not have to actually make the network call. It could just return the cached result. But what about stale data? You can put an expiration policy on the cache. For a list of states, a day is likely more than generous. For pricing, maybe an hour. The point is you can customize this per source. For many things, one could argue most queries, the data is fairly static and the app could benefit immensely by caching the "gets". If, however, you were to look online first, than only if the resource wasn't available look in the local cache than what benefit are you getting? Sure, the app would "work offline", but you don't see any benefit in the online mode. Each request still takes the time to roundtrip. If you implement a smart caching model you can provide dramatically faster user responses. ...and in most cases, the data is perfectly accurate. Now it would sure be nice to know when something changes, so if California does sink, Iraq or Canada become the 51^st state, you don't have to watch CNN and ask all your clients to either wait for the cache to update, or "invalidate" the cache. I talked about notifications a bit here, so I'll keep going.

Submit
This one gets interesting as well. You have an order to submit for some widgets. Sure, you can submit directly to a "Web Service", or web page. But in many situations the order submission doesn't actually mean the order will ship. Accounting needs to verify your credit. The products that were supposed to be in stock may have been routed to a bigger customer, or "fell off the truck". Again, the point is just because you may get an immediate acknowledgement the order was accepted, doesn't mean it will be fulfilled. So, why not accept this as the model, and when it works, it just works. When a problem occurs, it's not really a problem because it's built into the system. What if you "queued it up" for sending? In this case we save the message locally, in a "logical queue", and when the service is available, we send it on its way. I used the term "logical queuing" as I'm not implying you must use something like SQL Server Broker, MSMQ or WCF Queues, etc. These tend to be a bit over complicated for what you need on the client, and it makes it difficult to act, query or evaluate the data in its transient state. A while back I wrote a blogicle on and some samples for Logical Queuing.

Sync
This is what some might assume is the answer to all of these problems. If I can synchronize changes from other nodes (the server and other clients) with my local store, and I can make changes locally and have them synchronize back "up" to the other nodes, doesn't that solve everything? In the land of demos, sure. But in the real world there are just too many complications. The volume of data, requirements for business logic, and workflow make it difficult to assume Sync can solve all the problems. Where sync does do really well is for synchronizing reference data. That list of states, codes, or even larger volumes like the product catalog. The Logical Queuing blogicle and sample demonstrate some thoughts here. I recently saw some work the Microsoft Mobile Line of Business CRM team, and it also uses a similar model.

Revolution is on the horizon
With all the complications and half way solutions, you have to wonder what's the real answer to all this mess. Will this problem just go away because we'll have high speed internet available everywhere? Even if you could be guaranteed internet access everywhere, do we think that every service will be available all the time? As the world gets more connected, will systems be more reliable and capable of enlisting in massive distributed transactions? Or, will computing systems evolve to what every other large scale system as evolved to. Queuing, Caching, Reserving, Buffering, Acknowledgement, Conflict Detection & Resolution and Notifications.

While I talked a bit about the food supply earlier, this is also a bit like the VB Classic to Web transition. For those old enough to remember the great 90's there was a big transition from "fat clients" to "thin clients". No subtle suggestion of which is better there J When developers first started building ASP Classic (pre .net) apps they simply moved their session state to the ASP Session object. Which meant web servers could serve about 5-10 people before falling over. Not exactly the promise we had all hoped for. It took a while to realize the app models had to change. But, moving from Client apps to Web apps was a bit more obvious. Mostly because the UI changed (for the worse), but at least users could get their work done because we couldn't get the VB apps deployed. (yes, I'm over simplifying things, but run with me for a minute).

Since developers had to re-write their UI anyway, it was an obvious change. Making the transition from online to offline mode apps isn't as obvious. The only UI required is the UI really telling them when problems occur. Who wants that?

The reality is things are a changing. Nothing to announce, nothing to promise, but there is a revolution on the way. Revolutions take time for people to live through denial that it's coming, but it comes as a wave of reality that just smacks you with "duhh, I guess that was a stupid assumption".

While we all wait for the revolution, you can look at things like ADO.NET Sync Services, the Sync Framework, Astoria Offline, and lots of goodies the Patterns and Practices team has done.

Steve

SQL Server Compact 3.5 SP1 available for Win CE 5.0 and 6.0 Platform Builder

2008-08-14T21:12:00Z

After much demand, the latest Platform Builder updates have been released, and they include SQL Server Compact 3.5 SP1.

Steve

Why doesn't Visual Studio 2008 SP1 installer update SQL Server Compact 3.5 for Devices?

2008-08-13T21:53:00Z

In addition to the 64bit support being a web-only download, I should have also noted that for similar reasons, the Devices version of SQL Server Compact 3.5 SP1 is also only available as a web download.

Why: Because of the multiple platforms, the download is ~22mb. That's a big chunk for the Visual Studio Service Pack to include while not everyone may have installed the Smart Device extensions. I wish things were more flexible so we could have incorporated this into the VS SP1 for an auto-prompt for extra downloads, but I must say, I've been very impressed with the quality of the installer of the 2008 SP1 experience compared to the 2005 SP1 experience. Sometimes simpler is better...

Steve

Why does VS 2008 SP1 not include SQL Server Compact 3.5 SP1 64bit?

2008-08-13T00:12:00Z

So you want 64bit support so you can set Target = Any. You just installed VS 2008 SP1, but when you run your app you still get an error...

Why? Because VS 2008 SP1 doesn't actually include the 64bit version of SQL Server Compact 3.5 SP1. To remedy this, simply install the 64bit version from our download page. If you've already installed VS 2008 SP1, you have the 32 bit version. You just need the 64bit version.

Why doesn't VS 2008 SP1 include the 64bit release? Since VS2008 RTM only included the 32bit version of Compact, it was hard to justify adding a new package to the VS Service Pack. We could have negotiated this as the DevDiv folks have been very accommodating, but that also meant we would have had to have the 64bit release done much earlier so it can be "checked-in" to the SP1 branch. To minimize the download size for those that need the 64bit release, and to give our Compact team time to get the 64bit release complete, we opted to make the 64bit release available via the web only.

Steve

SQL Server Compact 3.5 SP1 Released

2008-08-07T04:12:00Z

I'm happy to announce the release of SQL Server Compact - SP1

This release includes several key features and bug fixes following up on the asks of our customers.

The new features in SQL Server Compact 3.5 SP1 are:

ADO.NET Entity Framework provider. The Entity Framework enables you to work with data in the form of domain-specific objects and properties, such as customers and customer addresses, without having to concern yourself with the underlying database tables and columns where this data is stored.

Support for the ADO.NET Entity Framework allows you to create flexible, strongly typed queries against the Entity Framework object context by using LINQ expressions and the LINQ standard query operators directly from the development environment.

Case-sensitive collations for those C# folks that were allowed into the database <g>
Native 64bit support. No more locking your apps to WoW mode or Target = X86. And yes, we support a single version of your app that can privately deploy Compact 32 and 64 so your customers don't have to figure out whether they're running 32 or 64bit operating systems.

We'll have a KB article out soon that covers the rollup of bug fixes since RTM as well.

We're still waiting on the main landing/content pages to be updated, so for those of you too impatient, here's the download links directly:

August 7th update: Links updated to reflect download pages with 32bit and 64bit downloads, along with the localized versions

SQL Server Compact SP1 will be included in Visual Studio 2008 SP1 as well. So, you won't need to download it separately like you did in Visual Studio 2005 SP1. ...we've gotten better about integrating things for you... These links are mostly for those that need SQL Server Compact SP1 for VS 2005 support, or those that can't install VS 2008 SP1 for some reason. The Visual Studio 2008 SP1 setup is sooooo much better than VS 2005 SP1.

More posts to come, but just to answer the first Q&A:

Q: What .NET FX Versions does Sp1 Require:
A: Compact SP1 can be used with VS 2005, .NET FX 2.0, 3.0, 3.5 and 3.5 SP1. When using the Entity Provider, you will need .NET FX 3.5 SP1 as this is where the entity framework ships.

Thanks, and as always, we welcome your feedback,

Steve and the rest of the SQL Server Compact team

SQL Server Compact Books - now in Spanish

2008-08-05T20:55:00Z

For our Spanish customers, Jose M. Torres just published a book covering SQL Server Compact for our Spanish customers. Been a while since my Spanish was up to par, but Jose is one of our MVPs for device apps, so just gives him instant credibility in my book. I'll have to get a few copies for hand outs and do some translating. But, should make for a good read for those looking for more info.

It's worth listing some other books as well:
Microsoft SQL Server 2005 Compact Edition by Prashant Dhingra and Trent Swanson. Prashant was a member of the SQL Server Compact team and has some unique perspectives.

Windows Mobile Data Synchronization with SQL Server 2005 and SQL Server Compact 3.1 by Rob Tiffany, William Vaughn, and Catherine Wyatt. Rob, with his Microsoft Consulting Field experience, and Bill, with his always unique, funny and very real experience also makes for a great read. Merge Replication can be one of the most powerful, and most difficult things to get correct. Rob does a great job demystifying how to get the most from Merge Replication using SQL Server Compact.

Bill also wrote this eBook for SQL Server Compact which was very insightful as well. What I love about Bill is he's brutally honest, but has the real world perspective many of our customers demand.

Steve

Heading to Tech Ed US 08

2008-05-30T10:43:00Z

It's that time of year again. A quick note on some of the sessions/panel discussions I'll be presenting at, and some others that relate to SQL Server Compact.

Code	Session
DAT325 Wednesday 8:30AM-9:45AM	Unlocking the Power of Microsoft SQL Server Compact 3.5 With Visual Studio 2008, you can now embed SQL Server Compact as dlls directly within your application. But you've seen the intro talks; now what? In this demo packed session, Ginny and Steve will dig into the more advanced scenarios for how to take advantage of SQL Server Compact within your applications. How to write managed Stored Procedures, sharing a common dll between desktop and device apps, using SQL Server Compact as a custom document format, tips on maximizing performance and how to deploy and version a local database within your app are all just some of the demos you'll see to maximize your end users productivity with Visual Studio 2008 and SQL Server Compact. Location: S220 E Presenters: Ginny Caughey and Steve Lasker

TEO Panel _24 Wednesday 1:00PM-2:00PM	Building Offline Enabled Applications Panel Discussion In an online world, why are we building offline apps? Because networks are only occasionally available, or occasionally not available. However, building Offline apps is a bit more complicated. Come bring your thoughts to a panel of speakers that work on enabling offline apps from the storage, sync, programming model, and UI stack. The panelists will discuss what we're working on today, and what's coming in the future. Location: Open Spaces on the main floor Panelists: Steve Lasker, Ginny Caughey, Rob Tiffany, Liam Cavanagh, Glenn Block

TEO Panel _33 Friday 2:00PM-3:00PM	LINQ in the UI Layer LINQ is commonly known as a great way to query data from external sources (databases, web services, XML, SharePoint, etc). However, there are numerous other places where LINQ can make the developers life much easier when working on the end user interface, especially when you incorporate DataSet into the mix. This panel will talk about these approaches and the possible pitfalls of using them. Location: Open Spaces on the main floor Panelists: Erick Thompson, Steve Lasker, Amanda Silver

MBL403	Building Custom Sync Providers for the Microsoft Sync Framework Andy Wigley Wednesday 2:45

WIN202	Introduction to Microsoft Sync Framework Liam Cavanagh Thursday 1:00

MBL404	Microsoft SQL Server 2005 Compact Ultimate Performance Tuning Darren Shaffer Thursday 4:30

MBL07-TLC	Microsoft Synchronization Services for ADO.NET: From Desktops to Devices Liam Cavanagh Friday 8:30

MBL01-TLC	Taking Data Offline: Introduction to Microsoft Synchronization Services for ADO.NET Liam Cavanagh Friday 4:30

Road Trip

The week after Tech Ed Developers we'll be doing our next Road Trip. We still have some time in a few of the cities, so if you've got something interesting, let me know and we might be able to swing by.

Tampa Florida, Monday-Tuesday, June 9^th-10^th
Los Angeles , Wednesday, June 10^th
San Francisco, Friday, June 13^th

PowerPoint Presentation

The following links were posted prior to Tech Ed. In typical fashion the content will continue to evolve until we actually present. I'll leave a note here when these have been updated post the session.

Tech Ed US 08 DAT325 - Unlocking the Power of SQL Server Compact

The following demos were presented either as part of the Unlocking the Power of SQL Server Compact session Ginny and I gave, shown at the booth, or shown at other presentations for our June '08 Road Trip

Demos

We'll be spending a lot of time at the booth hearing from all of you that have started to work with Compact. We continue to hear about cool scenarios, so come on by, and tell us what you like and what you think we need to do in our 4.0 release.

Thanks,
Steve

SQL Server Compact 3.5 SP1 Beta available

2008-05-14T20:22:00Z

August 6th 2008 UPDATE: SQL Server Compact 3.5 SP1 has shipped: SQL Server Compact 3.5 SP1 Released

Developers looking to get the beta of SP1 for SQL Server Compact can download it from here:

If you install Visual Studio 2008 SP1 Beta, you'll get the Compact Sp1 as well. But, if you need the Compact SP1 beta for Visual Studio 2005, or simply can't install the VS 2008 SP1 Beta for some reason, you can download the Compact beta directly.

So, what's in the Compact SP1 Beta?

ADO.NET Entity support for SQL Server Compact. In addition to runtime enhancements provided in the Compact runtime, you'll also get Designer support if you download the VS 2008 SP1 Beta.
Case Sensitive Collation support
Updates for datatypes exposed by SQL Server 2008 to be synchronized with Compact 3.5. We don't have any of these new datatypes in Compact, but sync will map them to equivalent types in Compact.
Bug fixes for several query optimizations
Additional overload to the SqlCeEngine.Verify() api to include additional consistency checking

Correction (May 15, '08):

The Verify overload was actually added just after SP1. I forgot that I installed a later build when writing this post. ...so, it's coming, just not in the public SP1

System.Data.SqlServerCe.SqlCeEngine eng = new System.Data.SqlServerCe.SqlCeEngine();

eng.Verify(System.Data.SqlServerCe.VerifyOption.Enhanced);

Updates to the Sync Services for ADO.NET runtime, including the ability to leverage the SQL Server 2008 Change Tracking features in the SyncAdapterBuilder

What's not yet in the Beta?

Native 64bit support. This will be in the RTM download. It's just not part of the VS SP1 as we didn't ship the 64bit release with VS 2008, and we're trying to hold the rule that we only service bits that were already on the users machine.
A bump in our versioning to support private deployment and central deployment.

I'll describe this in another post, but essentially developers wanting to privately deploy Sp1 when RTM is installed will fail as both SP1 and RTM have the same version number. Since the GAC always wins, the newer, privately deployed dlls will not load. We've fixed this in a build just after the beta, so this will work when we ship...

When will it ship?
SQL Server Compact 3.5 SP1 will ship with Visual Studio 2008 SP1 and SQL Server 2008, which is scheduled for later this summer.

Please post feedback and questions to SQL Server Compact 3.5 MSDN Forum and Synchronization Services for ADO.Net MSDN Forum

For bugs, please post to Microsoft Connect, and be sure to set the product name to SQL Server Compact Edition Repro steps are key.

Steve

Steve Lasker's Web Log - www.SteveLasker.com/Blog

New year, new gig, new blog. Moving to the cloud…

Demos, Presentations, Links, Screencasts and Videos for SQL Server Compact

Recent Presentations at PDC and Tech Ed

Just the demos, and nothing but the demos...

Other interesting links to previous posts:

Some great partner tools

Great books

Other Support/Info Channels

SQL Server Compact Blogs & Forums

Sync Framework/Sync Services for ADO.NET Blogs & Forums

Tech Ed EMEA 08 Powerpoints and Demos

Heading to Tech Ed EMEA Barcelona

Compact Tips & Tricks at the Redmond We-Dig users group

PDC 2008 - Embedding SQL Server Compact In Desktop And Device Applications

Connection Pooling

Query Plan Caching

Trace Listener

Using SQL Server Compact as a Doc format

Privately Deploying SQL Server Compact with the ADO.NET Entity Provider

Evolution or Revolution for moving to offline architectures

SQL Server Compact 3.5 SP1 available for Win CE 5.0 and 6.0 Platform Builder

Why doesn't Visual Studio 2008 SP1 installer update SQL Server Compact 3.5 for Devices?

Why does VS 2008 SP1 not include SQL Server Compact 3.5 SP1 64bit?

SQL Server Compact 3.5 SP1 Released

SQL Server Compact Books - now in Spanish

Heading to Tech Ed US 08

SQL Server Compact 3.5 SP1 Beta available