Visual Studio Magazine Article Retrospective

Following are images of Visual Studio Magazine issues from late 2003 to the present for which I've written cover stories. Each entry includes the article name and deck. Click the image to open the article from the Visual Studio Magazine Web site.

Updated 6/28/2008: As of early 2008, archives of articles earlier than October 2006 are no longer available from Redmond Media Group, so they are delivered as archived Web pages from the Wayback Machine.

All but one of the Wayback Machine archives are the single-page print version and have working links to Additional Resources, tables, and listings. All figures have captions and most have the original diagram or screen capture. Sample code is not accessible from Wayback Machine archives.

Targeting Azure Storage (July 2009) Learn how to store and retrieve binary large objects in the cloud with Azure's RESTful Storage API and sample C# StorageClient library.

Retire Your Data Center (February 2009) Visual Studio 2008, ASP.NET, and the Azure Services Platform combine to simplify local development of data-intensive Web apps and automate their deployment in Microsoft data centers. The result: You get maximized availability and reliability with almost limitless on-demand scalability, while you pay only for resources consumed.

Speed O/R Mapping with LINQ to SQL (December 2008) LINQ to SQL continues to be a top contender in the .NET object/relational mapping tool market despite Microsoft's promotion of the Entity Framework as one of the "Pillars of SQL Server 2008: Dynamic Development.”

Generate Web Sites Automatically (August 2008) Visual Studio 2008 Service Pack 1's new ASP.NET Dynamic Data templates automatically generate code for DataGrid, ListView, DetailsView, and FormView display and editing controls on dynamic pages derived from a master page and CSS stylesheet. Dynamic Data leverages AJAX to smooth page transitions and delivers scaffolding for codeless, key-based page routing with Entity Framework or LINQ to SQL object/relational mapping tools.

Test-Drive SQL Server Data Services (July 2008) Microsoft readies its new "cloud database" by hosting beta versions of REST and SOAP protocols for performing CRUD operations on clustered, customized SQL Server 2008 instances. These instances are organized as massively scalable, super-reliable, highly available Web services.

Manipulate Data in the Cloud with ADO.NET (May 2008) ADO.NET Data Services (formerly code-named "Project Astoria") delivers data from relational tables and Windows Live services to Web mashups and Visual Studio 2008 projects, including ASP.NET AJAX and Silverlight 2.0 rich Internet applications, as Representational State Transfer (REST) resources over HTTP in response to URI-based requests or LINQ to REST queries.

Model Domain Objects with the Entity Framework (March 2008) Microsoft's ADO.NET Team readies Entity Framework and Tools 1.0 for release as a VS 2008 add-in with enterprise-level features that LINQ to SQL doesn't offer -- domain object modeling, flexible inheritance techniques, multiple database vendors, and do-it-yourself n-tier deployment. "Do-it yourself n-tier deployment" refers to Daniel Simmons' Entity Bag (Perseus) project, which is covered by a sidebar.

Visual Studio 2008 Kicks Off (January 2008) Find out how VS 2008's greatly expanded feature set and new .NET Fx 3.5 namespaces can boost your career as a professional developer and add to your programming enjoyment.  Additional VS 2008 articles in the January 2008 issue: VS 2008: The MIA Features VS 2008: The Road Ahead

Optimize LINQ to SQL Performance (November 2007) Persisting business objects to sQL Server 2005 or later with object/relational mapping by LINQ to SQL can extract a performance Penalty. Learn how to take maximum advantage of LINQ's strongly typed query capabilities without overtaxing the database server or losing front-end agility.

Update Local Data Caches with Sync Services (May 2007) The Microsoft Synchronization Services 1.0 API for SQL Server 2005 Compact Edition and the new Sync Designer in the Orcas March 2007 CTP team up to generate a local data cache that synchronizes incrementally and bidirectionally with SQL Server [Express].

Lighten Up Your Local Databases (March 2007) Put local data storage on a resource diet and improve performance with the newly upgraded (and free) SQL Server 2005 Compact Edition.

Objectify Data with ADO.NET vNext (October 2006) The ADO.NET vNext August 2006 Community Technical Preview reincarnates ObjectSpaces’ object/relational mapping technology and OPath query language as the Entity Framework, Entity Data Model, Entity SQL, and LINQ to Entities for the Visual Studio “Orcas” release.

Program SQL Server 2005’s Service Broker (June 2006) SQL Server 2005’s versatile Service Broker infrastructure enables asynchronous messaging between databases and server instances, handles database server event notifications, responds to database change notifications, and sends Database Mail.

Test Drive VB9 and DLinq (April 2006) The January 2006 Language Integrated Query (LINQ) preview for the next ("Orcas") version of Visual Basic enables automating SQL Server object-relational mapping for DLinq and enhances XLinq syntax for literal XML and late binding.

Add Reports and Charts to Web Pages (March 2006) The ASP.NET 2.0 version of Visual Studio 2005's ReportViewer control and its Report Designer let Web page developers quickly embed, format, and export interactive reports and charts without running a SQL Server Report Server.

Build Client-Side Reports Easily (November 2005) VS 2005's new ReportViewer control and its built-in Report Designer enable smart-client and Web page designers to lay out, format, embed, export, and print interactive reports without running a SQL Server Report Server.

Create Interoperable Native Web Services (October 2005) Yukon lets you take advantage of the new kernel-mode Http.sys listener and eliminates the need for IIS to process ASMX files or SQLXML 3.0 templates that implement Web services.

Exploit Yukon's XML Data Type (June 2005) Take advantage of SQL Server 2005’s new native XML data type to add XML columns to a table, populate and index the columns, and understand basic XQuery syntax.

Build Real-Time Web Images (August 2004) Use Microsoft's TerraService and MapPoint Web Services to start your own VS.NET-based Windows form mapping projects.

Store Large Lookup Tables in DataSets (July 2004) Persist DataSets of lookup information as local XML files so disconnected laptop and Pocket PC users can search and update DataSets quickly.

Use InfoPath with VS.NET 2003 (May 2004) InfoPath SP1 and the new .NET 2003 Toolkit let you implement business logic behind InfoPath forms with managed VB.NET or C# code instead of JScript or VBScript event handlers.

