DevForce Universal

Overview | Pricing & Licensing | Evals & Downloads | Compatibility | Publisher Details | Reviews | Support Forum | Summary

Our regular prices are shown below. Please logon to see your discounted prices.

DevForce Universal 2010 (V6.1.4) Enterprise

DevForce Universal 2010 (V6.1.4) Enterprise with Data Center Server

Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase.  All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed above including volume licensing and previous versions.

Our regular prices are shown above. Please logon to see your discounted prices.

New and improved product features in DevForce 2010 (V6.1.4)

• The .NET 4 Client Profile is now fully supported in 2-tier WinClient applications.
• The DevForce Silverlight project templates now support targeting either Silverlight 4 or 5.
• Added an EntityManager property to globally control lazy loading and asynchronicity.
• Deleted entities now support the IEditableObject interface. (This was needed for scenarios where some third party UI control would hold a reference to a deleted DevForce entity and would try to call IEditableObject methods on it.)
• DomainModelTemplate and DomainModelTemplateCodeFirst have been refactored to a new BaseDomainModelTemplate class. Both classes now inherit from it.
• Debugger attributes have been added to avoid excessive debugger breaks during Query inversion expression tree work.
• When Max. Classes Per File is set to 1, the generated designer class filename will default to "className.cs" eg: NorthwindIBEntities.cs, EntityRelations.cs, Customer.cs, etc.
• DevForce now provides support for "persistent" entity connections for the duration of a client session.
• Version of PostSharp included in the DevForce installation has been updated to 2.1.5.1.
• The former "BOS Web Application" project template was broken into standard and advanced templates, now called "DevForce Entity Server Web Application" and "DevForce Entity Server Web Application – Advanced".
• WinForms sample created.
• DevForce now automatically drops timed out user sessions based on a server based timer and the config file UserSessionTimeoutsettings.
• Unused ibmmx model metadata files in a project will now be removed.
• DevForce’s implementation of the INotifyCompleted interface now supports multiple callbacks with the WhenCompleted method. This means that each call to INotifyCompleted.WhenCompleted will add its own action to a delegate chain instead of completely replacing the prior action.
• EntityManager.FindEntityGraph performance when IsDeleted=false has been substantially improved.
• DevForce installation now includes BaseDomainModelTemplate.cs source code.
• [Code First] A <CreatedOn> element has been added to all .ibmmx files.
• [Code First] Support for both Entity Framework 4.1 and 4.2 in Code First.
• [Code First] The IdeaBlade.EntityModel.CodeFirstShimis no longer required for Silverlight in Code First models.
• [Code First] The "DevForce Code First File" item template now adds all required assembly references.
• [Code First] Marking an entity with the ProvideEntityAspect or ProvideComplexAspectattributes will now rewrite the underlying property logic so that the 'original' implementation of the property is called from within DevForce’s property interception instead of completely replacing it.
• [Code First] IdeaBlade removed the requirement that Code First navigation properties be typed to require a RelatedEntityList<T>. The requirement now is simply that the property return an ICollection<T>.
• [Code First] .NET projects containing a Code First model are now automatically re-built during metadata generation. Note that a Silverlight project containing links to the Code First files will still require a manual rebuild.
• [Code First] The name of the ibmmx model metadata file generated for a Code First model will use the DataSourceKeyName attribute value if provided.
• [Code First] DevForce Code First build errors will now inform the users of where to look in the DRC to better understand the error.

What's New in DevForce 2010 (V6.1.3)

• The EntityManager.ImportEntities clss now returns a dictionary that maps original EntityAspects to their newly imported counterparts.
• There is a new EntityQueryPager class in IdeaBlade.EntityModel that allows any EntityQuery<T> to be paged either synchronously or asynchronously.
• The new paging logic can now also account for the state of the entities in the client-side cache.
• The DevForce icon is now displayed in the Visual Studio solution explorer for .cf and .ibmmx files.
• The ibmmx file now contains a license key, allowing an application containing only a CodeFirst model to be deployed.
• The "DevForce Code First Project Item" is automatically added to a project when the "CodeFirst" template is used to generate a model.
• A project can contain multiple CodeFirst models, or a mix of CodeFirst and EDMX-based models.
• PostSharp 2.1 from SharpCrafters is now installed as part of the DevForce installation.
• The new InternalsVisibleTo(Sytem.Runtime.Serialization) attribute allows Code First entities to be serialized between the Silverlight client and the EntityServer.
• Faster failure detection and better error messages are displayed if a connection string is not found.
• DevForce dynamic query building components help you build and execute LINQ queries on the fly.

