Have you ever thought about having a database that you can write your objects directly, and use SQL for retrieving them back?
Write objects into database and get them back.

   1:  // Open connection to the server

   2:  using (DB db = new DB("server=localhost;options=none;"))

   3:  {

   4:      // Open the database

   5:      db.OpenDatabase("Cinemas");

   6:   

   7:   

   8:      // Create the object we would like to work with

   9:      Cinema cinema = new Cinema() {

  10:             Location = "Sydney",

  11:             OpenDates = new DateTime[] { new DateTime(2003, 12, 10), new DateTime(2003, 10, 3) }

  12:      };

  13:   

  14:   

  15:      // And here is where the magic begins...

  16:      // Store the object - no conversion required

  17:      db.Store(cinema);

  18:   

  19:   

  20:      // Magic is not finished yet

  21:      // Get an object that matches the criteria

  22:      var movies = db.ExecuteQuery("SELECT Cinema WHERE ALL Movies.Studios.Titles CONTAINS '20th Century Fox'");

  23:   

  24:   

  25:      // Magic still goes on...

  26:      // Creating parameters

  27:      Parameters param = db.CreateParameters();

  28:      param["dt1"] = new DateTime(2006, 10, 1);

  29:      param["dt2"] = new DateTime(2009, 09, 17);

  30:   

  31:   

  32:      // And here we search for the values IN THE ARRAY!

  33:      var result = db.ExecuteQuery("SELECT Cinema WHERE OpenDates BETWEEN @dt1 AND @dt2", param);

  34:   

  35:   

  36:      // And here we do something good with the objects retrieved from the database

  37:      foreach (var cinema in result)

  38:      {

  39:          Console.WriteLine(cinema.ToString());

  40:      }

  41:  }

This is real code running on Eloquera Database 2.0 (codename Woomera) - the web-oriented client/server object database for .NET. It is already available as a pre-release version on the website Eloquera
The upcoming version of Eloquera database has some mind-boggling features