Get a Grip on Longhorn (February 2004) Take a running start at developing applications for the next Windows OS.

Optimize SQL Server Data Access (November 2003) Numerical test data with real-world data objects can help you choose a data-access methodology that maximizes the database's overall performance.

Cover story thumbnails for issues earlier than November 2003 aren't available at this time.

Note: The preceding list excludes articles for "Database Design" and other department columns.

Technorati Tags: Databases, SQL Server 2005, SQL Server, SQLServer, SQL Server 2005 Express, SQL Express, SQLX, MSSQL, SQL Server Service Broker, Service Broker, Query Notifications, Database Mail, LINQ, LINQ to SQL, DLinq, LINQ to XML, XLinq, Visual Studio 2005, Visual Studio, VS 2005, Web Services, ReportViewer Control, ReportViewer, XML Data Type, XQuery, XML, TerraService, TerraServer, MapPoint, Dataset, Longhorn, WinFS, Indigo, Avalon, Ego Trip

Interest in Cloud Computing Increases as Web Services and SOA Lose Google Search and News Volume

I’ve been tracking Web search interest in “cloud computing” since Microsoft announced SQL Server Data Services (SSDS, now SQL Data Services, SDS) at MIX 08 and I started my weekly Windows Azure and Cloud Computing Posts for Whenever posts. My admittedly unscientific technique was to periodically record Google hits for the “cloud computing” search term.

William Vambenepe’s The law of conservation of hype post of 5/8/2009 inspired me to compare Google Trends’ Search Volume index and News Reference volume for three related terms that in the past few years garnered similar hype levels: virtualization, SOA, and Web services. Here’s the Google Trends graph of the four terms for the past five+ years:

To better demonstrate that cloud computing is in the “Technology Trigger” phase of Gartner’s Hype Cycle, here’s a graph for “cloud computing” only for the past 12 months:

On May 8, 2009, a “cloud computing” Google Web search returned about 13,400,000 hits; a Google News search returned 7,775 hits.

Note: The peak at point C (late October 2008) occurred during Microsoft’s Professional Developers Conference (PDC) 2008 where Ray Ozzie and Amitabh Srivastava announced the Azure Services Platform in the opening keynote.

For reference, here’s a graphic example of the classic Gartner Hype Cycle:

Here’s Gartner’s view of cloud computing from its Gartner Highlights 27 Technologies in the 2008 Hype Cycle for Emerging Technologies press release:

Cloud computing — As companies seek to consume their IT services in the most cost-effective way, interest is growing in drawing a broad range of services (for example, computational power, storage and business applications) from the "cloud," rather than from on-premises equipment. Many types of technology providers are aligning themselves with this trend, with the result that confusion and hype will continue for at least another year before distinct submarkets and market leaders emerge.

Technorati Tags: Cloud Computing,SOA,Web Services,Virtualization,Windows Azure,Azure Platform Services,Microsoft Azure,Hype Cycle,Gartner Hype Cycle

LINQ and Entity Framework Posts for 5/22/2008+

Note: This post is updated daily or more frequently, depending on the availability of new articles.

SQL Server Data Services Rolls Out "Sprint 2" Upgrade

The SQL Server Data Services (SSDS) team's Sprint 2 goes live post of May 26, 2008 announces the second upgrade to SSDS servers were completed last week. Here's their list of new or improved features:

• Full text index and search
• Multiple B-Trees - this will allow us to deploy schemas as we move toward supporting schemas in SSDS
• Asynch queries - this will help in exposing fanout queries across multiple containers
• Logging and tracing improvements to help us manage and debug the service efficiently
• Backup and restore services
• Improvements to our Distributed Data Fabric for failover and friendly swapping between primary and secondary partitions

Hopefully, documentation for using the new features will appear quicker than that for SSDS v1.

Added: May 27, 2008

Steve Naughton Completes His Five-Part Permission Solution for ASP.NET Dynamic Data

UK Web developer Stephen Naughton has completed a five-part tutorial for adding role-based permissions to an ASP.NET Dynamic Data project on May 26, 2008:

Introduction - A DynamicData Attribute Based Permission Solution using User Roles.

Part 1 - Permissions Attribute (Metadata) Classes.

Part 2 - Sample Metadata for project.

Part 3 - The Helper Extension Methods.

Part 4 - Limit Tables shown on Default page and List, Edit & Details etc.

Part 5 - Generate Columns/Rows (using IAutoFieldGenerator)

Following are two earlier posts on Dynamic Data topics:

DynamicData - Limit the Filter Fields

DynamicData - Automatic Column Update

The ASP.NET Dynamic Data team's David Ebbo thanks Steve for his contribution in his Sample: Dynamic Data and attribute based permissions post of 5/7/2008.

Added: May 27, 2008, Updated: May 27, 2008

David Ebbo Explains How to Disambiguate ASP.NET Dynamic Data's PageRequestManagerServerErrorException JavaScript Error

ASP.NET Dynamic Data turns on AJAX partial rendering using an UpdatePanel by default, which substitutes PageRequestManagerServerErrorException errors for more informative messages. In his Dynamic Data, AJAX and JavaScript errors post of May 25, 2008, David explains how to turn off partial rendering (open the Site.master file (at the root of the app) and set EnablePartialRendering="false") so you can see the real error message.

Added: May 27, 2008

ADO.NET Entity Framework v2 Wish List Started in MSDN Forum

If you want to influence the feature list for the next version of the Entity Framework (EF), now's the time to add your request to the v2 Wish Lists - Add Yours Here thread that John Papa started in the ADO.NET Entity Framework and LINQ to Entities (Pre-release) forum. As of May 27, 2008 there were 13 replies in the thread.

Added: May 27, 2008

Diego Vega Explains How the EntityDataSource DataBinds Complex Types to ASP.NET Server Controls

Diego's EntityDataSource's flattening of complex type properties post of May 24, 2008 is an expansion of the answer he give Julie Lerman in response to her Re: DataBinding Complex Type properties question of the same date in the ADO.NET Entity Framework and LINQ to Entities (Pre-release) forum. This post is an expansion of Diego's earlier EntityDataSource: To wrap or not to wrap post of May 13, 2008.

