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.
The fastest trip to the server is no trip at all.
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.
End-to-end application platform
Cocktail takes the pain out of developing enterprise applications in Silverlight or WPF by leveraging established patterns and practices, such as MVVM, and building on DevForce’s rich data service capabilities.
We favor Model-View-ViewModel (MVVM) architectures for XAML-based applications. MVVM comes in a bewildering array of implementations. We’ve adopted Caliburn Micro’s because it is effective and productive for medium to large applications.
We use Caliburn Micro to navigate the vast network of screens that are typical of business applications allowing Cocktail to handle tracking, creation, revisiting, and closing of views as users meander among the screens in the course of multi-hour sessions.
"Write less!" is our mantra. Write less code and less XAML and there will be less to change, debug and test. Why write explicit switchboard code when Cocktail can infer your intentions? Cocktail can often wire your components together automatically when you adopt a declarative programming style and follow consistent naming conventions.
Cocktail leverages the data binding, validation, and change notification capabilities built into the entities produced and managed with our core DevForce product.
Cocktail applications delegate client-side data access to "Repository" or "Data Service" classes that shield Views and ViewModels from the details of querying and saving. Repositories encapsulate DevForce entity caches that can share data across views or isolate unsaved changes in "sandboxed editors".
Cocktail relies on Microsoft’s Managed Extensibility Framework (MEF) to discover and connect the independent parts of your application. The developer writes single-focused components that do one thing well; MEF injects the resources they need at runtime. Cocktail makes this "dependency injection" simple and fun.
Break large Silverlight applications into separate, light weight modules that are downloaded quickly, on-demand, to authorized users with Cocktail's XAP loader.
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 with ASP.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.
Download DevForce Express for FREE.
Ready to take the next step? Download DevForce Express and see how DevForce makes development easier.