Lesson 3
Polymorphism and Backward Compatibility in C#
Introduction

Hello, learner! In today's exciting chapter, we will unravel Polymorphism, a prominent feature of Object-Oriented Programming (OOP). Specifically, we will study its role in maintaining backward compatibility while introducing new features. Think of it as a software update that introduces new functions without breaking the older functionality — ingenious, isn't it?

Understanding Polymorphism

Polymorphism, a principle that derives from the Greek words "poly" (many) and "morphism" (forms), enables a variable or method to assume multiple roles — to embody various behaviors or functions determined by its data type or class.

Consider a class Bird with a method CanFly(). If we create subclasses like Sparrow and Penguin, we can override the CanFly() method for certain subclasses. This demonstrates polymorphism in action.

C#
1class Bird // Superclass 2{ 3 public virtual string CanFly() 4 { 5 return "Unknown"; 6 } 7} 8 9class Sparrow : Bird // Subclass 10{ 11 public override string CanFly() 12 { 13 return "Yes, I can fly!"; 14 } 15} 16 17class Penguin : Bird // Subclass 18{ 19 public override string CanFly() 20 { 21 return "No, I prefer swimming."; 22 } 23} 24 25class Program 26{ 27 static void Main(string[] args) 28 { 29 Sparrow sparrow = new Sparrow(); 30 Penguin penguin = new Penguin(); 31 Console.WriteLine("Sparrow says: " + sparrow.CanFly()); // Output: "Yes, I can fly!" 32 Console.WriteLine("Penguin says: " + penguin.CanFly()); // Output: "No, I prefer swimming." 33 } 34}
Polymorphism for Backward Compatibility

When adding new features, which introduce new behaviors to some components, polymorphism ensures that the existing parts function as before, thereby retaining backward compatibility. In complex cases, we maintain an older version of the method in the superclass for legacy support while offering newer functionalities in subclasses.

Take, for instance, a MathOperations class with a Multiply() method that accepts two parameters. To support the multiplication of three numbers, we design a subclass, ExtendedMathOperations, and include a new overloaded Multiply() method in it, ensuring backward compatibility.

C#
1class MathOperations // Superclass 2{ 3 public virtual int Multiply(int a, int b) 4 { 5 return a * b; 6 } 7} 8 9class ExtendedMathOperations : MathOperations // Subclass 10{ 11 public override int Multiply(int a, int b) 12 { 13 return a * b; 14 } 15 16 public int Multiply(int a, int b, int c) 17 { 18 return a * b * c; 19 } 20} 21 22class Program 23{ 24 static void Main(string[] args) 25 { 26 MathOperations mathOps = new MathOperations(); 27 ExtendedMathOperations extendedMathOps = new ExtendedMathOperations(); 28 Console.WriteLine(mathOps.Multiply(2, 3)); // Output: 6 29 Console.WriteLine(extendedMathOps.Multiply(2, 3)); // Output: 6, keeping backward compatibility 30 Console.WriteLine(extendedMathOps.Multiply(2, 3, 4)); // Output: 24 31 } 32}
Real-Life Examples

Consider a Document class that prints a text document and a subclass PhotoDocument, which supports color prints, as an example. This design allows the implementation without changing Document.PrintDoc().

C#
1class Document 2{ 3 public string Text { get; set; } 4 5 public Document(string text) 6 { 7 this.Text = text; 8 } 9 10 public virtual void PrintDoc() 11 { 12 Console.WriteLine("Printing document: " + this.Text); 13 } 14} 15 16class PhotoDocument : Document 17{ 18 public PhotoDocument(string text) : base(text) { } 19 20 public void PrintDoc(bool isColourPrint) 21 { 22 string printType = isColourPrint ? "Colour " : ""; 23 Console.WriteLine(printType + "Printing document: " + this.Text); 24 } 25 26 // Overloading to match the superclass method 27 public override void PrintDoc() 28 { 29 base.PrintDoc(); 30 } 31} 32 33class Program 34{ 35 static void Main(string[] args) 36 { 37 Document doc = new Document("Hello"); 38 doc.PrintDoc(); // Output: Printing document: Hello 39 40 PhotoDocument photoDoc = new PhotoDocument("Beautiful Sunset!"); 41 photoDoc.PrintDoc(); // Output: Printing document: Beautiful Sunset! 42 photoDoc.PrintDoc(true); // Output: Colour Printing document: Beautiful Sunset! 43 } 44}
Pros and Cons of Using Polymorphism for Backward Compatibility

As with any programming approach, using polymorphism to maintain backward compatibility comes with its own set of advantages and disadvantages. Here, we will explore two key pros and two cons to give you a more balanced understanding.

Pros

  1. Flexibility in Feature Expansion: Polymorphism allows for easy extension and addition of new features without altering the existing system's functionality. This means developers can introduce new subclasses that provide enhanced features while the original classes remain unaffected and continue to support legacy systems.

  2. Seamless Integration with Existing Codebase: Since polymorphism enables new features to coexist with older ones through subclassing, integrating these features into the existing codebase does not disrupt the functionality of legacy systems. This approach minimizes the risk of breaking changes and ensures a smoother transition for systems adopting new features.

Cons

  1. Increased Complexity: While polymorphism promotes flexibility and integration, it can also lead to a more complex codebase. Developers must understand the entire hierarchy and relationships between classes to effectively implement and maintain the system. This complexity might slow down development and increase the likelihood of errors.

  2. Potential Overhead in Performance: The use of polymorphism, especially when it involves a deep class hierarchy or extensive method overriding, might introduce runtime overhead. This is because the program needs to determine the correct method to execute dynamically at runtime, which could impact performance, particularly in systems where efficiency is critical.

Understanding these pros and cons is essential for making informed decisions when considering polymorphism as a strategy for adding new features while keeping backward compatibility.

Lesson Summary

You have aced understanding of polymorphism and its role in maintaining backward compatibility. Now, gear up for insightful exercises to reinforce today's learning. Regular application is the key to mastering these concepts. Are you ready to put your skills to the test? Let's go!

Enjoy this lesson? Now it's time to practice with Cosmo!
Practice is how you turn knowledge into actual skills.