In short, the EntityDataSource (EDS) flattens complex properties to enable two-way databinding to ASP.NET controls with Eval("Address.Street"), DataField = "Address.Street" and Bind("Address.Street") methods. An exception is one-way binding to ComboBoxes which requires an explicit projection with an alias, such as Select ContactID, Address.Street As Street.

Added: May 24, 2008

Francois Vanderseypen Explains Why He Didn't Use Entity Framework in his Sample Project

In his Linq To Sql or Entity Framework? post of May 24, 2008 Francois says he decided not to use Entity Framework for the Northwind Factory v2.1 sample project for the following reasons:

It seems Microsoft had the intention to ship the EF with VS2008 but a lack of time forced them to drop it and it’s now planned for SP1. Still even at this SP1-beta stage it’s somehow unacceptable that the multi-tiered solution, which should be there out of the box, is not present. Neither in L2S nor in the EF. It’s unacceptable for me in the sense that the whole world is now gravitating around multi-layered applications and any ORM or DAL system should enable this scenario (No out-of-the-box story!).

EF appears to me to be closer to a Microsoft multi-tiered implementation than LINQ to SQL because it serializes complete object graphs with the updated SP1 DataContractSerializer (DCS). Danny Simmons demonstrated the feasibility of a multi-tier EF with the Perseus project and its EntityBag. The question now is whether Danny intends to rearchitect Perseus with DCS or stick with EntityBag.

Added: May 24, 2008

Dinesh Kulkarni on Object Tracking and LINQ to SQL DataContext Lifetime

Dinesh explains that LINQ to SQL's object (instance) tracking feature is intended to prevent entities returned by successive queries from "stomping" on cached entity values. In his LINQ to SQL Tips 6: How to refresh given DataContext won't stomp on your objects post of May 23, 2008, Dinesh notes that you can overwrite the current values of one or more specified entities with the DataContext.Refresh method. However, he cautions that "the changes in the database for a given query can be:

1. Newly inserted objects
2. Updates of existing objects
3. Deleted objects that were present in a previous execution of the same query

Issuing the same query with the same DataContext takes care of the first. Refresh() can handle #2. But #3 requires a little more thought and computation. You could certainly use another DataContext to compare results."

The issue resolves to selecting the appropriate DataContext lifetime, as recommended in his Lifetime of a LINQ to SQL DataContext post of April 27, 2008. If your application is stateful, consider separate DataContexts for online transaction processing (OLTP) and reference data. Dinesh's recommendations also apply to projects that use the Entity Framework.

Added: May 24, 2008

Rob Conery Completes MVC Storefront Parts 11 and 12 with Moq and Jimmy Bogard Proposes an nHibernate Fork 

Rob's MVC Storefront, Part 11: Hooking Up The Shopping Cart And Components and MVC Storefront, Part 12: Mocking of May 23, 2008 continue the MVC Storefront saga. Part 12 uses Moq (a.k.a. LINQ for Mocks) to mock the repository's authentication data (Email, UserID, and Password).

Rob acknowledges in Part 12 Jimmy Bogard's proposal in The MVC Storefront Challenge! post of May 20, 2008 to fork the code with nHibernate replacing LINQ to SQL. The comments include responses from several potential volunteers to help with the coding.

Added: May 24, 2008

Test Google Sites LINQ and Entity Framework Wiki Started

I needed a place to catalog links to LINQ and Entity Framework resources, such as magazine articles, online help pages, and blog posts, that aren't date-sensitive. Google Sites opened as a free service to the public this week, so I set up a LINQ-EF site with pages of "announcements" for LINQ and EF-related topics. The LINQ-EF site isn't meant to compete with Troy Magennis's Hooked on LINQ Wiki; it doesn't include any original content.

Google Sites is based on the JotSpot model but with many advanced JotSpot features missing. (Google acquired JotSpot in late October 2006.) It's simple to set up and navigate, and it substitutes an HTML editor for the arcane markup used by many wikis. It doesn't yet integrate with other Google Apps. It's certainly not the "SharePoint" killer that some bloggers claim, but it's probably good enough for my current needs.

Added: May 24, 2008

Dates, Times and Codes Added to Most Tech*Ed LINQ and Entity Framework Sessions

The LINQ and Entity Framework Breakout and TLC Sessions at Tech*Ed Developers 2008 post was updated May 23, 2008 to include date, time and code data from the ADO.NET Team's Going to TechEd? Drop by and say Hi! blog of the same date.

Apparently, only Tech*Ed 2008 Developer attendees have access to this added data.

Added: May 24, 2008

Has LINQ to SQL Reached Legacy Status Less than Three Months after Launch?

LINQ to SQL was the only new data-access implementation to be included in Visual Studio 2008 when it "launched" with SQL Server 2008 and Windows Server 2008 in a series of "Heroes Happen Here" extravaganzas that started on February 27, 2008.

Judging from my Is the ADO.NET Team Abandoning LINQ to SQL? post of May 21, 2008, Microsoft appears to have ceased further development of LINQ to SQL, based on the lack of new and promised features in the LINQ to SQL SP1 Beta.

Repeated from: LINQ and Entity Framework Posts for 5/19/2008+

Updated 5/23/2008 with a response to a comment from Andres Aguiar and Julie Lerman's Damien Guard joins the LINQ to SQL team as a developer post of the same date.

Quick Links to VS 2008 SP1 Beta Docs

My VS 2008 and .NET Framework 3.5 SP1 Beta Documentation and Forum Links of May 22, 2008 has links to LINQ, Entity Framework and related topics in the unsearchable (and unindexed) MSDN Library.

Marcin Dobosz on Customizing ASP.NET Dynamic Data Validation Metadata

Marcin's Dynamic Data samples: Custom metadata providers post of May 23, 2008 explains how to "programmatically add [data validation] metadata attributes to an in-memory store before you register your model with the Dynamic Data runtime in Global.asax." This sample replaces the XML-based metadata provider for the December 2007 CTP.

His earlier Dynamic Data samples post contains a list of the current and forthcoming ASP.NET Dynamic Data samples. (I added a "Where's the beef?" comment to this post.)

A Solution for the KB944899 Problem When Attempting to Install VS 2008 SP1 Beta

