Как передать значение свойства только для инициализации во вложенный класс?

Если вы не против выставить класс Wheel наружу, вам следует объявить свои свойства FrontWheel и RearWheel типа Wheel, и позволить этому классу самостоятельно обрабатывать свою инициализацию.

class Bicycle  {
    public Wheel FrontWheel { get; init; }
    public Wheel RearWheel { get; init; }
}

// (...)

public static void Main() {
  Bicycle bicycle = new() { 
    FrontWheel = new() { Spokes = 32, DiskBrake = true}, 
    RearWheel = new() { Spokes = 24, DiskBrake = false }
  };

}

Если вас волнует, что тип Wheel не виден на стороне вызова, вам придется сделать Bicycle владельцем интерфейса для инициализации и доступа к внутренним свойствам, принадлежащим Wheel.

Для этого вам нужно будет сделать эти свойства доступными только для получения и добавить конструктор Bicycle, в котором потребитель класса может инициализировать эти Wheel значения.

class Bicycle {
  private readonly Wheel _frontWheel;
  private readonly Wheel _rearWheel;

  public int FrontWheelSpokes => _frontWheel.Spokes;
  public int RearWheelSpokes => _rearWheel.Spokes;
  public bool FrontWheelDiskBrake => _frontWheel.DiskBrake;
  public bool RearWheelDiskBrake => _rearWheel.DiskBrake;
    
  public Bicycle(int frontWheelSpokes, bool frontWheelDiskBrake, int rearWheelSpokes, bool rearWheelDiskBrake) {
        _frontWheel = new() { Spokes = frontWheelSpokes, DiskBrake = frontWheelDiskBrake };
        _rearWheel = new() { Spokes = rearWheelSpokes, DiskBrake = rearWheelDiskBrake };
  }
}

// (...)

public static void Main() {
    Bicycle bicycle = new(32, true, 24, false);
}

Распространенный подход к сложным сценариям построения — написать фабричный метод или класс для инкапсуляции параметров построения.

Класс для инкапсуляции параметров конструкции для вашего примера может выглядеть так:

public class BicycleCreationData
{
    public BicycleCreationData(int frontSpokes, bool frontDiskBrake, int rearSpokes, bool rearDiskBrake)
    {
        FrontSpokes    = frontSpokes;
        FrontDiskBrake = frontDiskBrake;
        RearSpokes     = rearSpokes;
        RearDiskBrake  = rearDiskBrake;
    }

    public int  FrontSpokes    { get; }
    public bool FrontDiskBrake { get; }
    public int  RearSpokes     { get; }
    public bool RearDiskBrake  { get; }

    public int    OptionalParameter1 { get; set; } = 42;
    public string OptionalParameter2 { get; set; } = "42";
    public double OptionalParameter3 { get; set; } = 4.2;
}

Необязательные данные задаются в конструкторе (вместо использования init), а необязательные данные просто используют свойства get/set.

При этом вы можете написать класс Bicycle следующим образом:

public class Bicycle
{
    private readonly Wheel _frontWheel;
    private readonly Wheel _rearWheel;

    public Bicycle(BicycleCreationData data)
    {
        _frontWheel = new Wheel { DiskBrake = data.FrontDiskBrake, Spokes = data.FrontSpokes };
        _rearWheel  = new Wheel { DiskBrake = data.RearDiskBrake,  Spokes = data.RearSpokes  };
    }

    public int FrontWheelSpokes => _frontWheel.Spokes;
    public int RearWheelSpokes  => _rearWheel .Spokes;

    public bool FrontWheelDiskBrake => _frontWheel.DiskBrake;
    public bool RearWheelDiskBrake  => _rearWheel .DiskBrake;
}

И вы могли бы создать Bicycle в два этапа следующим образом:

var bikeData = new BicycleCreationData(
    frontSpokes:    32,
    rearSpokes:     24,
    frontDiskBrake: true,
    rearDiskBrake:  false)
{
    OptionalParameter1 = 100,
    OptionalParameter2 = "100"
};

var bike = new Bicycle(bikeData);

Я не уверен, что это то, что вы ищете, но это решает комбинационный взрыв конструкторов.