Please note: After upgrading to this release, you must regenerate your code from the EDMX. Do this by re-saving the EDMX or by right clicking the .EDMX.TT file within Visual Studio 2010 and selecting Run Custom Tool.

What's new in DevForce 2010 (6.1.2)
This release of DevForce 2010 includes a Community Technology Preview (CTP) of IdeaBlade's support for Code First.
Please note: After upgrading to this release, you must regenerate your code from the EDMX. Do this by re-saving the EDMX or by right clicking the .EDMX.TT file within Visual Studio 2010 and selecting Run Custom Tool.

Code First CTP

• Future DevForce developers will be able to write their Entity Framework-based models in "Code First" style. This 6.1.2 release includes a Community Technology Preview (CTP) of IdeaBlade's support for Code First. Note that this feature is a CTP: the workflow, interfaces, and behavior may be radically different in the final release.

Breaking changes
Please note that the following breaking changes only apply if you're overriding IdeaBlade's DomainModelTemplate. These breaking changes are necessary for the preparation of Entity Framework Code First support.

• IdeaBlade.EntityModel.ForeignKeyAttribute has been removed.
• IdeaBlade.EntityModel.RelationPropertyAttribute has been removed.
• IdeaBlade.EntityModel.ConcurrencyStrategyAttribute has been added. This will be applied to a property when its ConcurrencyStrategy is not set to None.
• IdeaBlade.EntityModel.DataEntityProperty constructor now takes 1 more string parameter that specifies the name of the related navigation property name if the property is a foreign key. You need to specify null otherwise.
• Added a new function called WriteEdmFunctionOutParameterUpdate that you can override if you wish to customize your stored proc queries with OUTparameters.
• When overriding WriteEdmFunctionExecuteDefinition, remember that the class MethodDef now takes a new parameter called ParameterMode that defaults to null. If you have stored procedures with OUT parameters in your model, you have to supply this new ParameterMode.
• As we ship our DomainModelTemplate.cs with every DevForce install, you always have access to it if you‟d like to see the changes in more detail.

Defect repairs

• Entity relations on derived classes (entity classes inheriting from other entity classes) were not being correctly resolved when retrieving from the datasource and the related entities were already in the cache. Fixed. [D1799]
• The phrase "(internal)" was removed from the AssemblyCompany attribute on DevForce assemblies intended for distribution. [D1802]
• The EntityKeyQuery was not always producing correct results if some items were already in the cache. Fixed. [D1806]
• StoredProcQueries involving self referencing foreign key properties were setting these foreign key properties to null instead of the correct foreign key value. Fixed. [D1808]
• Adding a newly created unattached entity to a list navigation property could duplicate it. Fixed. [D1809]
• The PartsCatalog used during Composition will now correctly exclude *.config files. [D1810]
• PredicateDescription instances now support passing in a „null‟ value parameter even when comparing a non-nullable property. Previously this would fail. [D1814]
• Performing a Distinct() operation on a anonymous projection with a “CacheOnly” QueryStrategy would fail in Silverlight. Fixed. [D1815]
• The OriginalValues collection on ComplexTypeinstances was not being reset properly after a SaveChangescall. Fixed. [D1816]
• Updating an existing entity's primary key will now throw an immediate exception with a description of the issue. Previously, these entities would simply not be savable. [D1817]
• Anonymous projections with a “CacheOnly” QueryStrategy would fail in Silverlight. Fixed. [D1818]
• FilterOperator.Any and FilterOperator.All now work with a CompositePredicateDescription. [D1820]
• The multi-BOS feature using serviceKeys now correctly supports different application names. [D1821]
• Entities removed from the EntityManager could become “reattached” to an EntityManager by modifying their foreign key properties to point to an existing entity in an EntityManager. Reattachment now only occurs during NavigationPropertyreassignment. [D1824]
• PredicateDescriptions using "FilterOperator.InList" will no longer throw an ArgumentException when used with nullable properties. [D1827]
• Updating entities on both sides of a many to many relation with no payload could cause a duplicate relation entity to be created. Fixed. [D1828]
• Repairing a failed server-side property value validation would not clear the error from the entity's ValidationErrorscollection. Fixed. [D1830]
• We now provide a better, more explanatory error message when the synchronous version of either a StoredProcQuery or a PassthruESQL query is called in Silverlight. [D1831]
• EntityFramework „EDMX‟ files with explicit „csdl‟ namespaces could cause the DevForce designer to break. (This could occur when using a third party XML editor to edit the EDMX). Fixed. [D1836]
• MetadataType lookup during code generation was not always discovering nested metadata classes. Fixed. [D1837]
• Building a CompositePredicateDescription takes increasingly longer with each predicate added, eventually leading to a timeout. Fixed. [D1842]

