With last week’s posts Announcing .NET Core 3.0 Preview 5<\/a> and Visual Studio 2019 version 16.1 Preview 3<\/a>, the last major feature of C# 8.0 is now available in preview.<\/p>\n A big impediment to software evolution has been the fact that you couldn’t add new members to a public interface. You would break existing implementers of the interface; after all they would have no implementation for the new member!<\/p>\n Default implementations help with that. An interface member can now be specified with a code body, and if an implementing class or struct does not provide an implementation of that member, no error occurs. Instead, the default implementation is used.<\/p>\n Let’s say that we offer the following interface:<\/p>\n An existing class, maybe in a different code base with different owners, implements Now we want to add another overload of the The Of course an implementing class that does know about the new member is free to implement it in its own way. In that case, the default implementation is just ignored.<\/p>\ninterface ILogger\r\n{\r\n void Log(LogLevel level, string message);\r\n}\r\n<\/pre>\nILogger<\/code>:<\/p>\nclass ConsoleLogger : ILogger\r\n{\r\n public void Log(LogLevel level, string message) { ... }\r\n}\r\n<\/pre>\nLog<\/code> method to the interface. We can do that without breaking the existing implementation by providing a default implementation – a method body:<\/p>\ninterface ILogger\r\n{\r\n void Log(LogLevel level, string message);\r\n void Log(Exception ex) => Log(LogLevel.Error, ex.ToString());\r\n}\r\n<\/pre>\nConsoleLogger<\/code> still satisfies the contract provided by the interface: if it is converted to the interface and the new Log method is called it will work just fine: the interface’s default implementation is just called:<\/p>\npublic static void LogException(ConsoleLogger logger, Exception ex)\r\n{\r\n ILogger ilogger = logger; \/\/ Converting to interface\r\n ilogger.Log(ex); \/\/ Calling new Log overload\r\n}\r\n<\/pre>\n