Interface Basics C# with Example

An Interface's function known as a "contract" of functionality. It means that it declares properties and methods but 
it doesn't implement them. 
So unlike classes Interfaces: 
Can't be instantiated 
Can't have any functionality 
Can only contain methods * (Properties and Events are methods internally) 
Inheriting an interface is called "Implementing" 
You can inherit from 1 class, but you can "Implement" multiple Interfaces 
public interface ICanDoThis{ 
void TheThingICanDo(); 
int SomeValueProperty { get; set; } 
} 
Things to notice: 
The "I" prefix is a naming convention used for interfaces. 
The function body is replaced with a semicolon ";". 
Properties are also allowed because internally they are also methods 
public class MyClass : ICanDoThis { 
public void TheThingICanDo(){ 
// do the thing 
} 
public int SomeValueProperty { get; set; } 
public int SomeValueNotImplemtingAnything { get; set; } 
} 
. 
ICanDoThis obj = new MyClass(); 
// ok 
obj.TheThingICanDo(); 
// ok 
obj.SomeValueProperty = 5; 
// Error, this member doesn't exist in the interface 
obj.SomeValueNotImplemtingAnything = 5; 
// in order to access the property in the class you must "down cast" it 
((MyClass)obj).SomeValueNotImplemtingAnything = 5; // ok 
This is especially useful when you're working with UI frameworks such as WinForms or WPF because it's mandatory 
to inherit from a base class to create user control and you loose the ability to create abstraction over different 
control types. An example? Coming up: 
public class MyTextBlock : TextBlock { 
public void SetText(string str){ 
this.Text = str; 
} 
 

} 
public class MyButton : Button { 
public void SetText(string str){ 
this.Content = str; 
} 
} 
The problem proposed is that both contain some concept of "Text" but the property names differ. And you can't 
create create a abstract base class because they have a mandatory inheritance to 2 different classes. An interface 
can alleviate that 
public interface ITextControl{ 
void SetText(string str); 
} 
public class MyTextBlock : TextBlock, ITextControl { 
public void SetText(string str){ 
this.Text = str; 
} 
} 
public class MyButton : Button, ITextControl { 
public void SetText(string str){ 
this.Content = str; 
} 
public int Clicks { get; set; } 
} 
Now MyButton and MyTextBlock is interchangeable. 
var controls = new List{ 
new MyTextBlock(), 
new MyButton() 
}; 
foreach(var ctrl in controls){ 
ctrl.SetText("This text will be applied to both controls despite them being different"); 
// Compiler Error, no such member in interface 
ctrl.Clicks = 0; 
// Runtime Error because 1 class is in fact not a button which makes this cast invalid 
((MyButton)ctrl).Clicks = 0; 
/* the solution is to check  the  type  first. 
This is usually considered bad practice since 
it's a symptom of poor abstraction */ 
var button = ctrl as MyButton; 
if(button != null) 
button.Clicks = 0; // no errors 
}