N-tier data access. A single domain model. End-to-end development.
DevForce implements an end-to-end n-tier architecture. It works by exposing a generic web service on the server that takes a LINQ expression and returns business objects to the client over the internet.
You write LINQ queries on the client and you get back business objects with your custom business logic—just like working with a 2-tier or client-server application. DevForce handles all the n-tier WCF communications, serialization, and marshaling for you.
It’s that simple.
DevForce builds on the strengths of the Entity Framework, and then extends them with n-tier architecture, multiple data sources, non-relational data sources, and superior client application performance.
DevForce isn't just compatible with the Entity Framework, it extends the Entity Framework with numerous features like n-tier architecture, non-relational data sources, superior client application performance, and security.
Code First lets developers build their entity model classes without struggling with EDMX, visual designer, or database changes that put the model at risk.
DevForce LINQ is a comprehensive implementation with unique capabilities. It can execute synchronously and asynchronously, applies to remote data sources, local cache, or both simultaneously, works in 2-tier and n-tier modes, and can be composed statically or dynamically to accommodate user-defined query criteria that can only be known at runtime.
The range and power of DevForce LINQ may best be appreciated by taking a tour of the Entity Framework's 101 LINQ Samples. Every sample works in DevForce: 2-tier, n-tier, sent to the database, or applied to the local cache.
DevForce dynamic query building components help you build and execute LINQ queries on the fly based on information supplied at runtime.
Develop and deploy a single back-end to support multiple front-end UIs.
It also makes it easy to standardize your development environment onto a single framework that lets developers move seamlessly across projects.
The DevForce Entity Manager maintains two caches that are used to dramatically improve performance: An entity cache that contains every entity that gets added to an Entity Manager and a query cache that contains every query that has been processed against a backend datastore.
DevForce’s client-side cache enables applications to operate in a partially connected or fully disconnected environment.
You can query, modify, and even create new entities while offline , and you can save the cache to the file system to preserve the state of the entities if the application or computer needs to be shut down.
DevForce has an EntityQueryPager which is an integrated paging engine that can fetch pages from a combined view of the server-side datasource plus the client-side cache.
It can operate either synchronously or asynchronously, and can be used in both WinClient and Silverlight applications.
Make your application more responsive for your customers by fetching the data they need now—and the data they're going to need next—all at once with include queries.
A named query is a server-defined query that makes it easy to consolidate the logic to authorize, restrict, or modify a query into a single method.
DevForce supports inheritance as well as polymorphic queries , letting you query for multiple subtypes with the same LINQ statement.
The validation infrastructure provided by DevForce is made up of a collection of interoperating validation components that are both easy to use and capable of handling sophisticated scenarios like cross-field, cross object, and dynamic validation.
DevForce property interception provides a mechanism to intercept and either modify or extend the behavior of any property on a DevForce entity.
Provide live-list management capabilities to any list containing DevForce entities. Membership to the list is kept continuously updated based on changes to entities in an Entity Manager's entity cache.
Customize the DevForce code generation template when you need fine control over the entity class code generated for your Entity Data Model (EDM).
DevForce supports POCO. If the objects have an identified (primary) key value, they will operate fully as first-class citizens in the DevForce local cache.
Whether you prefer a Database First, Model First, or Code First development style, ultimately your model will be wired to data. DevForce's database features will improve your productivity … and your applications performance.
DevForce supports all ADO.NET data providers that work with the Entity Framework.
DevForce supports querying for entities using stored procedure queries and will requery entities after executing triggers.
If you have special logic needed to generate IDs, you can accomplish this with the DevForce IIdGenerator interface. You can even generate IDs while offline and DevForce will remap them and fix all foreign key references when saved.
DevForce supports Entity SQL (ESQL) queries with its PassthruEsqlQuery() class.
Connect to multiple databases/entity models simultaneously with DevForce. You can use a separate Entity manager for each model or use the same Entity Manager for multiple models. DevForce also provides transactional integrity when saving entities to two or more data sources.
The DevForce Entity Server mediates between client applications and server-side services. The Entity Server enables:
In an n-tier DevForce application, the client tier communicates with an Entity Server on a separate application server tier, and the application server in turn communicates with the data tier.
DevForce handles all the essential WCF configurations for you automatically. DevForce figures out what you need by interpreting your application solution structure in combination with artifacts added by DevForce Visual Studio project templates. Configuration for deployment can be as simple as identifying the server address.
The most typical, and most robust, deployment of the Entity Server is with Internet Information Services (IIS).
Deploying the Entity Server as a Windows service is a good choice in intranet and trusted domain environments, especially if you're not familiar with IIS.
DevForce provides out-of-the-box integration withASP.NET security services.
DevForce dramatically reduces the amount of data that must be transported, because it compresses business objects by as much as a 10:1 compression ratio.
A remote server method is a server-side method that is defined and deployed in an assembly on the server. This type of method can return any serializable object and can be passed any serializable parameters.
DevForce supports both single tenant per database as well as multiple tenants per database SaaS hosting. Add query filters to the server to guarantee tenant isolation and to simplify client-side programming. Host multiple environments, in the same application server … and then load balance that server.
Available for DevForce Universal, the Data Center upgrade is required for all Azure and multi-instance deployments. It includes all the features of the standard business object server and adds enterprise-class scalability, high availability, and security for business-critical applications.
With the encryption key set, DevForce enables automatic session transfer from one machine to another, enabling any server in the cluster to serve any client. If any machine fails, another can pick up the load and the load balancing is more easily distributed evenly across multiple servers.
When enabled DevForce will automatically escalate to Microsoft’s Distributed Transaction Coordinator for reliable transactions across multiple data sources.
Our support team will help you configure deployments that have special authentication needs, such as authenticating against a Windows Domain Controller, forwarding an ASP.NET security token through a DMZ, etc.
Save money in the cloud. Windows Azure promises to reduce the costs and risks of managing the IT infrastructure that supports your application. DevForce reduces your Azure costs even more.