The Microsoft ADO.NET Entity Framework is quickly becoming the standard for database access in .NET applications. The Entity Framework enables developers to create data access applications by programming against a conceptual application model instead of programming directly against a relational storage schema. The goal is to decrease the amount of code and maintenance required for data-oriented applications.

The Entity Framework does a good job of handling relational database mapping and persistence operations for client / server applications. However, most business applications need better data management and better support for developing the business objects that encapsulate the relational data.

DevForce provides essential improvements in critical areas such as:

• Infrastructure for n-tier applications
  The Entity Framework only supports a 2-tier architecture in which the client machine speaks directly to a relational database server. DevForce implements an end-to-end, multi-tier (n-tier) architecture whose middle tier component is called the "Business Object Server" (BOS).
• Intermittently connected and offline apps
  Entity Framework applications are vulnerable to temporary connection failures. DevForce applications have the means to survive transient connectivity and to thrive offline.
• Security
  The Entity Framework has no intrinsic security features. Because of it two-tier approach, the security burden falls entirely on the network and the database. The DevForce n-tier solution supports a rich variety of standard and custom authentication techniques and provides encryption and authorization points on both client and server.
• Client application performance
  Data access is the number one performance killer. Large volumes of data are deadly. Frequent trips to the server are worse. The Entity Framework is a purely 2-tier architecture in which the client talks SQL to the database, a chatty conversation with few means to shrink the data. The Entity Framework doesn't remember previous queries, meaning developers cannot query its primitive entity cache and cannot query asynchronously. DevForce has a query-able entity cache and a query cache and offers asynchronous queries that can hide the actual cost of a remote query as perceived by the end user.
• Multiple data sources
  The Entity Framework supports just one database per Entity Data Model. But many applications draw from data stored in multiple data sources. In DevForce, you can define a single domain model that holds entities from multiple data sources and use navigation properties to move seamlessly between them. Saving back to these data sources is just as seamless as DevForce will encapsulate all of the changes into a single transaction if desired. If you have the "reverse" problem - a database that is too large, you can use DevForce to break up a large database into multiple smaller models/modules that are easier to maintain and deploy.
• Non-Relational Data Sources
  The Entity Framework can only map entities to relational databases. DevForce's POCO (Plain Old CLR Object) support allows any data source that can be exposed as an enumeration to be used as a data source, which enables developers to work with a uniform, consistent object mode, regardless of the backing store.

Check out the DevForce and the Entity Framework whitepaper for more details on how we extend the Entity Framework.

• DevForce Platform
• DevForce Universal
• DevForce Silverlight
• DevForce WinClient
• DevForce in Windows Azure
• Roadmap