Topic 7218 min readStructured Tutorial

Compile-Time Polymorphism in C#

Quick Answer

Compile-time polymorphism in C# allows methods to have the same name but behave differently based on parameters, achieved through method overloading and operator overloading. It is resolved during compilation, improving code readability and flexibility.

Learning Objectives

Explain the purpose of Compile-Time Polymorphism in a practical learning context.
Identify the main ideas, terms, and decisions involved in Compile-Time Polymorphism.
Apply Compile-Time Polymorphism in a simple real-world scenario or practice task.

Introduction to Compile-Time Polymorphism

Polymorphism is a core concept in object-oriented programming that allows entities to take multiple forms.

In C#, compile-time polymorphism is a type of polymorphism resolved during compilation, primarily through method and operator overloading.

Understanding compile-time polymorphism helps write flexible and maintainable code.

Polymorphism allows one interface to control access to a general class of actions.

What is Compile-Time Polymorphism?

Compile-time polymorphism, also known as static polymorphism, is when the method to be invoked is determined at compile time.

This is typically achieved by defining multiple methods with the same name but different signatures within the same class.

Method Overloading: Same method name with different parameters.
Operator Overloading: Defining custom behavior for operators.

Method Overloading in C#

Method overloading allows multiple methods in the same class to share the same name but differ in parameter types or counts.

The compiler determines which method to call based on the method signature during compilation.

Methods must differ in parameter type, number, or order.
Return type alone cannot distinguish overloaded methods.

Example of Method Overloading

Below is a simple example demonstrating method overloading in C#.

Operator Overloading in C#

Operator overloading allows you to redefine the way operators work with user-defined types.

This enhances code readability and allows intuitive operations on custom classes.

Operators like +, -, == can be overloaded.
Operator overloading must be done using the 'operator' keyword.

Example of Operator Overloading

Here is an example showing how to overload the '+' operator for a custom class.

Practical Example

This class demonstrates method overloading with the 'Add' method accepting different parameter types and counts.

This example overloads the '+' operator to add two Point objects by summing their coordinates.

Examples

Method Overloading Example

public class Calculator {
    public int Add(int a, int b) {
        return a + b;
    }
    public double Add(double a, double b) {
        return a + b;
    }
    public int Add(int a, int b, int c) {
        return a + b + c;
    }
}

This class demonstrates method overloading with the 'Add' method accepting different parameter types and counts.

Operator Overloading Example

public class Point {
    public int X { get; set; }
    public int Y { get; set; }

    public Point(int x, int y) {
        X = x;
        Y = y;
    }

    public static Point operator +(Point p1, Point p2) {
        return new Point(p1.X + p2.X, p1.Y + p2.Y);
    }
}

This example overloads the '+' operator to add two Point objects by summing their coordinates.

Best Practices

Use method overloading to improve code readability and usability.
Ensure overloaded methods perform logically related operations.
Avoid overloading methods with ambiguous signatures.
Use operator overloading sparingly and only when it makes code more intuitive.

Common Mistakes

Overloading methods with only different return types (not allowed).
Creating overloaded methods with ambiguous parameter lists causing compiler errors.
Overusing operator overloading leading to confusing code.
Ignoring the principle of least surprise when overloading operators.

Hands-on Exercise

Create Overloaded Methods

Write a class with a method named 'Multiply' overloaded to handle two integers, two doubles, and three integers.

Expected output: A class with three 'Multiply' methods correctly overloaded.

Hint: Define multiple methods with the same name but different parameter lists.

Implement Operator Overloading

Create a class 'Rectangle' and overload the '+' operator to add the widths and heights of two rectangles.

Expected output: A Rectangle class with '+' operator overloaded to combine dimensions.

Hint: Use the 'operator' keyword and return a new Rectangle instance.

Interview Questions

What is compile-time polymorphism in C#?

Interview

Compile-time polymorphism is when the method to be called is determined during compilation, commonly achieved through method overloading and operator overloading.

Can methods be overloaded by only changing the return type?

Interview

No, methods cannot be overloaded by only changing the return type; their parameter lists must differ.

What is operator overloading?

Interview

Operator overloading allows custom implementation of operators for user-defined types to enable intuitive operations.