9.2 Code With Intent

If interfaces don't implement or add any functionality, then why should we use them? Great question. Interface based design gives us several advantages, including easier maintainability, scalability (making it bigger or smaller), and lastly it makes your code more reusable and accessible because of this separation of concerns.

"Separation of Concerns (SoC) is a design principle for separating a computer program into distinct sections, such that each section addresses a separate concern. A concern is "a set of information that affects the code of a computer program." - Wikipedia

Interfaces define a contract or agreement between your application and the other objects. The contract will include what methods and properties are exposed to said objects. Even though the interface will not add any true functionality to these objects, it is benefitting you as a programmer to be planning ahead and coding with intent on exactly how you want your program to work.

For example, say you have a vehicle. All vehicles have similar characteristics but differ enough that we could us an interface that contracts the similarities. Vehicles will have certain differences such as some have 18 wheels, others have 4, others have 2, but they all move, all have an engine, and have doors. These items might be different from one vehicle to another. We can create an interface of vehicle that has these general properties, we can then inherit from the interface to implement them.

Interfaces help us create a layout for what our classes will look like and what they will implement. When dealing with bigger applications and when you use interfaces, it allows us, the programmer, to easily interchange one component for another that is using the same interface.

Let's look at a code example of a vehicle interface:

    namespace InterfaceExample
    {    
        public interface IVehicle    
            {        
                int Doors { get; set; }        
                int Wheels { get; set; }        
                Color VehicleColor { get; set; }        
                int TopSpeed { get; set; }        
                int Cylinders { get; set; }        
                int CurrentSpeed { get; }        
                string DisplayTopSpeed();        
                void Accelerate(int step);    
            }
    }

Properties of interface IVehicle	Methods of interface IVehicle
Doors	DisplayTopSpeed()
Wheels	Accelerate(int step)
Color
Top Speed
Cylinders
Current Speed

Now we can create a motorcycle class based on our IVehicle interface

    public class Motorcycle : IVehicle    
        {       
            private int _currentSpeed = 0;        
            public int Doors { get; set; }        
            public int Wheels { get; set; }        
            public Color VehicleColor { get; set; }        
            public int TopSpeed { get; set; }        
            public int HorsePower { get; set; }        
            public int Cylinders { get; set; }        
            public int CurrentSpeed        
                {            
                    get { return _currentSpeed; }        
                }      
            public Motorcycle(int doors, int wheels, Color color, int topSpeed, int horsePower, int cylinders, int currentSpeed)        
                {            
                    this.Doors = doors;            
                    this.Wheels = wheels;            
                    this.VehicleColor = color;            
                    this.TopSpeed = topSpeed;            
                    this.HorsePower = horsePower;            
                    this.Cylinders = cylinders;            
                    this._currentSpeed = currentSpeed;        
                }        
            public string DisplayTopSpeed()        
                {            
                    return "Top speed is: " + this.TopSpeed;        
                }        
            public void Accelerate(int step)        
                {            
                    this._currentSpeed += step;        
                }    
        }

We could interchange the Motorcycle class with the Truck class or Carr class and have the same functionality of IVehicle all within the same application.

Interface based development can make your life as a developer much easier, and your applications much cleaner, maintainable, and scalable.

Next: Date & Time