A better explanation of POCO

Question

I'm wondering if anyone can give a solid explanation (with example) of POCO (Plain Old CLR Object). I found a brief explanation on Wikipedia but it really doesn't give a solid explanation.

I'm looking for Pros/Cons... Implementation... Benefit... etc. Thanks in advance.

Answer 1

You need to give more details, such as the context in which you are planning to use POCO. But the basic idea is that you will create simple objects containing only the data/code that is necessary. These objects would not contain any "baggage" such as annotations, extra methods, base classes, etc that might otherwise be required by (for example) a framework.

Answer 2

Example of a POCO:

class Person {

    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string EmailAddress { get; set; }

}

Answer 3

Instead of calling them POCO's, i prefer to call them persistence ignorant objects.

Because their job is simple, they don't need to care about what they are being used for or how they are being used for.

Personally i think POCO's are just another buzzword (like Web 2.0 - don't get me started on that) for a public class with simple properties.

I've always been using these type of objects to hold onto business state.

The main benefit's of POCO's are really seen when you start to use things like the repository pattern, ORM's and dependency injection.

In other words - you could create an ORM (let's say EF) which pulls back data from somewhere (db, web service, etc), then project this data into objects (POCO's).

These objects can be passed further down the app stack to the service layer, then onto the web tier.

Then if one day you decide to switch over to nHibernate, you should not have to touch your POCO's at all, the only thing that should need to be changed is the ORM.

Hence the term 'persistence ignorant' - they don't care what they're being used for or how they are being used.

So to sum up, the pro's:

• Allows a simple storage mechanism for data, simplifies serialization/passing around through layers
• Goes hand in hand with depedency injection, repository pattern and ORM's. Flexibility.
• Minimized complexity and dependencies on other layers. (higher layer's only care about the POCO's, POCO's don't care about anything). Loose coupling
• Simple testability (no stubbing required for domain testing).

Hope that helps.