Click for IdeaBlade Home Page Build data-rich business applications



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.

Expand AllCollapse All

Business Objects and Persistence

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.

  • Full Entity Framework integration

    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

    Code First lets developers build their entity model classes without struggling with EDMX, visual designer, or database changes that put the model at risk.

  • Full LINQ: including subqueries, aggregation, and projections

    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.

  • Dynamic queries

    DevForce dynamic query building components help you build and execute LINQ queries on the fly based on information supplied at runtime.

  • Single domain model for multiple clients

    Develop and deploy a single back-end to support multiple front-end UIs.

    DevForce's shared domain model makes it easy to develop, test, and deploy applications across multiple client technologies. (Think Silverlight, WPF, iOS, Android, HTML/JavaScript, etc.)

    It also makes it easy to standardize your development environment onto a single framework that lets developers move seamlessly across projects.

  • Client-side caching

    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.

  • Disconnected and offline operation

    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.

  • Cross-platform support with OData
    (Open Data Protocol)

    DevForce can also expose business objects to other platforms using an OData service. OData is a REST service that has client libraries for most platforms, including iOS/Objective-C, Android/Java, Ruby, PHP, and JavaScript.

  • Paging

    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.

  • Include queries

    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.

  • Named 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.

  • Inheritance and polymorphic queries

    DevForce supports inheritance as well as polymorphic queries, letting you query for multiple subtypes with the same LINQ statement.

  • Validation engine

    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.

  • Property interception

    DevForce property interception provides a mechanism to intercept and either modify or extend the behavior of any property on a DevForce entity.

  • Entity lifecycle events

    DevForce provides several points along the entity lifecycle where developers can intercept queries and/or modify saves—both on the client and the server.

  • Dynamic live lists

    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.

  • Customizable T4 code generation templates

    Customize the DevForce code generation template when you need fine control over the entity class code generated for your Entity Data Model (EDM).

  • Plain Old CLR Object (POCO) support

    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.

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.

  • MVVM

    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.

  • Navigation

    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.

  • Declarative style

    "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.

  • Wired for UI

    Cocktail leverages the data binding, validation, and change notification capabilities built into the entities produced and managed with our core DevForce product.

  • Repositories

    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".

  • Modularity

    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.

Entity Server

The DevForce Entity Server mediates between client applications and server-side services. The Entity Server enables:

Data Center

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.

  • Clustering and load balancing

    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.

  • Distributed transactions

    When enabled DevForce will automatically escalate to Microsoft’s Distributed Transaction Coordinator for reliable transactions across multiple data sources.

  • Advanced authentication scenarios

    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.

  • Windows Azure

    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.

Why DevForce?
Success Story
Dan Hickman

DevForce Powers the U.S. Army

“If DevForce Silverlight didn't exist, I wouldn't have used Silverlight in this application.”

Dan Hickman
Read the full story ...

Industry Buzz
Adam Kinney,
Microsoft Channel 9

"My favorite feature of DevForce Silverlight is the ability to run LINQ statements from within the client without having to touch the server. In the rich client application world, this makes development a lot easier."
Dean Tessman,
Manager of Developement, MediSolution

"The ROI from DevForce has been significant. Overall, we estimate that DevForce has saved us many man months of development time and increased developer efficiency dramatically."

Copyright © 2004-2013 IdeaBlade