Wally McClure found the Visual Studio 2008 Hotfix Cleanup Utility on the MSDN Code Gallery. This small *.exe file removes KB944899, if present, and removes the registry keys that cause the problem.

Matt Manela Explains LINQ to SQL's Optimistic Concurrency Management Features

In his Intro to LINQ to SQL Optimistic Concurrency post of May 22, 2008, Matt explains the significance of the UpdateCheck.Always, UpdateCheck.Never, and UpdateCheck.WhenChanged properties when managing updates with optimistic concurrency conflicts.

Scott Allen Analyzes Rob Conery's Problems with LINQ to SQL Lazy Loading

Scott left a comment to my "Rob Conery Runs into a LINQ to SQL Corner with his Repository Model" topic of LINQ and Entity Framework Posts for 5/19/2008+ that Rob's conclusion it was LINQ to SQL's fault: "I'd say that requires more investigation. Doesn't sound correct."

His Rob's Not So Lazy MVC Storefront post of May 21, 2008 uncovers the real culprit, a type conversion of the IList<Product> property.

Kevin Lewis Rewrites His UPS Webservice Rate Calculator with LINQ to XML and VB Literals

His LINQ to UPS to Calculate Shipping Rates post of May 22, 2008 contains the full source code for his updated GetShippingMethodsFromWeb function.

Samir Bajaj Demonstrates How to Use LINQ to SQL with Table per Type Inheritance

From the How Did I Miss That? department: Back on April 2, 2008, Samir posted TPT with LINQ to SQL on his MSDN blog that I wasn't tracking at the time. He discusses the three common mapping strategies for object hierarchies: Table per Hierarchy (TPH), Type per Type (TPT) and Table per Concrete Type (TPCT). LINQ to SQL has out-of-the-box support for TPH only. But Samir demonstrates that you can map a TPT hierarchy "using the built-in TPH support and a bit of T-SQL code."

The sample code is available here: TPT with LINQ to SQL.

Marco De Sanctis Asserts That It's Not Always a Wise Choice to Eager-Load Associated Entities in LINQ to SQL Projects

Most developers using LINQ to SQL as the data layer eager-load associated entities to minimize round trips to the database. In When Lazy Loading associations is useful of May 22, 2008, Marco describes two scenarios where lazy loading may be beneficial.

Marco De Sanctis Wraps LINQ to SQL's Data Context in a Generic Unit of Work Instance for Caching by ASP.NET

His Linq To Sql in real word Web applications post of May 20, 2008 shows you how to wrap LINQ to SQL's Data Context in a generic Unit of Work instance to emulate nHibernate's SessionPerConversation pattern. His post includes a link to download the sample code.

Technorati tags: LINQ to SQL, LINQ, LINQ to XML, VB 9.0, Entity Framework, Entity Data Model, EntityDataSource, VS 2008 SP1 Beta, nHibernate, ASP.NET Dynamic Data, ASP.NET MVC, Moq, JotSpot, Google

Will Access 14 be a "Tool for the Web" or SharePoint Server Front End?

Julie Lerman turned me on to Dan Fernandez's Channel9 interview of Bill Gates at the Office Developer Conference (ODC) 2008. What caught my eye were Dan's comments about the next version of Microsoft Access gaining Web capabilities:

The other cool part is hearing Bill hint about how Access will now be a tool for the Web. Many a developer has cut his teeth building Access applications and seeing Access go beyond desktop applications is huge. [Italics added for emphasis.]

Microsoft made a previous attempt to make Access "a tool for the Web" with Data Access Pages (DAP). However very few DAP projects offered Internet connectivity because securing them was exceedingly complicated. Microsoft Office Access 2007 (a.k.a. Access 12) doesn't support creating or even editing DAP.

