Originally Posted by Narue

Wow, I was just explaining interfaces to a coworker the other day. Freaky.

>Does any one know a robust benefit of using interfaces?
Consider the concept of data hiding. Let's say you want to provide a class to some client code, but don't want to give them full access. One way to restrict access without limiting the functionality of your class is to implement an interface and require the client code to get objects through a factory:

Help with Code Tags

C# Syntax (Toggle Plain Text)

using System;
 
namespace JSW {
	public class Program {
		static void Main() {
			IFoo myfoo = FooFactory.GetFoo();
			Bar mybar = new Bar();
 
			myfoo.Print();
			mybar.Print();
			mybar.Test();
		}
	}
 
	// Restricted type for clients
	public interface IFoo {
		void Print();
	}
 
	// Factory for clients
	public class FooFactory {
		public static IFoo GetFoo() {
			return new Bar();
		}
	}
 
	// Fully functional type for us
	internal class Bar: IFoo {
		public void Print() {
			Console.WriteLine( "Foo!" );
		}
 
		public void Test() {
			Console.WriteLine( "Test" );
		}
	}
}

using System; namespace JSW { public class Program { static void Main() { IFoo myfoo = FooFactory.GetFoo(); Bar mybar = new Bar(); myfoo.Print(); mybar.Print(); mybar.Test(); } } // Restricted type for clients public interface IFoo { void Print(); } // Factory for clients public class FooFactory { public static IFoo GetFoo() { return new Bar(); } } // Fully functional type for us internal class Bar: IFoo { public void Print() { Console.WriteLine( "Foo!" ); } public void Test() { Console.WriteLine( "Test" ); } } }

This is especially useful when interfacing with COM.

Another benefit of interfaces is team development. If you have a dozen programmers working on different pieces of code that need to connect, it's best to define interfaces for the connections. As long as the programmers write according to the interfaces, everything will link together nicely regardless of personal choices and style.

Yet another benefit is that with interfaces you can use a class without having defined it first. For example, if you have a class that does a lot of intricate work and won't be finished before the rest of the project, the rest of the project can use an interface to it and avoid being stalled by the development of that one class.

Personally, I like the guarantees that interfaces provide. If a class implements IDisposable, I know not only that the objects can be disposed without getting compiler errors, but that they should be disposed. This keeps my code consistent and robust. You can provide similar guarantees in your code simply by adhering to an interface.