ASP.NET AJAX, Silverlight and robust WinForms & WPF controls, as well as a flexible reporting engine are there to help you quickly create .NET applications on budget and on time. Telerik Premium Collection for .NET also includes Telerik OpenAccess ORM which lets you simplify the data access plumbing in desktop and Web applications. The Subscription License comes with a Gold Support Package (up to 24h response time), full C# source code, redistribution rights and free updates for the latest products for one year. The tools work without license keys and can be freely deployed on an unlimited number of development, testing and production servers. A 580-page self-paced tutorial and hundreds of code samples are provided to accelerate your learning.
Telerik Premium Collection for .NET Silverlight included controls:
Telerik Premium Collection for .NET WPF included controls:
Telerik Premium Collection for .NET WinForms included controls:
telerik Reporting features:
Fine-grained CSS-like styling - Telerik Reporting introduces an advanced, and much enriched styling mechanism through its build-in styling model, which closely follows CSS specifications. This model provides for quicker and very fine-grained visual customization of all reporting controls, all in the Visual Studio designer. This CSS-like mechanism offers full control over the item’s background, images, colors, borders, styles, paddings, etc.
You can assign styles to one or more reporting items by using the known CSS selectors: Type, Attribute, Style, and Descendant. Styles can also be applied globally and then saved to an external file for later use. If extra control over visual appearance is needed, cascading styles can be applied manually.
Variety of export formats - Telerik Reporting supports out-of-the-box the most commonly used output formats:
Flexible rendering mechanism - Output formats are implemented as Rendering Extensions - not a hardcoded set of output formats. You can easily add new output formats (XML, XPS,…) by creating a new rendering extension. The document builder will then handle the new format for you just like the out-of-the-box formats.
Extensible object model - You can easily customize the built-in reporting items or create new ones. You can either inherit from some of the existing reporting items or create a new one from scratch.
Full design time support for VS2005 - All reports created with the telerik Reporting tool can be fully customized through VS2005 design time. You can style any report to your preference, add/remove items and groups, and even preview the report through the provided HTML Preview mode for Web, and the Preview mode for Windows Forms.
In addition to the regular design-time characteristics, telerik Reporting offers two additional tools for better report management:
Report Explorer - this tool window displays the tree representation of the report structure with all items that are present. Using the Explorer, you can quickly access any element in your report, which makes it much easier to work with large, complicated reports.
The Data Explorer tool window shows the relevant data sources of the report:
Rich set of measurement units - A typical challenge in report design is the precise layout and sizing of elements for the purposes of proper printing and viewing in different formats. telerik Reporting supports a variety of measurement units, which can be used for any element, including borders, padding, and even font sizes. Examples:
You can also use combinations of different measurement units where appropriate. A default report measurement unit allows you to quickly enter dimensions and positions without specifying the unit.
Available Windows and Web report viewers - For complete control over viewing reports, the Telerik Reporting offers Windows Forms and Web Viewers, which guarantees that you will always get the same look and feel of your reports. Both viewers are also available within VS2005 with individual design-time support.
Telerik OpenAccess ORM features
Forward and Reverse Mapping
Support for 6 Databases - Enjoy database independence with full support for the most popular databases:
Deployment Flexibility, Mapping in the Middle
OpenAccess supports modifications of the database only within the scope of an active transaction. This addresses the real-world challenges of durability, consistency, atomicity and isolation. Therefore OpenAccess does not allow nor support any risks which might come from the underlying database. That’s why we support only fully transactional databases, focused on the most used databases for .NET applications. If you miss one important to you, please let us know.
OpenAccess defines a mapping in the middle: all mapping information is per default stored in the app.config file, so outside of your C#/VB code and outside of your database. This allows you not only to deploy your application with one object model and different database schemas for different deployments, it also allows to map differently for different database vendors. No need of any change in your code. Even if you don’t need this flexibility initially, it keeps your code independent. And it might even help to migrate your existing apps and databases to other, new databases (reverse map your old database/vendor and forward map it to your new ones).
Support for LINQ, OQL, and SQL Languages - With OpenAccess you got no limits, you can just use the best of all words, even combined.
Transparent Data Access, Lazy Loading and Automatic Change Tracking
OpenAccess uses lazy loading where your application objects are filled with the data upon access. Not all fields will be filled immediately, so collection or picture fields can be deferred in their population. This has the advantage of saving memory and network bandwidth while preserving easy access – when the field’s content is needed, the data is fetched transparently from the database server. Of course, you can decide which fields are to be fetched when, and OpenAccess provides sensible defaults.
Modifications to values of the persistent fields are automatically tracked. You don’t need to notify the OpenAccess runtime system that an instance is to be written. When modifications are detected, only the necessary columns are included in the resulting SQL statements. All referenced persistent objects will be handled as well, and only complete object graphs are stored – no instance is left behind.
Visual Studio Integration - OpenAccess ORM is tightly integrated into Visual Studio, so you don’t need to change your environment nor the way you develop. It comes with various wizards to make your life easier and to visualize what you do. OpenAccess supports IntelliSense and the documentation is integrated in the Visual Studio Help system. OpenAccess works with Visual Studio 2005 and 2008, on .NET 2.0, 3.0 and 3.5, and supports both C# and VB.NET.
Disconnected API
OpenAccess unique ObjectContainer API concept has been the first ORM feature supporting disconnected data scenarios. Whether you’re thinking of mobile devices, web applications or replications - you need disconnected data management you can count on. To work with portions of your data in a disconnected mode, just take them with you. OpenAccess keeps them transactionally save and uses little network bandwidth by only exchanging the minimum change set. So it tracks which objects have been changed or are new.
The offline ObjectContainer API shares a common interface with the online ObjectScope API, and parts of the applications can be implemented independent of their connectivity.
The ObjectContainer serves as a bag which can hold object network, provides serialization, change tracking and the ability to apply changes in a round-trip fashion to the database.
Synchronized Distributed Level 2 Cache
OpenAccess provides a cache which can be shared by many database access instances (object scopes) in process. This is useful in situations where a lot of data is shared and commonly asked for. A typical example is a web server where much of the data is stable, sharable and commonly used.
Entries are evicted from the cache, when objects change. The cache is populated upon read access, configurable in its sizes and stored entry types and uses LRU overflow handling.
Entries in the cache are object states (representing the data of a single object) and whole query results. That means, the result of recurring queries can be stored in the cache and such queries will not hit the database server unless the cache entry is evicted. Eviction is automatic but can also be triggered manually.
Not only is such a cache shared within one process, but many of those caches can easily be coupled over the network to provide a distributed synchronized cache. The key benefit is that the Level 2 Cache can be used even in such scenarios where multiple application or web servers are put together into a farm.
The network access for such a distributed shared cache is optimized by using a asynchronous reliable multicast protocol. This is perfect for a cache cluster of unknown size.
Boosting Performance by using Fetch Plans - OpenAccess ORM provides for declarative coupling of Object Model and Activities through Fetch Plans.
FetchPlans describe object networks for performance optimizations.
With the up-front declaration of a FetchPlan, OpenAccess is able to know in advance which object graph will be used by your code. This greatly improves your application performance in an easy and declarative manner.
This feature combines very well with the data fetches done by your application and avoids a common performance pitfall that is known as the ‘N+1 query problem’. Instead of querying for 1 order and then performing the n order details, a FetchPlan can be used to issue one optimal query fetching both order and its details.
The FetchPlan is built up during runtime by a simple yet powerful API. The basic intention is to have a FetchPlan per use case. There is always a current FetchPlan, and this FetchPlan is used by queries and object navigation too.
Philosophically, FetchPlans are the countermeasure to lazy-loading as they provide information for eager-loading.
Flexible Concurrency Mechanisms
OpenAccess supports both optimistic and pessimistic concurrency control. Both approaches can be mixed during runtime. Additionally it is possible to automatically obtain a pessimistic lock upon the first modifying access in an otherwise optimistic transaction.
When using optimistic concurrency control (the default), conflicts can be detected by designated version fields, the old content of the modified fields or all fields. And you can also turn conflict detection off.
Tél : (888) 850 9911
Fax : +1 770 250 6199
