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.

Answer 1

Example of a POCO:

class Person {

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

}

Answer 2

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 3

Instead of calling them POCOs, 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.

Personally I think POCOs 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 benefits of POCOs are really seen when you start to use things like the repository pattern, ORMs 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 (POCOs).

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 POCOs 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 pros:

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

Hope that helps.