db4o – Object Database for .Net

I have been using db4o (database for objects) for .Net for about a year and a half, and I have to tell you that you are doing yourself a disservice if you have not tried it, yet. It’s open source and it will save you tons of time. I will go into more detail in my upcoming book about Object Persistence including examples, but, db4o is one way to persist objects and that is by using an object database instead of a relational database.

If you have never used an object database before, think of it like this: you are already using .Net so you are already using objects. What you probably are not doing is using objects all the way to saving your “data”. At some point you have been messing with ugly SQL statements and maybe “mapping” objects or using a mapping layer. You may be using a “data layer” etc. All hog-wash!

db4o can save you about 50% of your development time. And that is a conservative estimate. I’ll be posting more including code in the upcoming months. Stay tuned.

Object Persistence

It’s been an awfully long time since my last post. I will try to update it more often with more fresh content and what’s hot in the .Net world. I have moved from South Florida to my new job in Charlotte, NC. So, we’ve been pretty busy getting settled in etc.

I’m currently working on several things including a book about Object Persistence. Object Persistence is such an important factor in an architecture. It amazes me how little attention it gets. Anyways, I have a lot of good experiences and knowledge that I want to share in my book.

Happy New Year!

Creating Data Transfer Objects – Part 2

I have updated the console application DTO to version 2.0 to use attributes now to decorate the domain classes for code generation. This offers much better control of which domain classes should be used to create the Data Transfer Object classes. In addition, you can also decorate generate public properties that use domain classes as a return value.  

For example, if you decorate the following sample domain classes below with the DTO attribute like so 


using DTOAttributes;
namespace Example
{   
   [DTOAttributes.DTO]   
   public enum CustomerType   
   {       
      Regular,       
      Special   
   }    [DTOAttributes.DTO]
   public class Customer
   {

The DTO console app will generate the following code:

public enum CustomerTypeDTO      
{             
   Regular,             
   Special,      
} 

public class CustomerDTO      
{             
   private List<EmailAddressDTO> _emails;
   [XmlElement(IsNullable = true)]
   public List<EmailAddressDTO> Emails
   {                    
      get { return _emails; }
      set { _emails = value; }
   } 

   private CustomerTypeDTO _type;
   [XmlElement(IsNullable = true)]
   public CustomerTypeDTO Type
   {                    
      get { return _type; }
      set { _type = value; }
   }

As you can see, it works pretty well. I’ve included the source code including the sample app. I’ve not update the CodeSmith template, yet as the console app is doing a fine job for me. For now. In my current project, this allows me to generate over 15,000 lines of code to create dozens of DTO classes automatically. Sweet! Enjoy!

You can download the new version here.

Creating Data Transfer Objects (DTO) with CodeSmith

I’ve created a template for CodeSmith to create Data Transfer Objects automatically by simply supplying the path and file to your domain model assembly file. This assembly should have all your business objects included. The template does the rest. I only spent two days on this but it works for the most part including generics. It basically uses reflection to create a DTO version of each business class.

 I was going to extend it by using Attributes to decorate class names as well as properties for your domain model; but, found that this current version fits my need at the moment.

Feel free to extend and enhance it. Let me know if you create a new version so that I can enjoy that as well.

You can download the file here.

UPDATE 07-15-2006: I have updated the template to support Enums. I also created a console app so that you can call this during your build process.