Introducing Interfaces

The IFileCompression interface shown in Listing 8.1 is an example of an interface implementation. By convention—a convention so strong it is universal—the interface name is PascalCase with a capital “I” prefix.

Listing 8.1: Defining an Interface

Click here to view code image

interface IFileCompression
{
  void Compress(string targetFileName, string[] fileList);
  void Uncompress(
      string compressedFileName, string expandDirectoryName);
}

IFileCompression defines the methods a type must implement to be used in the same manner as other compression-related classes. The power of interfaces is that they grant the ability to callers to switch among implementations without modifying the calling code.

Prior to C# 8.0, one of the key characteristics of an interface was that it had no implementation and no data. Method declarations in an interface always had a single semicolon in place of curly braces after the declaration. Properties, while looking like automatically implemented properties, had no backing fields. In fact, fields (data) could not appear in an interface declaration either.

Many of these rules were relaxed in C# 8.0 for the purposes of allowing interfaces to have some level of restricted changes after publishing. However, until the section “Interface Versioning in C# 8.0 or Later” in this chapter, we will ignore the new capabilities and discuss interfaces for the purposes of establishing polymorphism. This is where the real power of interfaces lies, and it is easier to discuss them in that context before opening up the new capabilities and describing the scenario for making an exception. So let’s stick with the simplification that interfaces cannot have any implementation (without even mentioning C# 8.0), and postpone the removal of that restriction until we explore the C# 8.0 capabilities.

The declared members of an interface describe the members that must be accessible on an implementing type. The purpose of nonpublic members is to make those members inaccessible to other code. Therefore, C# does not allow access modifiers on interface members; instead, it automatically defines them as public.

Polymorphism through Interfaces

Consider another example, as shown in Listing 8.2: IListable defines the members that a class needs to support if the ConsoleListControl class is to display it. As such, any class that implements IListable can use the ConsoleListControl to display itself. The IListable interface requires a read-only property, CellValues.

Listing 8.2: Implementing and Using Interfaces

Click here to view code image

interface IListable
{
  // Return the value of each cell in the row
    string?[] CellValues { get; }                                                    
}
public abstract class PdaItem
{
  public PdaItem(string name)
  {f
      Name = name;
  }

  public virtual string Name{get;set;}
}
class Contact : PdaItem, IListable
{
  public Contact(string firstName, string lastName,
      string address, string phone) :
      base(GetName(firstName, lastName))
  {
      FirstName = firstName;
      LastName = lastName;
      Address = address;
      Phone = phone;
  }

  protected string LastName {  get; }
  // ...
  protected string FirstName {  get; }
  public string? Address { get; }
  public string? Phone { get; }
  public static string GetName(string firstName, string lastName)
    => $"{ firstName } { lastName }";

  public string?[] CellValues                                                
  {                                                                          
      get                                                                    
      {                                                                      
          return new string?[]                                               
          {                                                                  
                FirstName,                                                   
                LastName,                                                    
                Phone,                                                       
                Address                                                      
          };                                                                 
      }                                                                      
  }                                                                          

  public static string[] Headers
  {
      get
      {
          return new string[] {
              "First Name", "Last Name    ",
              "Phone       ",
              "Address                       " };
      }
  }

  // ...
}
class Publication : IListable
{
  public Publication(string title, string author, int year)
  {
      Title = title;
      Author = author;
      Year = year;
  }

  public string Title { get; }
  public string Author { get; }
  public int Year { get; }
  public string?[] CellValues                                                
  {                                                                          
      get                                                                    
      {                                                                      
          return new string?[]                                               
          {                                                                  
              Title,                                                         
              Author,                                                        
              Year.ToString()                                                
          };                                                                 
      }                                                                      
  }                                                                          

  public static string[] Headers
  {
      get
      {
          return new string[] {
              "Title                                ",
              "Author             ",
              "Year" };
      }
  }