New and improved product features

• OUT parameters are now supported in stored procedure queries. DevForce code generation will generate any OUT parameters as 'ref' parameters in c#. (ByRef in VB). Generated code to access a stored proc with output parameters will now appear something like the following: [F1703]
  public void GetCompanyInfo(System.Nullable<int> Id, ref string CompanyName, ref System.Nullable<int> RowVersion)
• PredicateDescription instances can now be created where the 'value' parameter is another property on the object. For example: [F1729]
  myEntityManager.Customers.Where(c => c.Phone == c.Fax);
  Using PredicateDescription this becomes
  var pd = new PredicateDescription(typeof(Customer), "Phone", FilterOperator.IsEqualTo, new ProjectionSelector("Fax"));
  myEntityManager.Customers.Where(pd);
• Code First CTP. [F1741]
• The EntityManager constructor that takes an existing EntityManager instance as a parameter: [F1744]
• public EntityManager(EntityManager entityManager, EntityManagerContext entityManagerContext = null)
  has had its behavior extended so that any VerifierEngineassociated with the 'passed in' EntityManager is treated as a thread local VerifierEngine and is only associated with the new EntityManager if it is created on the same thread as the 'passed in' EntityManager. Otherwise a new VerifierEngine is associated with the new EntityManager. (Note that any newly constructed VerifierEngine will automatically discover any applicable verifiers). This change was made because VerifierEngines, like EntityManager's are NOT thread safe, and unless special care was taken the same VerifierEngine previously would often get accessed by more than one thread. This is unlikely to be a breaking change because of the DevForce Verifier discovery mechanism but if it is, the previous behavior can be restored by assigning the 'passed in' EntityManager's VerifierEngineto the new EntityManager's VerifierEngine property.
