Przeciążanie składowej oznacza tworzenie dwóch lub więcej składowych w ramach tego samego typu, różniących się jedynie ilością lub typem parametrów, ale posiadających tą samą nazwę.

Przeciążanie może dotyczyć:

1. Metody
2. Konstruktora instancyjnego
3. Indeksatora
4. Operatora

Przykłady jak to zrobić:

Metoda:

 class Answer
    {
        public int id { get; set; }
        public string Name { get; set; }

        public string FullAnswer { get; set; }
        public string ShortAnswer { get; set; }

        public string GetAnswer(bool returnFull)
        {
            return returnFull ? FullAnswer : ShortAnswer;
        }
        public string GetAnswer(int maxChars)
        {
            return FullAnswer.Length < maxChars ? FullAnswer : FullAnswer.Substring(0, maxChars);
        }

    }

Konstruktor instancyjny:

   class Question
    {
        public Question()
        {

        }
        public Question(string title)
        {
         
        }
    
    }

Indeksator:

    class Answers
    {
        List<Answer> allAnswers = new List<Answer>() 
        { new Answer { id = 1, Name = "A" }, new Answer { id = 1, Name = "B" } };

        public Answer this[int index]
        {
            get { return allAnswers.Where(a => a.id == index).SingleOrDefault(); }
       
        }
        public Answer this[string name]
        {
            get { return allAnswers.Where(a => a.Name == name).SingleOrDefault(); }

        }
    }

Operator:

    class AnswerState
    {
        public bool IsSelected { get; set; }
        public int CurrentNumber { get; set; }

        public static explicit operator AnswerState(bool x)
        {
            return x ? new AnswerState() { IsSelected = true } : new AnswerState() { IsSelected = false };
        }
    }

Kilka praktycznych uwag, o których warto pamiętać podczas przeciążania:
-Przeciążanie w przypadku metod nie może dotyczyć typu zwrotnego ani modyfikatora dostępu.
-Przeciążenie konstruktora instancyjnego zapobiega automatycznemu generowaniu konstruktora domyślnego.
-Przeciążanie operatorów narusza zgodność z CLS - innymi słowy przeciążony operator nie musi działać w innych językach platformy .NET i dobrą praktyką jest zapewnienie metody analogicznej do operatora.

Warto dodać, że w C# 4.0 wprowadzono parametry opcjonalne, które w wielu przypadkach z powodzeniem zastępują przeciążanie metod. Czyli zamiast definiować wiele metod, różniących się listą parametrów definiujemy jedną i określamy wartości domyślne:

public int MojaMetoda(int param1, double param2 = 10, string param3 = "brak wartosci");

Wówczas taką metodę możemy wywołać na wiele sposobów. Intellisense pokazuje parametry opcjonalne w nawiasach kwadratowych.

Dzięki temu nie trzeba pisać zbyt dużo kodu, a osiągamy podobny efekt.