  // ...
}
class Program
{
  public static void Main()
  {
      Contact[] contacts = new Contact[]
      {
          new Contact(
              "Dick", "Traci",
              "123 Main St., Spokane, WA  99037",
              "123-123-1234"),
          new Contact(
              "Andrew", "Littman",
              "1417 Palmary St., Dallas, TX 55555",
              "555-123-4567"),
          new Contact(
              "Mary", "Hartfelt",
              "1520 Thunder Way, Elizabethton, PA 44444",
              "444-123-4567"),
          new Contact(
              "John", "Lindherst",
              "1 Aerial Way Dr., Monteray, NH 88888",
              "222-987-6543"),
          new Contact(
              "Pat", "Wilson",
              "565 Irving Dr., Parksdale, FL 22222",
              "123-456-7890"),
          new Contact(
              "Jane", "Doe",
              "123 Main St., Aurora, IL 66666",
              "333-345-6789")
      };

      // Classes are implicitly convertible to
      // their supported interfaces
      ConsoleListControl.List(Contact.Headers, contacts);

      Console.WriteLine();

      Publication[] publications = new Publication[3] {
          new Publication(
              "The End of Poverty: Economic Possibilities for Our Time",
              "Jeffrey Sachs", 2006),
          new Publication("Orthodoxy",
              "G.K. Chesterton", 1908),
          new Publication(
              "The Hitchhiker's Guide to the Galaxy",
              "Douglas Adams", 1979)
          };
      ConsoleListControl.List(
          Publication.Headers, publications);
  }
}
class ConsoleListControl
{
    public static void List(string[] headers, IListable[] items)
    {
        int[] columnWidths = DisplayHeaders(headers);

        for (int count = 0; count < items.Length; count++)
        {
            string?[] values = items[count].CellValues;                   
            DisplayItemRow(columnWidths, values);
        }
    }

    /// <summary>Displays the column headers</summary>
    /// <returns>Returns an array of column widths</returns>
    private static int[] DisplayHeaders(string[] headers)
    {
        // ...
    }

    private static void DisplayItemRow(
        int[] columnWidths, string?[] values)
    {
        // ...
    }
}

The results of Listing 8.2 appear in Output 8.1.

Output 8.1

Click here to view code image

First Name  Last Name      Phone         Address
Dick        Traci          123-123-1234  123 Main St., Spokane, WA  99037
Andrew      Littman        555-123-4567  1417 Palmary St., Dallas, TX 55555
Mary        Hartfelt       444-123-4567  1520 Thunder Way, Elizabethton, PA 44444
John        Lindherst      222-987-6543  1 Aerial Way Dr., Monteray, NH 88888
Pat         Wilson         123-456-7890  565 Irving Dr., Parksdale, FL 22222
Jane        Doe            333-345-6789  123 Main St., Aurora, IL 66666

Title                                                    Author             Year
The End of Poverty: Economic Possibilities for Our Time  Jeffrey Sachs      2006
Orthodoxy                                                G.K. Chesterton    1908
The Hitchhiker's Guide to the Galaxy                     Douglas Adams      1979

In Listing 8.2, the ConsoleListControl can display seemingly unrelated classes (Contact and Publication). Any class can be displayed provided that it implements the required interface. As a result, the ConsoleListControl.List() method relies on polymorphism to appropriately display whichever set of objects it is passed. Each class has its own implementation of CellValues, and converting a class to IListable still allows the particular class’s implementation to be invoked.

Interface Implementation

Declaring a class to implement an interface is similar to deriving from a base class: The implemented interfaces appear in a comma-separated list along with the base class. The base class specifier (if there is one) must come first, but otherwise order is not significant. Classes can implement multiple interfaces but may derive directly from only one base class. An example appears in Listing 8.3.

Listing 8.3: Implementing an Interface

Click here to view code image

public class Contact : PdaItem, IListable, IComparable
{
  // ...

  #region IComparable Members
  /// <summary>
  ///
  /// </summary>
  /// <param name="obj"></param>
  /// <returns>
  /// Less than zero:      This instance is less than obj
  /// Zero                 This instance is equal to obj
  /// Greater than zero    This instance is greater than obj
  /// </returns>
  public int CompareTo(object? obj) => obj switch
  {
      null => 1,
      Contact contact when ReferenceEquals(this, contact) => 0,
      Contact { LastName: string lastName }
          when LastName.CompareTo(lastName) != 0 =>
              LastName.CompareTo(lastName),
      Contact { FirstName: string firstName }
          when FirstName.CompareTo(firstName) != 0 =>
              FirstName.CompareTo(firstName),
      Contact _ => 0,
      _ => throw new ArgumentException(
          $"The parameter is not a value of type { nameof(Contact) }",
          nameof(obj))
  };
  #endregion

