C# 2008 Programmer's Reference

//---error---
IPerson person = new IPerson();

Interface Naming Convention

By convention, begin the name of an interface with a capital I (such as IPerson, IManager, IEmployee, and so on) so that it is clear that you are dealing with an interface.

Implementing an Interface

Once an interface is defined, you can create a new class to implement it. The class that implements that particular interface must provide all the implementation for the members defined in that interface.

For example, here's an Employee class that implements the IPerson interface:

public class Employee : IPerson {
 public string Name { get; set; }
 public DateTime DateofBirth { get; set; }
 public ushort Age() {
  return (ushort)(DateTime.Now.Year - this.DateofBirth.Year);
 }
}

To implement an interface, you define your class and add a colon (:) followed by the interface name:

public class Employee : IPerson

You then provide the implementation for the various members:

{
 public string Name { get; set; }
 public DateTime DateofBirth { get; set; }
 public ushort Age() {
  return (ushort)(DateTime.Now.Year - this.DateofBirth.Year);
 }

Notice that I'm using the new automatic properties feature (discussed in Chapter 4) in C# 3.0 to implement the Name and DateofBirthproperties. That's why the implementation looks the same as the declaration in the interface.

As explained, all implemented members must have the public access modifiers.

You can now use the class as you would a normal class:

Employee e1 = new Employee();
e1.DateofBirth = new DateTime(1980, 7, 28);
el.Name = 'Janet';
Console.WriteLine(e1.Age()); //---prints out 28---

This could be rewritten using the new object initializer feature (also discussed in Chapter 4) in C# 3.0:

Employee el = new Employee() {
 DateofBirth = new DateTime(1980, 7, 28),
 Name = 'Janet'
};
Console.WriteLine(e1.Age()); //---prints out 28---

Implementing Multiple Interfaces

A class can implement any number of interfaces. This makes sense because different interfaces can define different sets of behaviors (that is, members) and a class may exhibit all these different behaviors at the same time.

For example, the IPerson interface defines the basic information about a user, such as name and date of birth, while another interface such as IAddress can define a person's address information, such as street name and ZIP code:

interface IAddress {
 string Street { get; set; }
 uint Zip { get; set; }
 string State();
}

An employee working in a company has personal information as well as personal address information, and you can define an Employee class that implements both interfaces, like this:

public class Employee : IPerson, IAddress {
 //---implementation here---
}

The full implementation of the Employee class looks like this:

public class Employee : IPerson, IAddress {
 //---IPerson---
 public string Name { get; set; }
 public DateTime DateofBirth { get; set; }
 public ushort Age() {
  return (ushort)(DateTime.Now.Year - this.DateofBirth.Year);
 }
 //---IAddress---
 public string Street { get; set; }
 public uint Zip { get; set; }
 public string State() {
  //---some implementation here---
  return 'CA';
 }
}

You can now use the Employee class like this:

Employee e1 = new Employee() {
 DateofBirth = new DateTime(1980, 7, 28),
 Name = 'Janet',
 Zip = 123456,
 Street = 'Kingston Street'
};
Console.WriteLine(e1.Age());
Console.WriteLine(e1.State());