I cut my Windows database development teeth building Access applications, and writing Using Microsoft Access [1.0] for Windows and 10 successive editions got me into the computer book authoring business in earnest. I was surprised to hear that the next version of Access (14.0, there won't be an Office 13) would be Web-enabled because the preceding attempt failed. So I transcribed BillG's comments on Access, which start at about 06:00 into the 11:42 interview:

Access, of course, has been phenomenally successful, but you think of it as just client forms and client data. Now [with Access] 2007, they did a great job where you could replicate from SharePoint down to Access lists back and forth, but that still didn't let you run your logic up on the server. So the next step is to take that base of Access users and literally let them write things that connect directly up to SharePoint and so it's server-based. So it's a logical step for Access. There's a lot of smart people working on that, so in no sense are we leaving the Access people behind. The same way we moved Excel up to the server, now we're moving Access up there as well.

There's not a single mention of the Web in the Access segment. Bill's comments were all about SharePoint. What's more, Access already has a free server; it's called SQL Server 2005 [Express Edition] or its predecessors, MSDE 1.0 and 2.0. If Access has a server, what constitutes "moving Access up there as well?"

Mene Mene Tekel Upharsin: Excel Services Beget Access Services

Access 12 currently enables importing, exporting, and moving Access tables from traditional .mdb and new .accdb files to or from SharePoint lists. The .accdb format was created expressly to support SharePoint's multi-select lists. You can store Access front ends in SharePoint document libraries, but opening them requires a licensed copy of Access 12 on the desktop. SharePoint has an Access DataSheet ActiveX control that's only accessible if the user has a license for a recent Access version.

An abandoned Excel Blog entry describes Excel Services as follows (slightly paraphrased):

Excel Services is brand new server technology that will ship with Office 12. Excel Services supports loading, calculating, and rendering Excel spreadsheets on servers. There are two primary interfaces: a web-based UI that lets you view spreadsheets in the browser, and a web services interface for programmatic access.

So what happens, exactly, to get the spreadsheet in the browser?  Behind the scenes, Excel Services opens the file the sales analyst saved to SharePoint, refreshes any external data in the spreadsheet, calculates any formulas, and renders the results in the browser. Specifically, Excel services sends only DHTML to the browser (no ActiveX), so the sales manager can be using any modern browser. The result is a very high-fidelity version of the analysis that the sales manager can interact with in the browser or, if they have permissions to do so, open up back in Excel. Excel 12 is the authoring tool for spreadsheets that run on Excel Services.

Note: SharePoint Server 2007's Creating Custom Solutions with Excel Services topic offers more up-to-date and detailed information about Excel Services.

Access 14 might become a "tool for the Web" (or at least intranets) by abandoning any pretense of remaining a desktop relational database management system (RDBMS), and becoming a list management query and reporting tool for SharePoint. This implies a set of Access Services running on the next version of Microsoft Office SharePoint Server (MOSS).

The Access Services might parallel Excel Services:

Access Web Services based on the SharePoint Lists Web Service or, less likely, a dedicated SOAP API similar to Excel Web Services.

Access Web Access provided by a simple forms engine, perhaps derived from the existing InfoPath forms engine, which renders customized forms and a DHTML version of the Access DataSheet control in a browser. Excel Services doesn't support VBA so Access Web Access might embargo VBA, too.

Access Query Services based on LINQ to Access (or the like), corresponding to Excel Calculation Services and modeled on Bart De Smet's LINQ to SharePoint project. SharePoint isn't an RDBMS, so support for SQL is superfluous.

Access User-Defined Functions for queries, roughly corresponding to Excel User Defined Functions, provided by the long-awaited Access application add-in for Visual Studio Tools for Office (VSTO).

Update 2/13/2008: InfoWorld's James Niccolai writes in his "'Office 14' to be more Web-friendly, Gates says" article of February 11 from ODC 2008:

Microsoft envisions the next version of Office [will] have partial online functionality similar to how Outlook Web Access works. ... "As we look at all the modules [in Office 14], we have in mind the equivalent of Outlook Web Access," Gates said. ...

It will take another step in that direction with Office 14 by offering Outlook Web Access equivalents of other Office applications such as Excel. "If you look at spreadsheets, maybe you'll not be able to set up all the data models [online], but you'll be able to read documents, change a few assumptions, and try things out," Gates said. ...

Gates did say that SharePoint Server, which is becoming more closely aligned with Office, "will be able to render a greater set of Office documents in an HTML environment."

A Pricey Transition to Access as a "Web Tool"

Web (Internet) access would require a MOSS for Internet Sites license (estimated price $40,943 for MOSS 2007) in addition to a MOSS Server License (est. $4,424 plus $94/user CAL for MOSs 2007) for non-public content.

Bloomberg's "Microsoft's SharePoint Exceeds $800 Million in Sales (Update2)" article reported that SharePoint grew faster than any other piece of software in company history, according to former Business Division President Jeff Raikes at the Microsoft Financial Analysts meeting on July 26, 2007. Microsoft said it has sold more than 85 million licenses to 17,000 customers.

According to eWeek's "Ballmer Details Ways Yahoo Deal Would Challenge Google" article of Feburary 4, 2008 by Clint Boulton:

Ballmer assured analysts that Microsoft is a provider of hosted software plus services for the Internet age.

He said that while people associate online advertising with the cloud computing trend that Google, Salesforce.com and other smaller vendors are leveraging, Microsoft plans to make all of its products available in the cloud as a SAAS (software-as-a-service). That includes the Windows operating system and major money-making products such as Office, in addition to the ad-driven Windows Live suite. [Emphasis added.]

"Each and every one of these businesses on top of a consistent cloud platform transitions to have additional revenue and profit opportunities based on this transformation to the cloud," Ballmer said.

A $40,943 per server price for enabling Access to become a Web tool certainly qualifies as a "revenue and profit opportunit[y]" for Microsoft but doesn't bode well for a "developer [who] has cut his teeth building Access applications" and wants to continue doing the same. This is especially the case when you consider that the runtime version of Access 2007 is a free download.

Update 2/13/2008: Mary Jo Foley's Office 14 to add more online document sharing article of February 13, 2008 sheds additional light on Office 14's "webification."

Update 2/14/2008: CIO Magazine's SharePoint 2007 Demystified: How to Cash in on Collaboration Tools article offers a relatively unbiased review of MOSS for enterprise use. However Sahil Malik contests the article's "Beware Microsoft Baggage" section; see his CIO Magazine - Journalistic ethics? post of this date.

Technorati tags: Microsoft Access, Microsoft Access 2007, Access 14, SharePoint, Microsoft SharePoint Services, MOSS, MOSS 2007, LINQ to SharePoint, LINQ, Cloud Computing

LINQ and Entity Framework Posts for 1/21/2008+

Mike Tulty Produces Three More ADO.NET Data Services Video Clips

His ADO.NET Data Services - Screecasts of January 25, 2008 has links to

• ADO.NET Data Services - Querying with LINQ
• ADO.NET Data Services - Query Interceptors
• ADO.NET Data Services - Service Operations

which supplement these

• ADO.NET Data Services - Surfacing Data
• ADO.NET Data Services - Querying with URI's
• ADO.NET Data Services - A Basic .NET Client
• ADO.NET Data Services - A Basic AJAX Client
• ADO.NET Data Services - A Basic Silverlight Client

produced in mid-January.

Added: January 25, 2008

Julie Lerman Implements EntityBag in a Visual Basic Service and Client

Julie's Creating and consuming a WCF service to test the EntityBag class post of January 25, 2007 includes details for employing Danny Simmons' EntityBag code in a VB WCF service and client. She warns that it's necessary to decorate your interface's ServiceOperation functions with <ServiceKnownType(GetType(EntityType))> for serialization to work correctly.

By default WCF implements WS-* security with wsHttpBinding, which greatly increases SOAP message overhead, as Julie notes in her Testing out the EntityBag post of January 24, 2008. You can use the WCF Service Configuration Editor to change the service to basicHttpBinding, which defaults to clear text messages.

Suggestion: I believe it would behoove the ADO.NET Team to provide a simple reference project with a self-hosted service based on Northwind or AdventureWorksLT using the basicHttpBinding. This would save everyone that downloads the Perseus classes a substantial amount of time and guesswork on implementation details.

Added: January 25, 2008

Diego Vega: ADO.NET Team Starts Entity Framework Portal on the MSDN Code Gallery Site

Diego's Welcome to the Entity Framework Toolkits & Extensions post of January 25, 2007 announces the creation of the ADO.NET Entity Framework & LINQ to Relational Data Portal on the MSDN Code Gallery. The gallery is a CodePlex implementation that's customized for contributions from Microsoft teams. Content is distributed under the Microsoft Public License (Ms-PL) unless otherwise noted.

The first toolkit and extension are:

• eSqlBlast is Zlatko Michailov's interactive Entity SQL tool and supporting libraries.
• Perseus is Danny Simmons' set of EntityBag and related classes for WCF services (see EntityBag topics below).

The first sample is:

• Sample EDMX Code Generator is an Asad Khan's EDMX code generation demonstration project (see topic below)

Update 1 January 26, 2008: Sanjay's SampleEdmxCodeGenerator sources post provides instructions for using the SampleEdmxCodeGenerator.

Questions: Will EFx become the official abbreviation for Entity Framework and LINQ to Entities be renamed LINQ to Relational Data? I doubt it.

Update 2 January 26, 2008: Diego says in two comments that Asad Khan didn't write the EDMX code generator (but didn't say who wrote it) and that LINQ to Relational Data is a generic term for LINQ implementations for relational data (i.e., LINQ to SQL and LINQ to Entities at the moment).