  #region IListable Members
  string?[] IListable.CellValues                                              
  {
      get
      {
          return new string?[]
          {
              FirstName,
              LastName,
              Phone,
              Address
          };
      }
  }
  #endregion
}

Once a class declares that it implements an interface, all (abstract¹) members of the interface must be implemented. An abstract class is permitted to supply an abstract implementation of an interface member. A non-abstract implementation may throw a NotImplementedException type exception in the method body, but an implementation of the member must always be supplied.

1. The capability of adding nonabstract members to an interface was added in C# 8.0 but is essentially ignored until the end of the chapter.

One important characteristic of interfaces is that they can never be instantiated; you cannot use new to create an interface, so interfaces do not have instance constructors or finalizers. Interface instances are available only by instantiating a type that implements the interface. Furthermore, interfaces cannot include static members.² One key interface purpose is polymorphism, and polymorphism without an instance of the implementing type has little value.

2. Before C# 8.0.

Each (non-implemented³) interface member is abstract, forcing the derived class to implement it. Therefore, it is not possible to use the abstract modifier on interface members explicitly.⁴

3. Only available in C# 8.0 or later.

4. Before C# 8.0.

When implementing an interface member in a type, there are two ways to do so: explicitly or implicitly. So far, we’ve seen only implicit implementations, where the type member that implements the interface member is a public member of the implementing type.

string?[] values;
Contact contact = new Contact("Inigo Montoya");

// ...

// ERROR:  Unable to call CellValues() directly
//         on a contact
// values = contact.CellValues;

// First cast to IListable
values = ((IListable)contact).CellValues;                                    
// ...

public class Contact : PdaItem, IListable, IComparable
{
  // ...

  #region IListable Members
  string?[] IListable.CellValues                                 
  {
      get
      {
          return new string?[]
          {
              FirstName,
              LastName,
              Phone,
              Address
          };
      }
  }
  #endregion
}

result = contact1.CompareTo(contact2);

Converting between the Implementing Class and Its Interfaces

Just as with a derived type and a base class, a conversion from an implementing type to its implemented interface is an implicit conversion. No cast operator is required because an instance of the implementing type will always provide all the members in the interface; therefore, the object can always be converted successfully to the interface type.

Although the conversion will always be successful from the implementing type to the implemented interface, many different types could implement a particular interface. Consequently, you can never be certain that a “downward” cast from an interface to one of its implementing types will be successful. Therefore, converting from an interface to one of its implementing types requires an explicit cast.

Interface Inheritance

Interfaces can derive from each other, resulting in an interface that inherits all the members⁵ in its base interfaces. As shown in Listing 8.6, the interfaces directly derived from IReadableSettingsProvider are the explicit base interfaces.

5. Except C# 8.0’s introduced non-private members.

Listing 8.6: Deriving One Interface from Another

Click here to view code image

interface IReadableSettingsProvider
{
    string GetSetting(string name, string defaultValue);
}
interface ISettingsProvider : IReadableSettingsProvider
{
    void SetSetting(string name, string value);
}
class FileSettingsProvider : ISettingsProvider
{
    #region ISettingsProvider Members
    public void SetSetting(string name, string value)
    {
        // ...
    }
    #endregion

    #region IReadableSettingsProvider Members
    public string GetSetting(string name, string defaultValue)
    {
        // ...
    }
    #endregion
}

In this case, ISettingsProvider is derived from IReadableSettingsProvider and therefore inherits its members. If IReadableSettingsProvider also had an explicit base interface, ISettingsProvider would inherit those members as well, and the full set of interfaces in the derivation hierarchy would simply be the accumulation of base interfaces.

Note that if GetSetting() is implemented explicitly, it must be done using IReadableSettingsProvider. The declaration with ISettingsProvider in Listing 8.7 will not compile.

Listing 8.7: Explicit Member Declaration without the Containing Interface (Failure)

Click here to view code image

// ERROR:  GetSetting() not available on ISettingsProvider
string ISettingsProvider.GetSetting(
  string name, string defaultValue)
{
  // ...
}

The results of Listing 8.7 appear in Output 8.2.

Output 8.2

Click here to view code image