Нередко класс данных создания вкладывается в класс, который должен быть создан, а затем добавляется метод Create() к классу данных создания. Это позволяет классу данных создания иметь доступ к частным методам в создаваемом классе.

Например, вы можете сделать конструктор закрытым и заставить все создание выполняться через класс создания следующим образом (а также при желании добавить дополнительную проверку данных создания):

public class Bicycle
{
    private readonly Wheel _frontWheel;
    private readonly Wheel _rearWheel;

    public sealed class Creator
    {
        public Creator(int frontSpokes, bool frontDiskBrake, int rearSpokes, bool rearDiskBrake)
        {
            FrontSpokes    = frontSpokes;
            FrontDiskBrake = frontDiskBrake;
            RearSpokes     = rearSpokes;
            RearDiskBrake  = rearDiskBrake;
        }

        public int  FrontSpokes    { get; }
        public bool FrontDiskBrake { get; }
        public int  RearSpokes     { get; }
        public bool RearDiskBrake  { get; }

        public int    OptionalParameter1 { get; set; } = 42;
        public string OptionalParameter2 { get; set; } = "42";
        public double OptionalParameter3 { get; set; } = 4.2;

        public Bicycle Create()
        {
            // Add additional data validation here.
            return new Bicycle(this);
        }
    }

    private Bicycle(Creator data)
    {
        _frontWheel = new Wheel { DiskBrake = data.FrontDiskBrake, Spokes = data.FrontSpokes };
        _rearWheel  = new Wheel { DiskBrake = data.RearDiskBrake,  Spokes = data.RearSpokes  };
    }

    public int FrontWheelSpokes => _frontWheel.Spokes;
    public int RearWheelSpokes  => _rearWheel .Spokes;

    public bool FrontWheelDiskBrake => _frontWheel.DiskBrake;
    public bool RearWheelDiskBrake  => _rearWheel .DiskBrake;
}

Тогда вы бы создали это так:

var bike = new Bicycle.Creator(
    frontSpokes:    32,
    rearSpokes:     24,
    frontDiskBrake: true,
    rearDiskBrake:  false)
{
    OptionalParameter1 = 100,
    OptionalParameter2 = "100"
}
.Create();

Можно воссоздать экземпляр вашего свойства колеса в каждом установщике инициализации. Вам придется скопировать свойства, которые вы не установили. Это имеет тот серьезный недостаток, что вам придется вызывать множество ненужных конструкторов Wheel, но вы можете сохранить дизайн своего класса. Код может быть таким (для краткости, только с передним колесом):

class Bicycle
    {
        private readonly Wheel _frontWheel = new();

        public int FrontWheelSpokes
        {
            get => _frontWheel.Spokes;
            init => _frontWheel = new Wheel
            {
                Spokes = value,
                DiskBrake = _frontWheel.DiskBrake
            };
        }

        public bool FrontWheelDiskBrake
        {
            get => _frontWheel.DiskBrake;
            init => _frontWheel = new Wheel
            {
                Spokes = _frontWheel.Spokes,
                DiskBrake = value
            };
        }
}

Онлайн-демо: https://dotnetfiddle.net/LzMdP5

В качестве альтернативы вы можете создать свойства Lazy и сохранить значения init в полях для использования при создании свойства Lazy.

Это требует дублирования всех свойств инициализации в полях, поэтому это несколько громоздко, но я публикую это просто ради интереса:

 class Bicycle
{
    private readonly Lazy<Wheel> _frontWheel;
    private readonly Lazy<Wheel> _rearWheel;
    private readonly int         _initFrontWheelSpokes = 24;
    private readonly int         _initRearWheelSpokes  = 32;
    private readonly bool        _initFrontWheelDiskBrake;
    private readonly bool        _initRearWheelDiskBrake = true;

    public Bicycle()
    {
        _frontWheel = new Lazy<Wheel>(() => new Wheel { Spokes = _initFrontWheelSpokes, DiskBrake = _initFrontWheelDiskBrake });
        _rearWheel  = new Lazy<Wheel>(() => new Wheel { Spokes = _initRearWheelSpokes,  DiskBrake = _initRearWheelDiskBrake  });
    }

    public int FrontWheelSpokes
    {
        get  => _frontWheel.Value.Spokes;
        init => _initFrontWheelSpokes = value ;
    }