• Storing any .NET object without implementing any interface or inheriting from a specially designed class.
• Queries based on SQL. Yep, good old SQL. And no SQL database is required.
• Returns the objects in their native form, as a single object or as an enumeration.
• Supports arrays in queries. Any arrays - simple, multidimensional, jagged, of simple or complex types. And there is more!
• Supports JOINs in queries. And even for arrays.
• Expressions and functions in queries. You can perform JOINs or sort your data on them.
• Flexible sorting - there are some really useful ones.
• Regular Expressions are your best friends! Regex support in queries.
• Indexes. Yep, you can index data for faster access. Both fields and properties.
• Bulk inserts and updates. You can insert tens of thousands objects in a second.
• Generic object support. And also in queries.
• Inheritance support in queries (SELECT ParentClass returns both ParentClass and ChildClass)
• Queries only upon certain type. (SELECT ONLY ParentClass returns only ParentClass, but not ChildClass)
• Restoring objects partially (you might need ForumTopic object, but don't need all TopicMessage, linked with it.)
• Depth for queries.
• Client/server architecture.
• Parallel and independent query execution for multiple users.
• Windows authentication. Specify no user name and log on under your current account.
• Both Server and client are implemented in 32- and 64-bit architectures.
• Unique identifier for any object within a database - for stateless environments (hence ASP.NET)
• Different cultures support in queries (e.g., "where dates BETWEEN['en-US'] @d1 and @d2" - formats will be treated as US English, even with the current UK settings on the machine.
• Approximate matching with ALMOST keyword.
• Have you seen an object database with SQL query support? With JOINs? And with arrays?

 So, what do you need to get Eloquera Database 2.0 running on your machine and ready for your command?

First, download and install the Eloquera setup files from the website.  You need to download the server for your platform (32- or 64-bit). The server includes also all client libraries.
Installation is straightforward, and takes just a few seconds. The setup will install the service called Eloquera Server 2.0.

Included with the Eloquera server is a folder containing examples in C#. These examples are quite concise but cover various topics on using Eloquera, like JOINs and queries on arrays.

Secondly, you need to connect to the database in your code. By default, only the members of the Administrators group can access the database server. As Eloquera uses integrated Windows authentication, you can add your own user or a group to the list of the permitted security entities.
To do that, open the Eloquera Server configuration file (it is usually located at "%ProgramFiles%\Eloquera\Eloquera Server" and it called Eloquera.config) with any suitable text editor (as Notepad).

Find the Server element, and change the value of the AllowUsers or AllowGroups attribute, adding your user or group to the list. The items in the list are separated by a semicolon. It is advised not to remove Administrators group from the list.
For development purposes it is good practice to add Users group to the list of allowed groups. After this your <Server> element in the configuration file will like this:

Server configuration.

   1:     <Server ServerPort="43962" Trace="true" Secure="true" AllowUsers="" AllowGroups="Administrators;Users" />

Restart the service for the changes to take effect. You can easily perform this task using the command line and running the following commands:
Restart service

   1:  net stop "Eloquera Server 2.0"

   2:  net start "Eloquera Server 2.0"

And now Eloquera is ready to run your queries.
Below I am going to give some brief examples of Eloquera DB queries. We will discuss all the features in the next articles about Eloquera Database. These examples are intended to show how easily you can start working with Eloquera.
We are going to use these two classes as a base for our demonstration:

Example classes

   1:  public class School 

   2:  {

   3:     public Location Location { get; set; }

   4:     public string Name { get; set; }

   5:  }

   6:  public class WorkPlace 

   7:  {

   8:     public Location Location { get; set; }

   9:     public string Company { get; set; }

  10:     public string Position { get; set; }

  11:  }

So, we have stored a bunch of objects of both types in the database, and now we want to run a JOIN query to get some of back.
JOIN query

   1:  var queryResult = db.ExecuteQuery("SELECT sch, wp FROM School sch INNER JOIN WorkPlace wp ON ch.Location=wp.Location");

Consider we have stored multiple instances of the following class in our database:
Example classes

   1:   public class User

   2:   {

   3:     public Location CurrentLocation { get; set; }

   4:     public string Name { get; set; }

   5:     public DateTime BirthDate { get; set; }

   6:     public User[] Friends { get; set; }

   7:     public WorkPlace UserWorkPlace { get; set; }

   8:     public string[] Emails { get; set; }

   9:   }

Array query

   1:  Parameters param = db.CreateParameters();

   2:  param.AddList("emails", new string[]{ "john@gmail.com", "david@hotmail.com" });

   3:   

   4:   

   5:  var res = db.ExecuteQuery("SELECT User WHERE Emails CONTAINS @emails", param);

As I said, you can find fully working examples of the Eloquera applications by installing the Eloquera server on your development machine.

Future starts today - you can download Eloquera 2.0 and find a new world of database programming.

Eloquera is the object database for .NET. Eloquera supports native operations with objects, SQL queries, unique object identification for stateless environments like web applications (ASP.NET).
Working with data never been easier. Add and update your object just by one line:
Adding object to the database in Eloquera.

   1:    Shop shop = new Shop();

   2:    //That stores the object and all its linked objects.

   3:    db.Store(shop); 

Run your queries in SQL on steroids (and you can use parameters for more flexibility):
Running query for a complex object.

   1:     Parameters param = db.CreateParameters();

   2:     param["customerCountry"] = "Australia";

   3:   

   4:   

   5:     var complexData = db.ExecuteScalar("SELECT TOP 1 Shop" +

   6:                                        " WHERE Customer.Country = @customerCountry" +

   7:                                        " ORDER BY TotalAmount DESC", param);

And you can use joins if your objects don't have relations:
Joins in Eloquera queries.

   1:     var complexData = db.ExecuteQuery("SELECT school, wplace FROM School school" +

   2:                                       " INNER JOIN WorkPlace wplace" +

   3:                                       " ON ch.Location.City=wp.Location.City");

   4:   

   5:   

   6:     foreach(var item in complexData)

   7:     {

   8:        var pair = (IDictionary<string, object>)item;

   9:        Console.WriteLine("School {0} and company {1} are both located at {2}", 

  10:                           pair["school"], 

  11:                           pair["wplace"], 

  12:                           ((School)pair["school"]).Location.City);

  13:     }