'ISettingsProvider.GetSetting' in explicit interface declaration
is not a member of interface.Inigo Montoya: Enough to survive on

This output appears in addition to an error indicating that IReadableSettingsProvider.GetSetting() is not implemented. The fully qualified interface member name used for explicit interface member implementation must reference the interface name in which it was originally declared.

Even though a class implements an interface (ISettingsProvider) that is derived from a base interface (IReadableSettingsProvider), the class can still declare an implementation of both interfaces overtly, as Listing 8.8 demonstrates.

Listing 8.8: Using a Base Interface in the Class Declaration

Click here to view code image

class FileSettingsProvider : ISettingsProvider,
     IReadableSettingsProvider                                      
{
    #region ISettingsProvider Members
    public void SetSetting(string name, string value)
    {
        // ...
    }
    #endregion

    #region IReadableSettingsProvider Members
    public string GetSetting(string name, string defaultValue)
    {
        // ...
    }
    #endregion
}

In this listing, there is no change to the interface’s implementations on the class. Although the additional interface implementation declaration on the class header is superfluous, it provides for better readability.

The decision to provide multiple interfaces rather than just one combined interface depends largely on what the interface designer wants to require of the implementing class. By providing an IReadableSettingsProvider interface, the designer communicates that implementers are required only to implement a settings provider that retrieves settings; they do not have to be able to write to those settings. This reduces the implementation burden by not imposing the complexities of writing settings as well.

In contrast, implementing ISettingsProvider assumes that there is never a reason to have a class that can write settings without reading them. The inheritance relationship between ISettingsProvider and IReadableSettingsProvider, therefore, forces the combined total of both interfaces on the ISettingsProvider class.

One final but important note: Although inheritance is the correct term, conceptually it is more accurate to say that an interface represents a contract, and one contract can specify that the provisions of another contract must also be followed. So, the code ISettingsProvider : IReadableSettingsProvider conceptually states that the ISettingsProvider contract requires also respecting the IReadableSettingsProvider contract, rather than that the ISettingsProvider “is a kind of” IReadableSettingsProvider. That being said, the remainder of the chapter will continue using the inheritance relationship terminology in accordance with the standard C# terminology.

Multiple Interface Inheritance

Just as classes can implement multiple interfaces, so interfaces can inherit from multiple interfaces. The syntax used for this purpose is consistent with class derivation and implementation, as shown in Listing 8.9.

Listing 8.9: Multiple Interface Inheritance

Click here to view code image

interface IReadableSettingsProvider
{
  string GetSetting(string name, string defaultValue);
}
interface IWriteableSettingsProvider
{
  void SetSetting(string name, string value);
}
interface ISettingsProvider : IReadableSettingsProvider,
    IWriteableSettingsProvider                                                       
{
}

It is unusual to have an interface with no members, but it is a reasonable choice when implementing both interfaces together. The difference between Listing 8.9 and Listing 8.6 is that it is now possible to implement IWriteableSettingsProvider without supplying any read capability. Listing 8.6’s FileSettingsProvider is unaffected. If it used explicit member implementation, however, specifying the interface to which a member belongs changes slightly.

Extension Methods on Interfaces

Perhaps one of the most important features of extension methods is the fact that they work with interfaces in addition to classes. The syntax used is identical to that used for extension methods for classes. The extended type (the first parameter and the parameter prefixed with this) is the interface that we extend. Listing 8.10 shows an extension method for IListable() that is declared on the Listable class.

Listing 8.10: Interface Extension Methods

Click here to view code image

class Program
{
  public static void Main()
  {
      Contact[] contacts = new Contact[] {
          new Contact(
              "Dick", "Traci",
              "123 Main St., Spokane, WA  99037",
              "123-123-1234")
           // ...
      };

      // Classes are implicitly converted to                                    
      // their supported interfaces                                             
      contacts.List(Contact.Headers);                                           

      Console.WriteLine();

      Publication[] publications = new Publication[3] {
          new Publication(
              "The End of Poverty: Economic Possibilities for Our Time",
              "Jeffrey Sachs", 2006),
          new Publication("Orthodoxy",
              "G.K. Chesterton", 1908),
          new Publication(
              "The Hitchhiker's Guide to the Galaxy",
              "Douglas Adams", 1979)
          };
      publications.List(Publication.Headers);                                   
  }
}

