Design guidelines for avoiding changes in multiple classes

I am trying to figure out how to make a small application more elegant and more resilient to change.

Basically, this is a kind of project pricing calculator, and the problem is that there are many parameters that can affect pricing. I'm trying to avoid cluttering the code with lots of if-clauses for each parameter, but still I have, for example. if clauses in two places, checking the value of the size parameter.

I have a book "Head First Design Patterns" and I tried to find ideas there, but the closest I got was a decorator sample that has an example where the prices of Starbuzz coffee are set based on the seasonings added first and then later by adding a parameter size (Tall, Grande, Venti). But that didn't seem to help, because adding this parameter still seemed to add complexity to the if-clause in many places (and this was an exercise they didn't explain further).

What I'm trying to avoid is to change multiple classes if the parameter were to change, or add a new parameter, or at least change as few places as possible (there's some fancy design principle word for this, t rememeber: -)).

Below is the code. Basically it calculates a price for a project that has Writing and Analyzing tasks with a size parameter and different price models. Later on, other options will appear, such as "How's the new product?" (New, 1-5 years old, 6-10 years old) etc. Any advice on the best design would be much appreciated, be it a "design pattern" or just good object-oriented principles that make it resilient to change (like adding another size or changing one of the size values ​​and only changing in one place, not in multiple if clauses):

public class Project
{
    private readonly int _numberOfProducts;
    protected Size _size;
    public Task Analysis { get; set; }
    public Task Writing { get; set; }

    public Project(int numberOfProducts)
    {
        _numberOfProducts = numberOfProducts;
        _size = GetSize();
        Analysis = new AnalysisTask(numberOfProducts, _size);
        Writing = new WritingTask(numberOfProducts, _size);

    }

    private Size GetSize()
    {
        if (_numberOfProducts <= 2)
            return Size.small;
        if (_numberOfProducts <= 8)
            return Size.medium;
        return Size.large;
    }
    public double GetPrice()
    {
        return Analysis.GetPrice() + Writing.GetPrice();
    }
}

public abstract class Task
{
    protected readonly int _numberOfProducts;
    protected Size _size;
    protected double _pricePerHour;
    protected Dictionary<Size, int> _hours;
    public abstract int TotalHours { get; }

    public double Price { get; set; }

    protected Task(int numberOfProducts, Size size)
    {
        _numberOfProducts = numberOfProducts;
        _size = size;
    }

    public double GetPrice()
    {
        return _pricePerHour * TotalHours;
    }
}

public class AnalysisTask : Task
{
    public AnalysisTask(int numberOfProducts, Size size)
        : base(numberOfProducts, size)
    {
        _pricePerHour = 850;
        _hours = new Dictionary<Size, int>() { { Size.small, 56 }, { Size.medium, 104 }, { Size.large, 200 } };
    }

    public override int TotalHours
    {
        get { return _hours[_size]; }
    }
}

public class WritingTask : Task
{
    public WritingTask(int numberOfProducts, Size size)
        : base(numberOfProducts, size)
    {
        _pricePerHour = 650;
        _hours = new Dictionary<Size, int>() { { Size.small, 125 }, { Size.medium, 100 }, { Size.large, 60 } };
    }

    public override int TotalHours
    {
        get
        {
            if (_size == Size.small)
                return _hours[_size] * _numberOfProducts;
            if (_size == Size.medium)
                return (_hours[Size.small] * 2) + (_hours[Size.medium] * (_numberOfProducts - 2));
            return (_hours[Size.small] * 2) + (_hours[Size.medium] * (8 - 2)) + (_hours[Size.large] * (_numberOfProducts - 8));
        }
    }
}

public enum Size
{
    small, medium, large
}

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        List<int> quantities = new List<int>();

        for (int i = 0; i < 100; i++)
        {
            quantities.Add(i);
        }
        comboBoxNumberOfProducts.DataSource = quantities;
    }

    private void comboBoxNumberOfProducts_SelectedIndexChanged(object sender, EventArgs e)
    {
        Project project = new Project((int)comboBoxNumberOfProducts.SelectedItem);
        labelPrice.Text = project.GetPrice().ToString();
        labelWriterHours.Text = project.Writing.TotalHours.ToString();
        labelAnalysisHours.Text = project.Analysis.TotalHours.ToString();
    }
}

      

        
        
        
      

    

At the end, this is a simple running code to call in a change event for the combobox that set the size ... (By the way, I don't like the fact that I have to use multiple dots to get to TotalHours at the end here, as far as I remember it breaks " the principle of least knowledge "or" the law of demeter ", so the contribution to this will also be appreciated, but this is not the main question)

Hello,

Anders