Bashmohandes

LLBLGen Pro Version 2.0 Beta is available

The great ORM (Object/Relational Mapper) LLBLGen Pro version 2.0 beta is available now for the customers, it has so many great features that I was expecting to see like Nullable Types & Generic support
and this a list of the NEW features (copy & paste from the documentation)

Added

• Full .NET 2.0 support. The .NET 2.0 runtime libraries are a new code base, ported to .NET 2.0 in every detail internally as well, so the code uses internally .NET 2.0 features where possible/applicable.
• SqlServer DQE: now has a compatibility switch (global): DynamicQueryEngine.CompatibilityLevel, which can be set to SqlServer7, 2000 or 2005 (2000 is default), either through code or in the .config file. The compatibility switch controls which paging query style is used (temp-table on 7/2000, CTE based on 2005) and which sequence is used by default (@@IDENTITY on SqlServer7, SCOPE_IDENTITY() on 2000/2005)
• SqlServer DQE: NewSequenceid() is now supported on SqlServer 2005
• SqlServer DQE: support for CLR based User Defined Types.
• SqlServer DQE/SqlServer 2005: When the compatibility switch is set to SqlServer2005, the paging query is using a CTE based WITH statement instead of a temp table approach, which can greatly enhance performance.
• .NET 2.0: support for nullable types
• .NET 2.0: support for System.Transactions
• .NET 2.0: support for new wsdl schema interpretation logic to have wsdl.exe generate typed stubs instead of DataSet based stubs in Webservices scenarios
• New validation framework:
  • Entities now implement IDataError
  • More events, virtual methods have been added to let you tap into the life time / actions of entities like validation on load.
  • IEntityValidator and IValidator have been merged into a single interface and base class, which gets all the information you need to do proper valication, like the containing entity.
• Powerful data-projection framework added: project any entitycollection or resultset retrieved from a datareader onto any datastructure of any type using generic code.
• It's now possible to fetch a query as a datareader. This query can be a stored procedure call, or a query created on the fly by the DQE used. This datareader can then be used further, if required, to project the data onto classes like entity classes, datatables or custom classes using the generic data-projection framework.
• EntityView (SelfServicing) and EntityView2 (Adapter) classes added, which are dataview-style objects for entity collections. They support sorting, and filtering in-memory, data projection onto other entity collections, datatables or custom classes.
• Expression, all predicates and sortclause now are able to work in-memory on an entity in an interpreted way. This means that you can use the normal predicate, expression and sortclause objects to filter an entity collection in an EntityView(2) object, which allow you to write compile-time checked filters and sort expressions for in-memory filtering/sorting.
• The ORMException class, which is the base class for all ORM...Exception classes now contains the runtime libraries version and build numbers.
• Expressions now support calls to database functions. Database functions can accept entity fields or normal values you pass to the function. You can use database functions freely in an expression you assign to an entity field or filter.
• Full support for 2-way declarative databinding and design time databinding in ASP.NET 2.0, using the LLBLGenProDataSource (selfservicing) and LLBLGenProDataSource2 (adapter) controls. These controls support (design time) databinding of entity collections, typed lists and typed views and support server-side paging, sorting and filtering. They also support data persistence / retrieval delegated to different methods (tracking changes into a unit of work object), and filtering/sorting based on parameter binding with other controls on an ASP.NET 2.0 webform.
• Full support for design time databinding in .NET 2.0 winforms.
• EntityFields(2) now has a CloneAsDirty() method, which clones the fields object and marks all fields as Changed as well as itself as Dirty.
• FieldCompareValue now has a CaseSensitiveCollation setting for string values, so you can perform case insensitive field compares on case sensitive databases
• New DQE for Oracle using the Microsoft provider.
• .NET 2.0/VS.NET 2005: Debug visualizers for a lot of classes in the framework to ease debugging your code.
• Synching setup of entities related to eachother has been enhanced, so that also dereferencing through FK field changes will result in proper clean-up of synchronization data and references.
• Synchronization of FK fields with their related PK fields are now fully controlled from the FK side entity. This means that you can now hide the 1:n relation and keep the m:1 relation to have synchronization of PK fields with FK fields. This can be handy if you don't want the collection like Customer.Orders, but you do want the fk side, Order, to sync with the pk side, Customer, when you do Order.Customer=newCustomer and the object graph is saved.
• The Context class now has a Clear() method, to prevent that entities are kept in scope because they were referenced by a context referenced by an entity which was kept in scope as well.
• DataAccessAdapterBase and DaoBase now have a virtual method called HandleValueReadErrors, which can be used to re-try a datareader value read in case when that caused an exception internally, for example when datareader.GetValues() gave an overflow exception on Oracle.
• EntityFields(2) objects now have a DefineField(fieldobject...) method and overloads, which make it easy to define field sets without having a lot of overloads in ResultsetFields, which is a subclass of EntityFields(2).
• New attribute has been added, IncludeInCompactXmlAttribute, which controls if a newly added entity collection property has to be added to the xml produced in webservice scenario's or Compact Xml scenario's. (Webservices use the CompactXml setting)
• New exception classes: ORMInterpretationException and ORMGeneralOperationException have been added. ORMInterpretationException is thrown when during an in-memory interpretation of an entity by an expression, predicate or sortclause an exception occurs. The ORMGeneralOperationException is thrown when the O/R core isn't used appropriately and no other exception classes are appropriate.
• Memory footprint of in-memory collections has been greatly reduced
• Entity collection fetch performance has been greatly enhanced
• Prefetch Paths with m:n nodes are now more efficient. Duplicates in parameterized prefetch paths are now filtered out as well, resulting in faster queries.

Have fun
Click Here for more Info in the discussion board