static class Listable
{
  public static void List(                                                      
      this IListable[] items, string?[] headers)                                
  {
      int[] columnWidths = DisplayHeaders(headers);
      for (int itemCount = 0; itemCount < items.Length; itemCount++)
      {
          string?[] values = items[itemCount].CellValues;

          DisplayItemRow(columnWidths, values);
      }
  }
  // ...
}

In this example, the extension method is not for an IListable parameter (although it could have been), but rather for an IListable[] parameter. This demonstrates that C# allows extension methods not only on an instance of a particular type but also on a collection of those objects. Support for extension methods is the foundation on which the Language Integrated Query (LINQ) capability is implemented. IEnumerable is the fundamental interface that all collections implement. By defining extension methods for IEnumerable, LINQ support was added to all collections. This radically changed programming with collections. We explore this topic in detail in Chapter 15.

Versioning

Prior to C# 8.0, when creating a new version of a component or application that other developers have programmed against, you should not change interfaces. Because interfaces define a contract between the implementing class and the class using the interface, changing the interface is equivalent to changing the contract, which will possibly break any code written against the interface.

Changing or removing an interface member signature is obviously a code-breaking change, as any call to that member will no longer compile without modification. The same is true when you change public or protected member signatures on a class. However, unlike with classes, adding members to an interface could also prevent code from compiling without additional changes. The problem is that any class implementing the interface must do so entirely, and implementations for all members must be provided. With new interface members, the compiler will require that developers add new interface members to the class implementing the interface.

With C# 8.0, the “don’t change interfaces” rule changes slightly. C# 8.0 added a mechanism for enabling a default implementation for an interface member, such that adding a member (you still can’t remove or modify an existing member in a version-compatible way) will not trigger compiler errors on all implementations. Prior to C# 8.0, there is a way to achieve a similar result to changing an interface by adding an additional interface. In this section, we discuss both approaches.

interface IDistributedSettingsProvider : ISettingsProvider
{
  /// <summary>
  /// Get the settings for a particular URI.
  /// </summary>
  /// <param name="uri">
  /// The URI the setting is related to.</param>
  /// <param name="name">The name of the setting.</param>
  /// <param name="defaultValue">
  /// The value returned if the setting is not found.</param>
  /// <returns>The specified setting.</returns>
  string GetSetting(
      string uri, string name, string defaultValue);

  /// <summary>
  /// Set the settings for a particular URI.
  /// </summary>
  /// <param name="uri">
  /// The URI name the setting is related to.</param>
  /// <param name="name">The name of the setting.</param>
  /// <param name="value">The value to be persisted.</param>
  /// <returns>The specified setting.</returns>
  void SetSetting(
      string uri, string name, string value);
}

public interface IListable
{
    // Return the value of each cell in the row
    string?[] CellValues { get; }

    ConsoleColor[] CellColors                                          
    {                                                                  
        get                                                            
        {
            var result = new ConsoleColor[CellValues.Length];
            // Using generic Array method to populate array
            // (see Chapter 12)
            Array.Fill(regit sult, DefaultColumnColor);
            return result;
        }
    }
    public static ConsoleColor DefaultColumnColor { get; set; }        
}

public class Contact : PdaItem, IListable
{
  //...

