/// <summary>
/// Interfaces only describe the properties,
/// methods,and events that a class exposes for use.
/// Logic to implement these features is not allowed in
/// an interface.
/// </summary>
public interface IExample
{
  /// <summary>
  /// Example of a string property the implementing class
  /// must provide.
  /// </summary>
  string StringProperty { get; set; }
  /// <summary>
  /// Example of a read-only property.
  /// </summary>
  string ReadOnlyStringProperty { get; }
  /// <summary>
  /// Example of a method that accepts two parameters.
  /// </summary>
  int OperateOnTwoNumbers(int pNum1, int pNum2);
}

/// <summary>
/// An implementing class MUST provide the appropriate
/// items described in the interface or the project will not build.
/// The implementing class can add any additional
/// features deemed appropriate.
/// </summary>
public class Example : IExample
{
  /// <summary>
  /// Implement the StringProperty described in the interface.
  /// </summary>
  public string StringProperty { get; set; }
  /// <summary>
  /// The ReadOnlyStringProperty cannot have a public setter,
  /// but can have a private, protected, or internal setter.
  /// </summary>
  public string ReadOnlyStringProperty { get; internal set; }
  /// <summary>
  /// The implementing class must provide the method signatures
  /// described in the interface, though if no logic is
  /// added to the method, it will still build.
  /// </summary>
  public int OperateOnTwoNumbers(int pNum1, int pNum2)
  {
    return pNum1 + pNum2;
  }
  /// <summary>
  /// Any further customization of the implementing
  /// class is allowed.
  /// </summary>
  public bool MethodNotInTheInterface()
  {
    return true;
  }
}

/// <summary>
/// Implementing a method described in an interface does not
/// require that proper logic be added, only that the method
/// signature is provided.
/// </summary>
public int OperateOnTwoNumbers(int pNum1, int pNum2)
{
  throw new NotImplementedException("OperateOnTwoNumbers");
}

/// <summary>
/// This is an example of a class that uses the
/// interface we just created.
/// </summary>
public class BusinessLogic
{
  public int UseInterfaceImplementation()
  {
    //Though we are creating a real Example class, we
    //are assigning it to an IExample variable.
    IExample sampleClass = new Example();
    //We can use the variable reflecting the interface
    //as if it were the real class.
    return sampleClass.OperateOnTwoNumbers(1, 2);
  }
}

/// <summary>
/// This is a second implementation of the IExample interface.
/// It has no relation to the other implementation and can
/// implement completely different logic.
/// </summary>
public class AlternateExample : IExample
{
  /// <summary>
  /// The string property is the same as the previous implementation.
  /// </summary>
  public string StringProperty { get; set; }
  /// <summary>
  /// The ReadOnlyStringProperty will always return the
  /// given value.
  /// </summary>
  public string ReadOnlyStringProperty
  {
    get { return "I'm an Alternate"; }
  }
  /// <summary>
  /// This method operates on the two inputs in a different
  /// way, returning a completely different result than our
  /// previous implementation.
  /// </summary>
  public int OperateOnTwoNumbers(int pNum1, int pNum2)
  {
    return pNum1 * pNum2;
  }
}