Added: January 25, 2008

Sanjay Nagamangalam Describes How the ADO.NET Entity Designer Handles CodeGen

Sanjay's How does the ADO.NET Entity Designer generate code? of January 24, 2008 describes how the EntityModelCodeGenerator, which uses VS 2008's SingleFileGenerator extension mechanism, extracts the CSDL content from the EDMX file and generates code with the EntityClassGenerator.

His How to Extract CSDL from EDMX post of the same date shows you how to extract CSDL, MSL, or SSDL content from the EDMX file with LINQ to XML.

Update January 26, 2008: Sanjay's SampleEdmxCodeGenerator sources post provides instructions for using the SampleEdmxCodeGenerator.

Added: January 25, 2008

Danny Simmons Wraps Up His EntityBag Sextet with the RelationshipEntry Story

EntityBag Part VI – RelationshipEntry of January 24, 2008 is the final installment of Danny's six-part EntyBag Extravaganza. RelationshipEntry is a DataContract-serializable class with eight DataMember properties:

• RelationshipName
• State
• Role1
• Key1
• AddedEntityIndex1
• AddedEntityIndex2

and two non-serializable properties

• Entity1
• Entity2

Constructor, ResolveEntityAndKeys, and Methods topics explain how the class is used.

The three class files (EntityBag.cs, ContextSnapshot.cs, and RelationshipEntry.cs) and required extension methods (UtilityExtensionMethods.cs) are in the Perseus  Entity Framework Extension file that's described in the preceding "Diego Vega: ADO.NET Team Starts Entity Framework Portal on the MSDN Code Gallery Site" topic.

Added: January 25, 2008

Mike Taulty Minimizes LINQ to XML Code by Using the ReplaceWith() Method

Mike moves two nodes within a child node to its parent with three lines of LINQ to XML code in his Reparenting nodes in LINQ to XML of January 24, 2008.

The more I work with LINQ to XML, the better I like it (despite some reservations about namespace issues I discussed in Namespace Strangenesses in XML Infosets Transformed by LINQ to XML.)

The Pfx Team: Parallelizing LINQ Aggregate Queries with PLINQ

The Parallel Programming with .NET blog's Parallel Aggregations in PLINQ post of January 24, 2008 begins by describing how the Aggregate Standard Query Operator works, then discusses the general topic of parallel LINQ aggregation semantics, and identity issues that can cause the results of parallel and sequential aggregation to differ.

More EntityBag Details Exposed: The ContextSnapshot Object

Danny Simmons' EntityBag Part IV – ContextSnapshot Fields and Properties post of January 22, 2008 and EntityBag Part V – ContexSnapshot Constructing and Applying of January 23 cover the ContextSnapshot that's serialized across the wire. Topics include:

• The DataMembers and Other Fields: unchangedEntities, modifiedOriginalEntities, modifiedEntities, deletedEntities, addedEntities, addedRelationships, deletedRelationships and unchangedManyToManyRelationships.
• Public Properties and Related Methods: ConnectionString, Dictionary<EntityKey, int> AddedEntityKeyToIndex and IEntityWithKey GetAddedEntity(int addedEntityIndex)
• Constructors: ContextSnapshot(ObjectContext context) for the service and ContextSnapshot(ObjectContext context, string connectionString) for the client with a cleared connection string
• ApplyToContext(ObjectContext context) method: Attaches unchangedEntities, modifiedOriginalEntities and modifiedEntities, adds addedEntities and addedRelationships, deletes deletedEntities and deletedRelationships, and finally attaches unchangedManyToManyRelationships

The ContextSnapshot corresponds to the ephemeral "mini connectionless DataContext" for LINQ to SQL's erstwhile "n-tier story."

Danny's three posts that precede this are:

• EntityBag Part I – Goals - 1/20/2008
• EntityBag Part II – Modes and Constructor - 1/21/2008
• EntityBag Part III – Public Surface and Serialization -1/21/2008

Following are links to a few of Danny's other related posts (in reverse chronological order):

• Did you know that connection string builders will parse connection strings not just create them?
• Filtered association loading and re-creating an entity graph across a web service boundary...
• So they're hard, but what if I need them... ("them" being data-centric Web services)
• Why are data-centric web services so hard anyway?

Added: 1/23/2008

Namespace Strangenesses in XML Infosets Transformed by LINQ to XML

I was working with an Atom 1.0 document returned from an ADO.NET Data Service based on Northwind (what else?) when I ran across two anomalies in how LINQ to XML handles namespaces when composing XML Infosets with VB's literal XML or C#'s functional construction syntax.

VB MVP Bill McCarthy led me to an (apparently undocumented) workaround for a spurious xmlns="" namespace declaration, but I still haven't found the answer to preventing namespace declaration duplication with literal XML composition.

Read more about the issues here.

Added: 1/23/2008

Julie Lerman: Those Who Forget the LinqDataSource Are Bound To Repeat Its Problems in the EntityDataSource

Julie Lerman recounts the problems that she's encountered with the LinqDataSource for LINQ to SQL, especially with lack of updatability when you specify a projection and return an anonymous type, and hopes they won't be repeated in the forthcoming EntityDataSource.