  #region IListable
  public string[] CellValues
  {
      get
      {
          return new string[]
          {
              FirstName,
              LastName,
              Phone,
              Address
          };
      }
  }
  // *** No CellColors implementation *** //                            
  #endregion IListable
{

public class Publication : IListable
{
  //...

    #region IListable
    string?[] IListable.CellValues
    {
        get
        {
            return new string?[]
            {
                Title,
                Author,
                Year.ToString()
            };
        }
    }
    ConsoleColor[] IListable.CellColors                                 
    {                                                                   
        get                                                             
        {                                                               
            string?[] columns = ((IListable)this).CellValues;           
            ConsoleColor[] result = ((IListable)this).CellColors;       
            if (columns[YearIndex]?.Length != 4)                        
            {                                                           
                result[YearIndex] = ConsoleColor.Red;                   
            }                                                           
            return result;                                              
        }                                                               

    }
    #endregion IListable
    // ...
}

public interface ISampleInterface
{
  private static string? _Field;
  public static string? Field
  {
      get => _Field;
      private set => _Field = value; }
      static IsampleInterface() =>
           Field = "Nelson Mandela";
    public static string? GetField() => Field;
}

public interface IPerson
{
  // Standard abstract property definitions
  string FirstName { get; set; }
  string LastName { get; set; }
  string MiddleName { get; set; }

  // Implemented instance properties and methods
  public string Name => GetName();
  public string GetName() =>
      $"{FirstName} {LastName}";
}
public class Person
{
  // ...
}
public class Program
{
  public static void Main()
  {
      Person inigo = new Person("Inigo", "Montoya");
      Console.Write(
          ((IPerson)inigo).Name);
  }
}

public interface IPerson
{
  // All members are public by default
  string FirstName { get; set; }
  public string LastName { get; set; }
  string Initials =>
      $"{FirstName[0]}{LastName[0]}";
  public string Name => GetName();
  public string GetName() =>
      $"{FirstName} {LastName}";
}

public interface IPerson
{
  string FirstName { get; set; }
  string LastName { get; set; }
  string Name => GetName();
  private string GetName() =>
      $"{FirstName} {LastName}";
}

public interface IPerson
{
  string FirstName { get; set; }
  string LastName { get; set; }
  string Name => GetName();
  internal string GetName() =>
      $"{FirstName} {LastName}";
}

public interface IPerson
{
  string FirstName { get; set; }
  string LastName { get; set; }
  string Name => GetName();
  protected internal string GetName() =>
      $"{FirstName} {LastName}";
}

class Program
{
  static void Main()
  {
      IPerson? person = null;
      // Non-deriving classes cannot call
      // private protected member.
      // _ = person?.GetName();
      Console.WriteLine(person);
  }
}
public interface IPerson
{
  string FirstName { get; }
  string LastName { get; }
  string Name => GetName();
  private protected string GetName() =>
      $"{FirstName} {LastName}";
}
public interface IEmployee: IPerson
{
  int EmpoyeeId => GetName().GetHashCode();
}
public class Person : IPerson
{
  public Person(
      string firstName, string lastName)
  {
      FirstName = firstName ??
          throw new

ArgumentNullException(nameof(firstName));
      LastName = lastName ??
          throw new


ArgumentNullException(nameof(lastName));
  }
  public string FirstName { get; }
  public string LastName { get; }

  // private protected interface members
  // are not accessible in derived classes.
  // public int PersonTitle =>
  //     GetName().ToUpper();
}

public interface IPerson
{
  // virtual is not allowed on members
  // without implementation
  /* virtual */ string FirstName { get; set; }
  string LastName { get; set; }
  virtual string Name => GetName();
  private string GetName() =>
      $"{FirstName} {LastName}";
}

public interface IWorkflowActivity
{
  // Private and, therefore, not virtual
  private void Start() =>
      Console.WriteLine(
          "IWorkflowActivity.Start()...");

  // Sealed to prevent overriding
  sealed void Run()
  {
      try
      {
          Start();
          InternalRun();
      }
      finally
      {
          Stop();
      }
  }

  protected void InternalRun();

  // Private and, therefore, not virtual
  private void Stop() =>
      Console.WriteLine(
          "IWorkflowActivity.Stop()..");
}

public interface IPerson
{
  // virtual is not allowed on members
  // without implementation
  /* virtual */ abstract string FirstName
    { get; set; }
  string LastName { get; set; }
  // abstract is not allowed on members
  // with implementation
  /* abstract */ string Name => GetName();
  private string GetName() =>
      $"{FirstName} {LastName}";
}

public partial interface IThing
{
  string Value { get; protected set; }
  void SetValue(string value)
  {
      AssertValueIsValid(value);
      Value = value;
  }

  partial void AssertValueIsValid(string value);
}

public partial interface IThing
{
  partial void AssertValueIsValid(string value)
  {
      // Throw if value is invalid.
      switch(value)
      {
          case null:
              throw new ArgumentNullException(
                  nameof(value));
          case "":
              throw new ArgumentException(
                  "Empty string is invalid",
                  nameof(value));
          case string _ when
              string.IsNullOrWhiteSpace(value):
              throw new ArgumentException(
                  "Can't be whitespace",
                  nameof(value));
      };
  }
}

public class WorkflowActivity
{
  private void Start()
  {
      // Critical code
  }
  public virtual void Run()
  {
      Start();
      // Do something...
      Stop();
  }
  private void Stop()
  {
      // Critical code
  }
}

public interface IWorkflowActivity
{
  // Private and, therefore, not virtual
  private void Start() =>
      Console.WriteLine(
          "IWorkflowActivity.Start()...");

  // Sealed to prevent overriding
  sealed void Run()
  {
      try
      {
          Start();
          InternalRun();
      }
      finally
      {
          Stop();
      }
  }
  protected void InternalRun();

  // Private and, therefore, not virtual
  private void Stop() =>
      Console.WriteLine(
          "IWorkflowActivity.Stop()..");
}

public interface IExecuteProcessActivity : IWorkflowActivity
{
  protected void RedirectStandardInOut() =>
      Console.WriteLine(
          "IExecuteProcessActivity.RedirectStandardInOut()...");

  // Sealed not allowed when overriding
  /* sealed */ void IWorkflowActivity.InternalRun()
  {
      RedirectStandardInOut();
      ExecutProcess();
      RestoreStandardInOut();
  }
  protected void ExecutProcess();
  protected void RestoreStandardInOut() =>
      Console.WriteLine(
          "IExecuteProcessActivity.RestoreStandardInOut()...");
}

class ExecuteProcessActivity : IExecuteProcessActivity
{
  public ExecuteProcessActivity(string executablePath) =>
      ExecutableName = executablePath
          ?? throw new ArgumentNullException(nameof(executablePath));

  public string  ExecutableName { get; }

  void IExecuteProcessActivity.RedirectStandardInOut()=>
      Console.WriteLine(
          "ExecuteProcessActivity.RedirectStandardInOut()...");

  void IExecuteProcessActivity.ExecutProcess() =>
      Console.WriteLine(
          $"ExecuteProcessActivity.IExecuteProcessActivity.
ExecutProcess()...");

  public void Run()
  {
      ExecuteProcessActivity activity
          = new ExecuteProcessActivity("dotnet");
      // Protected members cannot be invoked
      // by the implementing class even when
      //  implemented in the class.
      // ((IWorkflowActivity)this).InternalRun();
      //  activity.RedirectStandardInOut();
      //  activity.ExecuteProcss();
      Console.WriteLine(
          @$"Executing non-polymorphic Run() with process '{
              activity.ExecutableName}'.");
  }
}

public class Program
{
  public static void Main()
  {
      ExecuteProcessActivity activity
          = new ExecuteProcessActivity("dotnet");

      Console.WriteLine(
          "Invoking ((IExecuteProcessActivity)activity).Run()...");
      // Output:
      // Invoking ((IExecuteProcessActivity)activity).Run()...
      // IWorkflowActivity.Start()...
      // ExecuteProcessActivity.RedirectStandardInOut()...
      // ExecuteProcessActivity.IExecuteProcessActivity.ExecutProcess()...
      // IExecuteProcessActivity.RestoreStandardInOut()...
      // IWorkflowActivity.Stop()..
      ((IExecuteProcessActivity)activity).Run();

      // Output:
      // Invoking activity.Run()...
      // Executing non-polymorphic Run() with process 'dotnet'.
      Console.WriteLine();
      Console.WriteLine(
          "Invoking activity.Run()...");
      activity.Run();
  }
}

Invoking ((IExecuteProcessActivity)activity).Run()...
IWorkflowActivity.Start()...
ExecuteProcessActivity.RedirectStandardInOut()...
ExecuteProcessActivity.IExecuteProcessActivity.ExecutProcess()...
IExecuteProcessActivity.RestoreStandardInOut()...
IWorkflowActivity.Stop()..

Invoking activity.Run()...
Executing non-polymorphic Run() with process 'dotnet'.

Extension Methods versus Default Interface Members

When it comes to extending a published interface with additional functionality, when is a default interface member preferable to creating an extension method or creating a second interface that derives from the first and adds additional members? The following factors should be considered when making this decision:

• Both conceptually support overriding by implementing a method of the same signature on an instance of the interface.

• Extension methods can be added from outside the assembly that contains the interface definition.

• While default interface properties are allowed, there is no instance storage location available (fields are not allowed) for the property value, limiting the applicability to calculated properties.

• While there is no support for extension properties, calculations can be provided with “getter” extension methods (e.g., GetData()), without limiting them to .NET Core 3.0 or later frameworks.

• Providing a second derived interface supports defining both properties and methods without introducing a version incompatibility or a framework limitation.

• The derived interface approach requires implementing types to add the new interface and take advantage of the new capability.

• Default interface members can be invoked only from the interface type. Even implementing objects don’t have access to the default interface members without casting to the interface. In other words, default interface members behave like explicitly implemented interface members unless the base class provides an implementation.

• Protected virtual members can be defined on interfaces, but they are only available as such to deriving interfaces—not to classes implementing the interface.

• A default interface member may be overridden by the implementing classes, thereby allowing each class to define the behavior if desired. With extension methods, the binding is resolved based on the extension method being accessible at compile time. As a result, the implementation is determined at compile time instead of at runtime. With extension methods, therefore, the implementing class author can’t provide a different implementation for the method when it’s called from libraries. For example, System.Linq.Enumerable.Count() provides a special implementation index-based collection by casting to the list implementation to retrieve the count. As a result, the only way to take advantage of the improved efficiency is to implement a list-based interface. In contrast, with a default interface implementation, any implementing class could override this method to provide a better version.

In summary, adding property polymorphic behavior is only possible with a second interface or default interface members. And, if support for frameworks prior to .NET Core 3.0 is needed, creating a new interface is the preferred solution when adding properties. When only methods, and not properties, are part of the updated interface, extension methods are preferred.

Interfaces Compared with Abstract Classes

Interfaces introduce another category of data types. (They are one of the few categories of types that don’t extend System.Object.⁸) Unlike classes, however, interfaces can never be instantiated. An interface instance is accessible only via a reference to an object that implements the interface. It is not possible to use the new operator with an interface; therefore, interfaces cannot contain any instance constructors or finalizers. Prior to C# 8.0, static members are not allowed on interfaces.

8. The others are pointer types and type parameter types. However, every interface type is convertible to System.Object, and it is permissible to call the methods of System.Object on any instance of an interface, so perhaps this is a hairsplitting distinction.

Interfaces are similar to abstract classes, sharing such features as the lack of instantiation capability. Table 8.2 lists additional comparisons. Given that abstract classes and interfaces have their own sets of advantages and disadvantages, you must make a cost–benefit decision based on the comparisons in Table 8.2 and the guidelines that follow to make the right choice.

In summary, assuming a .NET Core 3.0 framework is acceptable, C# 8.0 (or later) defined interfaces have all the capabilities of abstract classes except the ability to declare an instance field. Given that an implementing type can override an interface’s property to provide storage, which the interface then leverages, interfaces virtually provide a superset of what an abstract class provides. Furthermore, interfaces support a more encapsulated version of protected access in addition to multiple inheritance. Therefore, it makes sense to favor using interfaces for all polymorphic behavior, thereby decoupling the contracts (what the type does) from the implementation details (how the type does it) for C# 8.0 and .NET Core 3.0 or later scenarios.

Interfaces Compared with Attributes

Interfaces with no members at all, inherited or otherwise, are sometimes used to represent information about a type. For example, you might create a marker IObsolete interface to indicate that a type has been replaced by another type. This is generally considered to be an abuse of the interface mechanism: Interfaces should be used to represent which functions a type can perform, not to indicate facts about particular types. Instead of marker interfaces, use attributes for this purpose. See Chapter 18 for more details.

Summary

Interfaces are a key element of object-oriented programming in C#. They provide polymorphic capabilities like abstract classes without using up the single-inheritance option, because classes can implement multiple interfaces. Starting with C# 8.0/.NET Core 3.0, interfaces can include implementation via the use of default interface members, almost giving them a superset of the capabilities of abstract classes if backward compatibility is not required.

In C#, the implementation of interfaces can be either explicit or implicit, depending on whether the implementing class is used to expose an interface member directly or only via a conversion to the interface. Furthermore, the granularity of whether the implementation is explicit or implicit is determined at the member level: One member may be implicitly implemented, while another member of the same interface is explicitly implemented.

Chapter 9 looks at value types and discusses the importance of defining custom value types. In addition, it points out the subtle problems that such types can introduce.