The syntax for defining an interface is very similar to the syntax for defining a class:

    [attributes] [access-modifier] interface interface-name [:base-list] {interface-body}

The optional attributes are well beyond the scope of this book (however, see the sidebar, "Attributes“).

Access modifiers (public, private, etc.) work just as they do with classes. (See Chapter 7 for more about access modifiers.) The interface keyword is followed by an identifier (the interface name). It is common (but not required) to begin the name of your interface with a capital I (IStorable , ICloneable, IGetNoKickFromChampagne, etc.). The optional base list is discussed later in this chapter.

    [NoIDispatch]

Attributes are most often used in one of two ways: either for interacting with legacy COM objects or for creating controls that will be fully recognized by the Visual Studio development environment. You can create your own custom attributes , but this is unusual and not covered in this book (for more on this, see Programming C#, Fourth Edition [O’Reilly, 2005]). Now suppose you are the author of a Document class, which specifies that Document objects can be stored in a database. You decide to have Document implement the IStorable interface. It isn’t required that you do so, but by implementing the IStorable interface, you signal to potential clients that the Document class can be used just like any other IStorable object. This will, for example, allow your clients to add your Document objects to an array of Notes

    IStorable[] myStorableArray = new IStorable[3];

and to otherwise interact with your Document in this very general and well-understood way.

To implement the IStorable interface, use the same syntax as if the new Document class were inheriting from IStorable—a colon (:) followed by the interface name:

    public class Document : IStorable

You can read this as “define a public class named Document that implements the IStorable interface.” The compiler distinguishes whether the colon indicates inheritance or implementation of an interface by checking to see if IStorable is defined, and whether it is an interface or base class.

    public MyBigClass : TheBaseClass, IPrintable, IStorable, IClaudius, IAndThou

Your definition of the Document class that implements the IStorable interface might look like this:

    public class Document : IStorable
    {
         public void Read(  ) {...}
         public void Write(object obj) {...}
         // ...
    }

It is now your responsibility, as the author of the Document class, to provide a meaningful implementation of the IStorable methods. Having designated Document as implementing IStorable, you must implement all the IStorable methods, or you will generate an error when you compile. Example 13-1 illustrates defining and implementing the IStorable interface.

using System;namespace InterfaceDemo
{

   interface IStorable
   {
      void Read(  );
      void Write( object obj );
      int Status { get; set; }

   }

   public class Document : IStorable
   {
      // store the value for the IStorable required property
      private int status = 0;

      public Document( string s )
      {
         Console.WriteLine( "Creating document with: {0}", s );
      }

#region IStorable

      public void Read(  )
      {
         Console.WriteLine(
         "Implementing the Read Method for IStorable" );
      }

      public void Write( object o )
      {
         Console.WriteLine(
         "Implementing the Write Method for IStorable" );
      }

      public int Status
      {
         get { return status; }
         set { status = value; }
      }
#endregion

   }

   class Tester
   {
      public void Run(  )
      {
         Document doc = new Document( "Test Document" );
         doc.Status = -1;
         doc.Read(  );
         Console.WriteLine( "Document Status: {0}", doc.Status );
      }

      static void Main(  )
      {
         Tester t = new Tester(  );
         t.Run(  );
      }
   }
}

The output looks like this:

    Creating document with: Test Document
    Implementing the Read Method for IStorable
    Document Status: -1

    interface IStorable
     {
         void Read(  );
         void Write(object obj);
         int Status { get; set; }
     }

    int Status { get; set; }

    IStorable myStorable = new Document(  );

    public class Document : IStorable
    {

    #region IStorable
      //...
    #endregion