She also points out an anomalous exception when editing with Entity.Property/EntityReference pairs in combo boxes with StoreOriginalValuesInViewState set to True.

I'm not sanguine that the ADO.NET team can overcome these EntityDataSource hurdles by RTM.

Julie observes that the EntityDataSource "has been mentioned in the forums." Danny Simmons said:

While the LINQDataSource will not work with LINQ to Entities, we are working on an Entity Data Source which we expect to ship in v1 of the EF.

in answer to Blinky Bill's Informal List of Limitations entry of 1/3/2008 that spelled out some of the more serious issues with Entity Framework Beta 3. His complaints—together with Danny's replies—are well worth reading.

Here's Danny's same-day response regarding the ObjectContext's lack of serializability:

I would argue that making the ObjectStateManager serializable introduces significant issues long-term for n-tiered stacks.  If it were serializable certain things would be easier, but it's somewhat like shooting yourself in the foot if you are building any kind of large-scale SOA system.  You might take a look at my blog post: http://blogs.msdn.com/dsimmons/archive/2007/12/20/why-are-data-centric-web-services-so-hard-anyway.aspx That said, making n-tiered stacks easier to create is certainly an important topic we are giving a lot of thought to.

It's an interesting response in the light of Danny's current work on the EntityBag, no?

(My apologies to philosopher George Santayana,whose "Those who cannot remember the past are condemned to repeat it" warning comes from Reason in Common Sense, the first volume of his The Life of Reason quintet.)

Alexander Nowak Solves Missing Entity Framework Files Problem with Unit Testing

Belgian developer Alexander Nowak's Unit testing ADO Entity Framework post of January 22, 2008 describes how he encountered "The specified metadata path is not valid" exceptions when attempting to unit test a sample Entity Framework Beta 3 project. The problem is related to issues with the design-time .edmx file and missing .ssdl, .msl, and .csdl from the specified MSTest folder that holds copies of the assembly and app.config or web.config files.

Alexander shows you how use the VS test environment's Deployment feature of the Rosario November 2007 CTP to add the missing metadata files to the appropriate MSTest folder.

Embedding the three metadata files in the assembly by the process Julie Lerman describes in her Embedding EDM schema files in Entity Framework Beta 3 post of December 14, 2007, should also solve the problem. Here's a brief excerpt from her detailed article on the topic.

Open the EDMX file in the design window and then you will see a new property in the property window called Metadata Artifact Processing. The default of this is "Copy to Output".

To get around a current known bug, build the project with the property set to "Copy to Output". Then change the Metadata Artifact Processing property to "Embed in Output Assembly". Eventually you won't need to build with Copy to Output first.

EntityBag Details Exposed: Modes, Constructor, Public Surface and Serialization

Danny Simmons' EntityBag Part II – Modes and Constructor and EntityBag Part III – Public Surface and Serialization posts of January 21, 2008 describe the EntityBag class's enum, objects, factory class and methods:

1. Mode Enum: Constructed -> Deserialized -> LocalContext -> Unwrapped
2. Root Object: A single public property over which to create a private ObjectContext
3. CreateEntityBag<T>(context, root) factory class for data retrieval
4. OnSerializing(streamingContext) method: if Constructed mode, create ContextSnapshot from persisted entities; if LocalContext mode, create ContextSnapshot from changes to original ContextSnapshot
5. UnwrapInto<T>(context) method: for create, update, delete operations

In answer to a comment about EntityBag Part I – Goals of January 20, 2008, Danny says:

The EF won't have something like this built-in for v1, but we are looking hard at the topic for future releases.  I'm not 100% certain we'll do this, since there are some serious issues when it comes to interoperability, etc. (as I've noted).  I believe we made some major mistakes with the DataSet in this regard, and I don't want to repeat them.

Marcelo Lopez Ruiz Explains How to Use Service Operations with ADO.NET Data Services

Marcelo's Service Operations in ADO.NET Data Services post of January 21, 2008 explains how to set up ADO.NET Data Services with the RESTful equivalent of Web methods—Windows Communication Foundation (WCF) service operations that expose custom methods decorated with the [WebGet] attribute. The functions return an IQueryable<Model.Entity> or IEnumerable<Model.Entity> type, where Model is the name of the underlying Entity Data Model and Entity is the entity name, such as Customer[s].

Setting up service operations with custom WebGet methods lets you easily restrict particular users or groups to specific retrieval operations against your data services.

The following WebDataService's CustomersInLondon() method returns an IQueryable<Model.Customer> to enumerate all Northwind Customers in London from this URL: http://localhost/WebDataService1.svc/CustomersInLondon.

public class WebDataService1 : WebDataService< Model.Entities >
{
    public static void InitializeService(IWebDataServiceConfiguration config)
    {
        config.SetResourceContainerAccessRule("Customers", ResourceContainerRights.AllRead);
        config.SetServiceOperationAccessRule("CustomersInLondon", ServiceOperationRights.All);
    }
    
    [WebGet]
    public IQueryable<Model.Customers> CustomersInLondon()
    {
        return from c in this.CurrentDataSource.Customers
               where c.City == "London"
               select c;
    }  
}

The IQueryable<T> is composable, so you can filter the result with a URL, such as: http://localhost/WebDataService1.svc/CustomersInLondon('AROUT')/Orders. If you want to prevent users from modifying the query, change IQueryable<Model.Customers> to IEnumerable<Model.Customers>.

Marcelo also explains how substituting [WebInvoke] for [WebGet] lets you pass parameters in the request body instead of the URL, [SingleResult] indicates that only a single instance is returned, and [MimeTypeAttribute] applies a particular MIME type, such as text/html, to the returned element(s).

Danny Simmons Describes a Serializable EntityBag for n-Tier Entity Framework Deployment

I'm glad to see the ADO.NET Entity Framework team taking the pragmatic approach to Web service-enabling v1.0 with the serializable EntiyBag that Danny describes in his EntityBag Part I – Goals post of January 20, 2008.

For my take on Danny's answer to the LINQ to SQL Team's apparently-abandoned serializable "mini-connectionless DataContext" read Coming to the Entity Framework: A Serializable EntityBag for n-Tier Deployment, which ran too long for inclusion in this post.