    public bool FrontWheelDiskBrake
    {
        get  => _frontWheel.Value.DiskBrake;
        init => _initFrontWheelDiskBrake = value;
    }

    public int RearWheelSpokes
    {
        get  => _rearWheel.Value.Spokes;
        init => _initRearWheelSpokes = value ;
    }

    public bool RearWheelDiskBrake
    {
        get  => _rearWheel.Value.DiskBrake;
        init => _initRearWheelDiskBrake = value;
    }
}

Это более сложная версия полезного ответа SomeBody , включающая идею Shingo о создании Wheel пластинки:

record class Wheel
{
    internal Wheel() { }

    public int Spokes { get; init; }
    public bool DiskBrake { get; init; }
}

Теперь я могу реализовать Bicycle вот так:

class Bicycle
{
    private readonly Wheel _frontWheel = new();
    private readonly Wheel _rearWheel = new();

    public int FrontWheelSpokes
    {
        get => _frontWheel.Spokes;
        init => _frontWheel = _frontWheel with { Spokes = value };
    }

    public int RearWheelSpokes
    {
        get => _rearWheel.Spokes;
        init => _rearWheel = _rearWheel with { Spokes = value };
    }

    public bool FrontWheelDiskBrake
    {
        get => _frontWheel.DiskBrake;
        init => _frontWheel = _frontWheel with { DiskBrake = value };
    }

    public bool RearWheelDiskBrake
    {
        get => _rearWheel.DiskBrake;
        init => _rearWheel = _rearWheel with { DiskBrake = value };
    }
}

Требуется некоторое объяснение, поскольку в приведенном выше коде происходит много всего. Каждый раз, когда используется свойство Bicycle, предназначенное только для инициализации, создается поверхностная копия Wheel на основе существующего Wheel, хранящегося в частном поле Bicycle. Давайте посмотрим, например, как компилятор C# преобразует свойство FrontWheelSpokes:

public int FrontWheelSpokes
{
    get
    {
        return _frontWheel.Spokes;
    }
    init
    {
        Wheel wheel = _frontWheel.<Clone>$();
        wheel.Spokes = value;
        _frontWheel = wheel;
    }
}

<Clone>$ — это сгенерированный компилятором метод в классе Wheel:

[CompilerGenerated]
public virtual Wheel <Clone>$()
{
    return new Wheel(this);
}

Конструктор клонирования также генерируется компилятором для класса Wheel:

[CompilerGenerated]
protected Wheel(Wheel original)
{
    <Spokes>k__BackingField = original.<Spokes>k__BackingField;
    <DiskBrake>k__BackingField = original.<DiskBrake>k__BackingField;
}

Вы можете полностью изучить сгенерированный компилятором код в Sharplab.

Так что же происходит, когда создается экземпляр Bicycle, как показано в вопросе?

Bicycle bicycle = new()
{
    FrontWheelSpokes = 32,
    RearWheelSpokes = 24,
    FrontWheelDiskBrake = true,
    RearWheelDiskBrake = false
};

Этот код вызывает создание экземпляров 6 объектов Wheel. Два из них изначально создаются во время построения Bicycle, когда инициализируются частные поля _frontWheel и _rearWheel. Дополнительные 4 создаются путем вызова свойств нового файла Bicycle, предназначенных только для инициализации. Из всех 6 экземпляров Wheel последние 2 сохраняются, а первые 4 отбрасываются и становятся пригодными для сбора мусора. Отброшенные объекты представляют собой мелкие копии, поэтому их объем памяти равен размеру default-инициализированного Wheel. Работа, необходимая для их создания, незначительна: всего лишь присвоение резервных полей оригинала клону. Тем не менее, этой работы можно было бы избежать, если бы компилятор C# был более полезен в автоматическом распространении свойств только для инициализации.

Я все еще не решил, буду ли я использовать эту технику в моем реальном сценарии. Я использую свойства только для инициализации для некоторых настроек моего класса Wheel, которые используются редко, поэтому на практике эта мизерная стоимость будет редко окупаться. Меня больше беспокоят последствия преобразования моего Wheel в record, потому что Wheel — это абстрактный базовый класс, и есть другие классы, производные от него. Так что я могу столкнуться с какой-нибудь другой стеной по дороге.