DevForce WinClient

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

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. 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, makes it easier to use, and adds all the features you see here plus more.

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.

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.

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.

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.

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.