• PredicateDescription instances can now be created that compare string values for all comparison operators (>,>=, <, <= , ==). Note that this is not supported by standard .NET syntax i.e. [F1745]
  myEntityManager.Customers.Where(c => c.CompanyName > “F”);  INVALID .NET Syntax (Strings are not comparable via standard operators)
  Must be rewritten as:
  myEntityManager.Customers.Where(c => c.CompanyName.CompareTo(“F”) > 0);
  Using PredicateDescription this is now possible and is expressed as:
  var pd = new PredicateDescription(typeof(Customer), "CompanyName, FilterOperator.IsGreaterThan, “F”);
  myEntityManager.Customers.Where(pd);

What's New in DevForce 2010 (6.1)

• NamedQuery support
  Dictating the server-side implementation of a query is easy using named queries. You can write several named queries for a particular entity type and offer clients a menu of query alternatives that each express a distinctive intent.
• Improvements to CompositionHost probing
  The CompositionHost now supports IgnorePatterns which can be customized as needed. The default patterns automatically ignore many third party UI assemblies to help improve startup performance.
• Multiple business application servers
  A client application can now connect to multiple business application servers.
• Enhanced dynamic query support
  "Any" and "All" FilterOperators added for use with IPredicateDescription.
  Support for dynamic async scalar operators - IEntityScalarAsync (as opposed to IEntityScalarAsync ).

What's New in DevForce 2010
Major changes appear across the board. The most important derive from the product's reliance on the new Microsoft .NET technologies released in 2010:

• Visual Studio 2010
• .NET 4
• Silverlight 4
• Entity Framework v.4

DevForce 2010 does not work with:

• Earlier versions of Visual Studio
• Earlier versions of .NET or Silverlight
• Entity Framework v.3.5

DevForce 2010 supports Silverlight, WPF, Windows Forms, ASP WebForms, and ASP MVC clients. (Dependant on edition)

DevForce Universal - All the Data Services Needed in One Package.

DevForce Data Services fills a gap in the application infrastructure stack between where your Data Access Layer (DAL) ends and your client application begins.

The gap concerns your “business logic layer”. How your raw data become business objects with behavior, logic, and rules. How your business objects traverse tiers and cross the network … securely and reliably. How you query for them with LINQ and save changes transactionally. How you do all of this at scale and with maximum performance.

DevForce Data Services fills this gap so you don’t have to reinvent it, cobble it, maintain it, and defend it. We’ve got eight years of tough customer experience, with production applications in the field spanning the spectrum of .NET client technologies: WinForms, ASP.NET, WPF, and now Silverlight.

DevForce Universal provides Data Services for WPF, WinForms, ASP, and now Silverlight in a single product. DevForce Universal is a combination of the value and features found within DevForce WinClient and DevForce Silverlight products.

DevForce WinClient

DevForce is a framework for building and operating multi-tier, data-driven enterprise applications.

Enterprise applications are not simply big applications, or an application for a big company. Rather, they are applications with the following specific characteristics:

• Its users devote many hours to its use, performing task essential to conducting the organization's business
• It requires a rich and responsive graphical user interface, dense with sophisticated controls
• User interactions are complex; task and context switching is common
• It presents data that are complex in themselves, and deeply interrelated
• The data are stored centrally and shared with other users

Supply chain, customer relationship management (CRM), and asset tracking applications are typical examples.

User productivity is critical. That puts a premium on the application‟s ability to provide a highly responsive, richly featured user experience – the kind of experience typical of a desktop application running directly on a client machine.

It is expected that people get work done at any time from anywhere. Those people may be employees or they may be valued partners. In either case, security matters. Accordingly, we often need to deploy and operate enterprise applications over a wide area network – preferably over the internet – with undiminished productivity and security.

DevForce is especially suited to building and running applications that require a rich user experience delivered to remote, Internet-connected clients.

DevForce Silverlight

DevForce Silverlight allows you to deliver line of business applications in the browser with the kind of responsiveness users expect from a desktop application. Developed for Microsoft Silverlight, the browser plug-in which powers rich application experiences, it allows you to leverage your existing DevForce experience with new tools and techniques to build serious applications.

A few things to note about Silverlight, and thus about DevForce Silverlight:

• Silverlight is inherently n-tier. The client application executes in a sandbox on the browser, and must communicate with a service to retrieve and save data. The DevForce Silverlight Business Object Server (BOS) provides that service, and allows you quickly to have a Silverlight application retrieving and saving to a database, using the domain model and business objects you're already familiar with.
• Silverlight is inherently asynchronous. To avoid blocking the browser, Silverlight requires that all service communications be performed asynchronously. This can be a bit challenging at first, but DevForce Silverlight provides an asynchronous API very similar to the standard synchronous API, plus additional features to make asynchronous programming as easy as possible.

In DevForce Silverlight, you have the EntityManager to hold your client-side entity cache and communicate with the BOS, just like you would in a standard DevForce EF application. The Domain Model is actually shared between the two environments, and DevForce handles the movement of your business objects between tiers. You use the standard EntityQuery syntax to build true LINQ queries, which can be directed against a back-end data source or against the local DevForce cache. Your queries run asynchronously against back-end data sources, or synchronously against the local cache.

Key to it all is the shared domain model. The domain model used by the Silverlight application is the same domain model used on the server, or in any .NET DevForce application: not an anemic object model with an unfamiliar API. You can add business logic - via custom methods and properties, DevForce property interceptors, and DevForce verification - to your shared domain model. You can also choose to deploy logic which is applicable to the client-side or server-side only.

Building on the strengths of DevForce WinClient, DevForce Silverlight allows RIA developers to build scalable applications utilizing Silverlight and the Entity Framework. IdeaBlade have years of experience building object-relational mapping tools and have applied this experience to DevForce Silverlight, giving RIA developers the ability to build rich domain models for their Silverlight applications. Their previous expertise in building n-tier data models combined with their integration with the new Silverlight 3 UI controls and validation provides developers with an environment to create powerful enterprise applications using Silverlight.

Why DevForce?

Infrastructure for Multi-tier
N-tier data access is hard. Constructing a remote domain model for your data is hard. DevForce simplifies n-tier persistence and provides a rich domain model on which to build your application. Stop writing plumbing and infrastructure code and focus on your business logic and user experience.

Single Domain Model
You shouldn't have to duplicate your business logic in multiple places. The mobile business objects in DevForce enable you to use a single domain model whether you are writing client-side, server-side, or have multiple faces for the application in different technologies such as WPF, WinForms, ASP.NET, or Silverlight*.

Rich Domain Model
DevForce provides you with rich business objects with real behavior. Use a domain model that represents your problem, not just flat data transfer objects, where you have to do all the bookkeeping and re-implement your logic.

Verification Engine
Verify the correctness of your business objects and provide helpful error messages to the user. Supports cross-field and cross-object validation, and is seamlessly integrated with Silverlight 3 validation. Keeps your business logic in your business objects and out of the UI .

Offline Execution
Use your application while disconnected or partially connected to the internet. Save your work in isolated storage and resume working later.

Web Services
Consume other services in your application. DevForce can create web-service backed business objects allowing you to integrate them into your domain model.

Entity Framework Integration
Standardize on Microsoft's next generation ORM framework. DevForce is built upon the Entity Framework, enables it to go n-tier, enables it to work in Silverlight, makes it easier to use.

Responsiveness
DevForce applications are snappy. The domain model executes on client, client-side caching reduces trips to the server, data compression reduces network latency, and asynchronous queries allow background processing. For DevForce Silverlight the domain model executes inside the Silverlight client, client-side caching reduces trips to the server, data compression reduces network latency, and asynchronous queries allow background processing.

Full n-tier LINQ Support
Get the full power of LINQ in an n-tier application. LINQ-to-Entities only operates 2-tier, and other LINQ implementations only support a narrow range of queries. DevForce supports them all. For DevForce Silverlight you can use the full power of LINQ from within the Silverlight client application.

Multiple Data Sources
Use multiple back-end databases in a single domain model. Navigate cross-database relations using object properties. Save all your changes safely in a distributed transaction.

Data Access
Getting data into a Silverlight application is hard. Constructing a remote domain model for your data is hard. DevForce simplifies n-tier persistence and provides a rich domain model on which to build your application. Stop writing plumbing and infrastructure code and focus on your business logic and user experience.

Offline Execution
Use your application while disconnected or partially connected to the internet. Save your work in isolated storage and resume working later.

Web Services
Consume other services in your application. DevForce can create web-service backed business objects allowing you to integrate them into your domain model.

Scalability
Client-side caching, connection pooling, and a stateless and multi-core enabled server provide DevForce applications with excellent scalability and fault-tolerant characteristics.

Security
No connection string is exposed on the client. Server-side security checks prevent unauthorized access even if the client is compromised.

WinForms Databinding Support
Advanced databinding API works with .NET controls as well as Infragistics and DevExpress. Auto-populate forms with controls and then customize as you see fit.

MVVM and Best Practices
DevForce is built around good architectural practices such as MVC and MVVM and enables you to conveniently keep your UI and business logic where they belong without sacrificing usability or functionality.