C# Method and Parameter Variance

Method Combination

• Method combination occurs when two or more methods with the same name interact to solve a problem.
• Programmatic (imperative) control involves one method controlling the activation of another. Superclass control occurs when a method in a parent class activates a method in a child class, while subclass control is the reverse.
• Imperative method combination uses an overall pattern to manage the cooperation between methods. Methods do not call each other directly, and a separate abstraction manages how methods in different classes combine.
• Declarative method combination is supported in C# using the base.Op(...) notation.

Parameter Variance

• Parameter variance describes how parameters change in relation to the classes they belong to.
• Covariance means parameters vary in the same way as classes (e.g., if class A uses parameter S, and class B inherits from A and uses parameter T, T is equivalent to S).
• Contravariance means parameters vary in the opposite way as classes (e.g., if class A uses parameter S, and class B inherits from A and uses parameter T, T is a different type from S).

Abstract Classes

• Abstract classes define concepts that aren't fully implemented. They often have one or more abstract operations.
• Abstract operations have names and parameters but lack a body (implementation).
• Abstract classes cannot be instantiated.
• Abstract classes are designed to be completed in subclasses, where the abstract methods are defined.

Sealed Classes and Methods

• A sealed class cannot be inherited.
• Sealed classes prevent inheritance by other classes.
• Sealed classes also seal all virtual methods within the class.
• Methods marked as sealed cannot be redefined or overridden in subclasses.

Interfaces

• Interfaces define signatures of operations but don't implement them directly.
• Interfaces act as contracts, specifying a set of operations any implementing class must support.
• Classes and structures can implement multiple interfaces.
• Interfaces can be used as types, just like classes.
• Interface members can be organized in hierarchies.

Important Interfaces (C# Libraries)

• IComparable: An interface with a CompareTo method used in general sorting and searching.
• IEnumerable: An interface with a method for accessing an enumerator.
• IEnumerator: An interface with methods for traversing collections.
• IDisposable: An interface with a Dispose method for resource cleanup.
• ICloneable: An interface with a Clone method for creating copies.
• IFormattable: An interface with a ToString method for formatted string generation.

Explicit Interface Member Implementations

• Explicit interface implementations are used when an interface method has the same name as a class member.
• Explicitly implementing an interface member lets the compiler recognize the specific interface implementation rather than the class method.

Composite Design Pattern

• The composite design pattern groups objects into tree structures, treating both individual elements and groups of elements uniformly.
• Clients operate the same way with both leaf and composite nodes in the tree structure, offering flexible and modular components.

Cloning

• Cloning creates a copy of an existing object.
• Shallow cloning copies primitive types and references but not the objects referenced by the references.
• Deep cloning recursively creates copies of every referenced object.

Visitor Design Pattern

• The visitor design pattern allows external methods to operate on composite objects without making changes to the structure of the composite components. External methods call an accept method on a component, which then passes the visitor through all the items in the composite structure.

IntSequence Traversals

• Integer sequences can be represented as composites (trees) of integers, intervals, and more complex composites.

Consequences of Using a Visitor

• A new type of traversal can be added without affecting the composite.
• A visitor encapsulates traversal-specific methods.
• State related to a traversal can be managed within the visitor.
• Adding a new component class requires changes to the visitor classes.