[Repeated from the previous week's post.]

Jim Wooley's ThinqLinq Site is Live and LINQ In Action Has Gone to the Printer

Over the weekend Jim's new LINQ-powered ThinqLinq blog and site added new content and Manning Publications Co. sent LINQ in Action by Fabrice Marguerie, Steve Eichert and Jim Wooley to the printer. Copies should be in bookstores and Amazon.com by mid-February.

Congratulations to Fabrice, Steve and Jim and best wishes for the book's success!

I have all the LINQ books currently published, including the eBook version of LINQ in Action and I agree with Sam Gentile comment in his post of January 22, 2008:

My best of friends, Steve Eichert, along with  Fabrice, Jim, has shipped their LINQ in Action. I can tell you that I have the LINQ books, and this is by far the best.

Take Advantage of the LinqDataSource's GroupBy and OrderGrouopBy Features with Nested ListView Controls

Matt Berseth's Building a Grouping Grid with the ASP.NET 3.5 LinqDataSource and ListView Controls post of January 10, 2008 shows you how to create an expandable master/child ListView presentation that doesn't require a postback for expanding or collapsing. The preceding link is to a live demo and the source code is available to download.

Matt's earlier Creating a FrequencyDecoder.com Style Grid with the ListView, DataPager and LinqDataSource Controls post shows you how to create a soothingly attractive, customized pastel grid with a single ListView control.

Added 1/23/2008: Missed in previous linkblog post.

Technorati Tags: Entity Framework,Entity Data Model,EntityBag,Serialization,Windows Communication Foundation,WCF,LINQ to Entities,LINQ,ADO.NET Data Services,Project Astoria,Service Operations,WebGet,WebInvoke,Web Services,LINQ in Action,Unit Testing,EntityDataSource,LinqDataSource,ListView,ListView Control,PLINQ,Parallel FX

Coming to the Entity Framework: A Serializable EntityBag for n-Tier Deployment

Danny Simmons explained in his earlier Why are data-centric web services so hard anyway? and So they're hard, but what if I need them... posts of December 20, 2007 that serializing object graphs with associations isn't a walk in the park. The LINQ to SQL team abandoned their efforts to create a serializable "mini connectionless DataContext," which led to Dinesh Kulkarni's LINQ to SQL Has No "Out-of-the-Box Multi-Tier Story" admission on October 15, 2007.

Updated 1/21/2008 and 1/22/2008: Additions/clarifications in [].

Part of the LINQ to SQL team's problem was the desire for Web service interoperability, which (in my opinion, at least) isn't in the cards for object/relational management (O/RM) tools. This observation is especially true for those O/RMs that support [value-based rather than timestamp] change tracking [that's independent of the domain's business objects.]

So I'm glad to see Danny taking the pragmatic approach to Web-service enabling the Entity Framework, as described in his EntityBag Part I – Goals article of January 20, 2008. He says the following about service interoperabilty:

While I like the simplicity of [EntityBag] interaction, it is super important to keep in mind the restrictions imposed by this approach. First off, there’s the fact that this requires us to run .Net and the EF on the client—in fact it requires that the code for your object model be available on the client, so it is certainly not interoperable with Java or something like that.

If interoperabilty is the Holy Grail of Web services, why do typed DataSets remain one of the most common objects serialized by .NET Web services? According to Scott Hanselman, Returning DataSets from WebServices is the Spawn of Satan and Represents All That Is Truly Evil in the World. (Scott posted this diatribe on June 1, 2004, three years before he joined Microsoft in July 2007.) An obvious answer is "because you can."

Another issue is lack of adherence to (or support for) the Web service contract's terms and conditions:

Secondly, because we are sending back and forth the entire ObjectContext, the interface of the web methods imposes no real contract on the kind of data that will travel over the wire. The retrieval method in our example is called GetRoomAndExits, but there’s absolutely no guarantee that the method might not return additional data or even that it will return a room and exits at all. This is even scarier for the update method where the client sends back an EntityBag which can contain any arbitrary set of changes and they are just blindly persisted to the database.

The lack of a service contract or its enforcement doesn't appear to deter the crowd supporting RESTful Web services, including ADO.NET Data Services.

To qualify as an enterprise-level O/RM tool, the Entity Framework must provide out-of-the-box n-tier support for WCF Web services and remoting, even if it's an add-in to v1.0. Save interoperability and contract concerns for v.2.0+.

I look forward to the promised "future posts" in which "we can dig into the implementation of EntityBag."

Backstory: I discussed problems with serializing object graphs that contain cyclic references created by combinations of EntitySet and EntityRef(erence) associations in my Controlling the Depth and Order of EntitySets for 1:Many Associations post of December 20, 2007 (updated 12/23/2007), Serializing Object Graphs Without and With References of November 21, 2007 (updated 12/12/2007), and Serializing Cyclic LINQ to SQL References with WCF of October 30, 2007).

Update 1/21/2008: Frans Bouma's comment of 1/21/2008 takes Microsoft and me to task: Microsoft for not incorporating change data in the business object itself and me for not being precise regarding the difficulty of managing value-based concurrency conflicts without changing the business object's structure. Both the Entity Framework (EF) and LINQ to SQL minimize encroaching on "persistence ignorance" and plain old CLR objects (POCO). See Danny's EF Persistence Ignorance Recap of September 26, 2007 and my Persistence Ignorance Is Bliss, but Is It Missing from the Entity Framework? article of March 14, 2007 (updated 4/24/2007 and earlier).

Update 1/22/2008: In answer to a comment about EntityBag Part I – Goals of January 20, 2008, Danny says on the same day:

The EF won't have something like this built-in for v1, but we are looking hard at the topic for future releases.  I'm not 100% certain we'll do this, since there are some serious issues when it comes to interoperability, etc. (as I've noted).  I believe we made some major mistakes with the DataSet in this regard, and I don't want to repeat them.

Technorati Tags: Entity Framework,Entity Data Model,EDM,EntityBag,O/R Mapping,Object/Relational Mapping,Windows Communication Foundation,WCF,Web Services,Object Graphs,Cyclic Relationships,LINQ to Entities,LINQ