# CSharp Interface vs POCO

\#####Q: I would like to understand the difference between an Interface and a POCO in CSharp 10? Can you give examples of these two OO programming techniques and which to use when?

A: In C#, an Interface and a POCO (Plain Old C# Object) are two different programming concepts with distinct purposes.

1. Interface: An interface in C# is a contract that defines a set of members (methods, properties, events) that a class must implement. It allows classes to provide a specific behavior without inheriting from a base class. Here's an example of an interface definition:

```csharp
interface IQuackable
{
    void Quack();
}
```

In this example, any class that implements the `IQuackable` interface must provide an implementation of the `Quack()` method.

2. POCO (Plain Old C# Object): A POCO refers to a simple class in C# that doesn't have any special requirements or dependencies. It is a lightweight object that usually only contains properties to hold data. POCOs are often used to transfer data between different layers of an application (e.g., from the database to the UI). Here's an example of a POCO class:

```csharp
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}
```

In this example, the `Person` class is a POCO as it only contains properties to represent the data of a person.

When to use each:

* Use interfaces when you want to define a contract for common behavior that can be implemented by multiple classes. This allows for polymorphism and loose coupling, making your code more flexible and maintainable.
* Use POCOs when you need a simple class to hold data without any additional behavior or dependencies. POCOs are often used for data transfer objects (DTOs), entity models, or plain data structures.

In summary, interfaces define contracts for class behavior, while POCOs are simple classes used for data representation.
