TechTalk announces Genome 2.0, object-relational-mapping for .NET

[Christian Hassa]

Since this newsgroup is going to be depricated soon and there might be a lot
of developers who are looking for an O/R mapping solution until Longhorn
arrives (and probably even beyond that point) I want to draw your attention
to Genome, an object-reational-mapping tool for .NET developed by TechTalk.
Genome has been existing since 2002 and already proved itself in several
real-world enterprise applications. Originally intended only for internal
usage it has matured so much in the last 2 years that we decided to make
Genome a publicly available product.

We think that Genome is not just yet another O/R mapper but it introduces
concepts of O/R mapping which are not found often in other products. There
is a whitepaper available for download (http://www.genom-e.com) which gives
a quick overview about Genome concepts and architecture.

Genome Benefits and Highlights
=====================

Strongly typed object-query-language (OQL) based on C#

While a lot of existing O/R mapping tools are providing basic CRUD
operations they stick to SQL conventions in their query language (if a query
language is provided at all). Relational database limitations can not be
overcome if the query language is not adapted to the concept of OO
programming. Therefore Genome introduces a powerful query language working
with set operations. OQL is easy to learn since expressions are formulated
in C# syntax. The query language transforms OO concepts like encapsulation
and polymorphism to the relational world allowing reusability and
refactoring in the database. OQL supports full projection and allows
strongly typed building of dynamic queries. Query expressions can be reused
to build up more complex expressions and for expressing any kind of
relationship between objects (not limited to simple 1:n and n:m). Even
recursive expressions can be executed completely on the SQL server side by
being automatically compiled to stored functions.

Separation of concerns and easily changeable data loading strategies

Genome introduces an infrastructure called the Context as a Strategy pattern
for governing how much data is loaded up (number of roundtrips to the
server) and how long data is cached. The Context is also used for
configuring transactional behavior and records all changes to an object
graph before being committed to the database or rolled back. Genome supports
several transactional models like short running transactions being directly
executed in the database and long running transactions being executed
disconnected from the database.
By having an active Context assigned to the thread, the Context is an
implicit parameter for all operations of the business logic. This means
transactional, loading and caching strategies can be reconfigured
independently of the business logic, even during runtime.

No Limitations

While enabling developers to spare implementing their data tier Genome does
not introduce any architectural limitations. Its design is held generalized
to fit for building service layers as well as web applications or simple
client/server applications.

Extensible

Genome offers hooks and eyes for integrating your custom data access code
and needs. Events can fire custom written stored procedures which results
can be again populated into object graphs by Genome. Lower level APIs allow
extending Genome further for specific needs.

Availability
=======
Genome is available now. It can be used free of charge for non-commercial
and developer community projects. The Professional version is licensed per
developer with no runtime or other distribution fees. Further information
about Genome and a free evaluation license can be downloaded at
http://www.genom-e.com.

About TechTalk
===========
TechTalk GmbH is an independent software vendor specialized on the Microsoft
.NET platform. TechTalk was founded 1993 in Vienna, since 2000 a subsidiary
in Budapest/Hungary exists. TechTalk is providing leading edge .NET
architectural consulting and enterprise application development for large
and leading organizations such as government institutions, banking and
industry..
Further information about TechTalk can be found at http://www.techtalk.biz.

[Frans Bouma [C# MVP]]

Christian Hassa wrote:

> Strongly typed object-query-language (OQL) based on C#
>
> While a lot of existing O/R mapping tools are providing basic CRUD
> operations they stick to SQL conventions in their query language (if a query
> language is provided at all). Relational database limitations can not be
> overcome if the query language is not adapted to the concept of OO
> programming. Therefore Genome introduces a powerful query language working
> with set operations. OQL is easy to learn since expressions are formulated
> in C# syntax. The query language transforms OO concepts like encapsulation
> and polymorphism to the relational world allowing reusability and
> refactoring in the database. OQL supports full projection and allows
> strongly typed building of dynamic queries. Query expressions can be reused
> to build up more complex expressions and for expressing any kind of
> relationship between objects (not limited to simple 1:n and n:m). Even
> recursive expressions can be executed completely on the SQL server side by
> being automatically compiled to stored functions.

Perhaps I'm wrong, but because your OQL (which looks ok) is based on
operator definition / overloading, isn't it so that you can't use it in
VB.NET?

FB

--
Get LLBLGen Pro, the new O/R mapper for .NET: http://www.llblgen.com
My .NET Blog: http://weblogs.asp.net/fbouma
Microsoft C# MVP

[Christian Hassa]

Hi Frans!

If you are working with Sets directly in code than we use operator
overloading.

However, each operation is also expressed as a method of the Set class. So
e.g. instead of writing:
set1 = set1 * set2
you can also write
set1 = set1.Intersect(set2)
. which also works in VB.

On the other hand, most of your OQL is anyway written in the mapping file
where we parse/compile it ourself and are not bound to any VB.NET
limitations.

The short answer is: you can use Genome with VB.NET. Actually, some people
are already using it with VB.NET.

Br
Chris

"Frans Bouma [C# MVP]" <perseus.us...@xs4all.nl> schrieb im
Newsbeitrag news:xn0dj5v0...@msnews.microsoft.com...

[Frans Bouma [C# MVP]]

Ok thanks. :)

Frans.

[David Vásquez]

Hi Christian,

Genome looks pretty mature and personally I like the idea of using mapping XML
files. Since we are looking for an OR-Mapper which is close to OS, we have some
interrogants about your product:

1. Can Genome be installed and work in .NET 2.0 as fine (performance,
robustness) as in .NET 1.1 ?
2. Does Genome support concurrency control (optimistic locking) ?
3. Are the mapping files close in structure to the OS one?
4. How much investment do you think would be requiered to migrate the data
access layer from a system build upon OS to a one working with Genome?

Thanks in advance,
David

[Christian Hassa]

Hi David!

Thanks for evaluating our product!

Regarding your questions:

1. Can Genome be installed and work in .NET 2.0 as fine (performance,
robustness) as in .NET 1.1 ?

We haven't done any performance tests on .NET 2.0 yet, however we do not see
any potential problems why Genome would not execute or execute less
efficiently on .NET 2.0. However we are looking forward in utilizing .NET
2.0 features for Genome, especially generics and features of Yukon will be
of great benefit. We plan to release a version of Genome with special
support for .NET 2.0 when .NET 2.0 is released.

2. Does Genome support concurrency control (optimistic locking) ?

The current version of Genome supports only pessimistic locking. The next
release, which is scheduled for mid summer (around 15th of July this year)
will already support various locking capabilities, including (but not
limited to):

1.. pessimistic and optimistic locking using the database
2.. pessimistic and optimistic locking using a separate locking server
Notice that the interface for accessing the locking infrastructure is
already set (since we already support pessimistic locking). With the new
release you will just get additional options for locking (e.g. you can
define a field in the table for providing the versioning information needed
for optimistic locking).
Of course you can also implement optimistic locking on your Genome objects
today as all the necessary features are there already. It's just that Genome
will not provide any specific support in this area (as well as it will not
prevent you from doing that).

3. Are the mapping files close in structure to the OS one?

It depends from how you look at it. In ObjectSpaces you have to create three
mapping files: one describes your entity objects, one describes your data
model and one describes the mapping between these two.

In Genome, your object model is examinated using reflection with a help of a
few attributes (e.g.: ElementTypeAttribute). In Genome you have to author
only one mapping file (the schema definition file) which however allows you
to describe more aspects of your object-relational mapping than in OS. You
can describe the entity-table mapping (mapping classes to tables, member
variables to fields) as well as relations and associations (using OQL
queries) but the possibilities do not end here. You can also describe any of
your methods and/or properties using OQL queries which allows you to execute
your business methods directly on the SQL server!

4. How much investment do you think would be requiered to migrate the data
access layer from a system build upon OS to a one working with Genome?

Not much. OS mapping files could be easily transcribed to schema
definitions. OPath queries are also easy to formulate in OQL. One would have
to throw out a lot of code, that would not have to be rewritten (Genome
takes care of a lot more data access aspects than Object Spaces). Also,
after porting your code under Genome you would be tempted to refactor it,
since Genome allows you a much greater deal of decomposition in your
business layer, but that is optional of course J

br
Christian Hassa