C# WPF – Как обновить все элементы в списке на основе изменения одного из них и заставить привязки работать?

Ваши объекты стены должны реализовать INotifyPropertyChanged, и вам необходимо подписаться на PropertyChangedEvent для каждого из них. Вот что-то, что укажет вам правильное направление.

public class MainWindowViewModel : INotifyPropertyChanged
{
    private ObservableCollection<Wall> _walls;

    public ObservableCollection<Wall> Walls
    {
        get { return _walls; }
        set 
        { 
            _walls = value;
            OnPropertyChanged();
        }
    }

    public void OrderWalls()
    {
        for (int i = 0; i < _walls.Count; i++)
        {
            Walls[i].YPos = Walls[i-1].YPos + Walls[i].YHeight;
        }
    }

    public MainWindowViewModel() 
    {
        Walls = new ObservableCollection<Wall>();

        Walls.Add(new Wall { Floor = "Floor 4", Height = 3, Length = 6, YPos = 50, XPos = 50 });
        Walls.Add(new Wall { Floor = "Floor 3", Height = 3, Length = 6, YPos = 200, XPos = 50 });
        Walls.Add(new Wall { Floor = "Floor 2", Height = 3, Length = 6, YPos = 350, XPos = 50 });
        Walls.Add(new Wall { Floor = "Floor 1", Height = 3, Length = 6, YPos = 500, XPos = 50 });

        foreach(var wall in Walls)
        {
           wall.PropertyChanged += WallChanged; // subscribe to all changes.
        }
    }

    private void WallChanged(object sender, PropertyChangedEventArgs e)
    {
         // May want to be selective on what changes you are worried
         // about. Only run when the height changes for instance.
         // Otherwise you could call this recursively and end up with a stack overflow.
         if (e.PropertyName == nameOf(Wall.Height))
             OrderWalls(); // Something changed update the y's.
    }

    public event PropertyChangedEventHandler? PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string name = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
    }
}

Ваш код ошибочен. Во-первых, ваши свойства YPos и XPos не вызывают событие PropertyChanged. Это не позволит визуальным элементам обновлять свое положение на Canvas.

Далее, ваши расчеты также неверны. Самое главное, что ваш индекс выйдет за пределы допустимого диапазона для первой итерации, поскольку вы начнете с индекса i = 0 и ссылаетесь на коллекцию с помощью i - 1.
Затем вы добавляете высоту текущего элемента к вертикальному положению предыдущего элемента. Но вы должны добавить предыдущую высоту YHeight к предыдущей позиции YPos, чтобы получить новую позицию текущего элемента:

public void OrderWalls()
{
  if (!Walls.Any())
  {
    return;
  }

  for (int i = 1; i < _walls.Count; i++)
  {
    // This line will throw an IndexOutOfRangeException 
    // because in the first iteration 'index = i -1' results in 'index == -1'
    //Walls[i].YPos = Walls[i-1].YPos + Walls[i].YHeight;

    // Naming the elements usually visualizes what you are doing to help 
    // identifying logical and typing errors
    Wall currentWall = Walls[i];
    Wall previousWall = Walls[i - 1];
    currentWall.YPos = previousWall.YPos + previousWall.YHeight;
  }
}

Однако этот алгоритм можно значительно улучшить с точки зрения производительности, которая становится тем более актуальной, чем больше элементов содержит коллекция. Поскольку изменение высоты известно, вы можете использовать его, чтобы избежать полной итерации коллекции. Тот факт, что изменения высоты не влияют на предыдущие элементы, позволяет нам пропустить их.

Затем мы можем просто сместить вертикальное положение за счет изменения высоты. Класс Wall должен уведомлять об изменении своего размера, чтобы владелец элементов Wall мог переставлять объекты. По этой причине класс Wall должен реализовать событие SizeChanged.

Вам следует переместить всю связанную логику в выделенный класс. Например, вы можете создать пользовательский WallCollection, который прослушивает событие Wall.SizedChanged для изменения порядка элементов. Вы можете инкапсулировать поведение в любой класс, но этот класс должен иметь ссылку на коллекцию и отслеживать коллекцию на предмет добавления/удаления изменений, чтобы зарегистрировать/отменить регистрацию обработчиков событий SizeChanged. Эту логику проще иметь непосредственно в специализированной коллекции, поэтому я выбираю WallCollection.

WallSizeChangedEventArgs.cs
Данные о событии, чтобы предоставить наблюдателю подробную информацию об изменениях.

public class WallSizeChangedEventArgs : EventArgs
{
  public WallSizeChangedEventArgs(Size oldSize, Size newSize)
  {
    this.OldSize = oldSize;
    this.NewSize = newSize;
  }

  public Size OldSize { get; }
  public Size NewSize { get; }
  public bool HasHeightChanged => this.OldSize.Height != this.NewSize.Height;
  public bool HasWidthChanged => this.OldSize.Width != this.NewSize.Width;
  public double HeightChange => this.NewSize.Height - this.OldSize.Height;
  public double WidthChange => this.NewSize.Width - this.OldSize.Width;
}

Стена.cs
Смотрите комментарии, чтобы узнать об исправлениях.

public class Wall : INotifyPropertyChanged
{
  public Wall()
  {
    // Set the default. If the YPos value is left with this default
    // then the WallCollection will automatically stack items
    // with a gap of zero between the Wall items. Updating YPos will keep the gap at zero.
    // If the default is overwritten e.g. with 100, and this value would create a gap of e.g. 30
    // between the current and the preceding Wall item, then WallCollection will now update the YPos
    // by simply adding the offset. This way the vertical margin will always remain the same (30).
    this.YPos = double.PositiveInfinity;
  }

  // Introduce an event to notify about changes and make information about change details,
  // like the actual change value, available.
  // This helps to implement the re-arrange algorithm more efficiently
  // as we can now avoid the complete iteration of the collection.
  public event EventHandler<WallSizeChangedEventArgs>? SizeChanged;

  public event PropertyChangedEventHandler? PropertyChanged;

  // Prefer const over static (or static readonly)
  private const int Scale = 50;

  private double _height; //Height of wall IRL
  private double _length; //Lenght of wall IRL
  private double _xPos; //Horizonal position on canvas (Canvas.Left)
  private double _yPos; //Vertical position on canvas (Canvas.Top)

  // If this property doesn't raise the PropertyChanged event make it an auto-property
  public string Floor { get; set; }

  public double Height
  {
    get => _height;
    set
    {
      // We will only report the scaled size
      double oldHeight = this.YHeight;

      _height = value;

      // Avoid duplicate formula definition. Either execute from property setter (recommended) or move to method
      //_yHeight = value * Scale;

      // Use 'nameof' instead of magic strings for robustness. 
      //OnPropertyChanged("YHeight");
      OnPropertyChanged(nameof(this.YHeight));

      // We will only report the scaled size
      OnSizeChanged(new Size(this.XLength, oldHeight), new Size(this.XLength, this.YHeight));
    }
  }

  public double Length
  {
    get { return _length; }
    set
    {
      // We will only report the scaled size
      double oldWidth = this.XLength;

      _length = value;

      // Avoid duplicate formula definition. Either execute from property setter (recommended) or move to method
      //_xLength = value * Scale;

      // Use 'nameof' instead of magic strings for robustness and IDE support to avoid typos or enable symbol renaming. 
      //OnPropertyChanged("XLength");
      OnPropertyChanged(nameof(this.XLength));

      // We will only report the scaled size
      OnSizeChanged(new Size(oldWidth, this.YHeight), new Size(this.XLength, this.YHeight));
    }
  }

  // This property must raise the PropertyChanged event
  // to trigger the repositioning on the Canvas via data binding!
  public double XPos
  {
    get => _xPos;
    set
    {
      _xPos = value;
      OnPropertyChanged();
    }
  }

  // This property must raise the PropertyChanged event
  // to trigger the repositioning on the Canvas via data binding!
  public double YPos
  {
    get => _yPos;
    set
    {
      _yPos = value;
      OnPropertyChanged();
    }
  }

  // The setter is redundant as it discards the set value. Instead implement property as computed property.
  //
  // Width of Border on canvas (IRL Length * Scale)
  public double XLength => this.Length * Scale;
  //{
  //  get { return _xLength; }
  //
  //  // This setter is redundant as it discards the set value. Instead implement property as computed property
  //  set { _xLength = Length * Scale; }
  //}

  // The setter is redundant as it discards the set value. Instead implement property as computed property.
  //
  // Height of Border on canvas (IRL Height * Scale)
  public double YHeight => this.Height * Scale;
  //{
  //  get { return _yHeight; }

  //  // This setter is redundant as it discards the set value. Instead implement property as computed property
  //  set { _yHeight = Height * Scale; }
  //}

  protected virtual void OnSizeChanged(Size oldSize, Size newSize)
    => this.SizeChanged?.Invoke(this, new WallSizeChangedEventArgs(oldSize, newSize));

  protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}

WallCollection.cs
Эта коллекция также автоматически будет складывать каждый добавленный элемент, переопределяя начальное значение YPos, если оно есть double.PositiveInfinity.

public class WallCollection : ObservableCollection<Wall>
{
  public WallCollection()
  { }

  public WallCollection(IEnumerable<Wall> collection) : base(collection)
  { }

  public WallCollection(List<Wall> list) : base(list)
  { }

  protected override void SetItem(int index, Wall item)
  {
    CheckReentrancy();

    // In case the index exists, the item will be replaced.
    // Therefore, we have to unhook all event handlers 
    // from the replaced item.
    RemoveItemInternal(index);

    // Add/replace the item
    base.SetItem(index, item);

    // Store the index in a hash table for fast lookup
    AddItemInternal(index, item);
  }

  protected override void InsertItem(int index, Wall item)
  {
    // Add the item
    base.InsertItem(index, item);

    // Store the index in a hash table for fast lookup
    AddItemInternal(index, item);
  }

  protected override void RemoveItem(int index)
    => RemoveItemInternal(index);

  protected override void ClearItems()
  {
    // Call CheckReentrancy to prevent this collection from being modifed while CollectionChanged event is raised.
    // The OnCollectionChanged implementation usually calls BlockReentrancy().
    // This is important as you want to prevent CollectionChanged event handlers to modify the collection
    // *before* all listeners have been notified (about the exact same state). 
    // You don't want that a "item added" ColectionChanged event becomes obsolete
    // because event handler A has e.g. removed the new item before event handler B could handle it.
    // Event handler B would still get the original notification about an added item.
    // But because event handler A has modified the collection, the event now reports an invalid state to event handler B.
    // This introduces a high potential for bugs. To avoid this, the collection is locked during CollectionChanged events.
    // If OnCollectionChanged has called BlockReentrancy() then calling CheckReentrancy()
    // from a modifying method will throw an exception until the bock has been lifted (all event handlers have been executed).
    // CheckReentrancy is usually called by the base methods SetItem(), InserItem(), RemoveItem() and ClearItems().
    // Because we have to unregister SizeChanged event handlers for each individual item
    // we have to perform the cleanup before manually clearing the collection.
    // We therefore don't invoke the base implementation of ClearItems() which is why we have to call CheckReentrancy by ourselves.
    CheckReentrancy();

    for (int index = this.Count - 1; index >= 0; index--)
    {
      RemoveItemInternal(index);
    }

    this.indexMap.Clear();
    OnPropertyChanged(new PropertyChangedEventArgs(nameof(this.Count)));
    OnPropertyChanged(new PropertyChangedEventArgs(nameof(Binding.IndexerName)));

    // This base method of ObservableCollection will internally call BlockReentrancy()
    // to lock this collection for modifications during the event execution
    OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
  }

  private void AddItemInternal(int index, Wall item)
  {
    if (!this.indexMap.ContainsKey(item))
    {
      this.indexMap.Add(item, index);
      StartObserveSizeChanges(item);
    }

    // Auto allign the added Wall
    InitializeVerticalWallPosition(index, item);
  }

  private void RemoveItemInternal(int index)
  {
    Wall removedItem = this[index];
    base.RemoveItem(index);
    StopObserveSizeChanges(removedItem);
    _ = this.indexMap.Remove(removedItem);
  }

  private void InitializeVerticalWallPosition(int index, Wall item)
  {
    // Only arrange when:
    if (index > 0  // item is not the first
        && item is not null
        && double.IsInfinity(item.YPos)) // item has no explicit vertical position assigned (the default YPos value is double.PositiveInfinity)
    {
      Wall previousWall = this.Items[index - 1];
      item.YPos = previousWall.YPos + previousWall.YHeight;

      ArrangeWalls(item, true, item.YHeight);
    }
  }

  private void StartObserveSizeChanges(Wall item)
  {
    // In case the items live longer than this collection (and the collection is not cleared before disregarded),
    // we must use a WeakEventManager to avoid a leak.
    WeakEventManager<Wall, WallSizeChangedEventArgs>.AddHandler(item, nameof(Wall.SizeChanged), OnWallSizeChanged);
  }

  private void StopObserveSizeChanges(Wall item)
  {
    // In case the items live longer than this collection (and the collection is not cleared before disregarded),
    // we must use a WeakEventManager to avoid a leak.
    WeakEventManager<Wall, WallSizeChangedEventArgs>.RemoveHandler(item, nameof(Wall.SizeChanged), OnWallSizeChanged);
  }

  // When a wall has changed its YHeight we must rearrange all succeeding Wall items.
  // A changing height means that the YPos offset of all succedding items has to be adjusted.
  private void OnWallSizeChanged(object? sender, WallSizeChangedEventArgs e)
  {
    var changedWall = (Wall)sender;
    ArrangeWalls(changedWall, e.HasHeightChanged, e.HeightChange);
  }

  private void ArrangeWalls(Wall? changedWall, bool hasHeightChanged, double heightChange)
  {
    if (hasHeightChanged)
    {
      ArrangeItemsVertically(changedWall, heightChange);
    }
  }

  private void ArrangeItemsVertically(Wall changedWall, double change)
  {
    // If  there wasn't the Dictionary we would have to call IndexOf(changedWall) to get the current index.
    // And then increment the index to get the succeeding Wall items.
    // This is a O(n) operation while querying the Dictionary is O(1). This means the perfomance is not depedeing on the size of collection.
    // We will always get the index immediately.
    if (!this.indexMap.TryGetValue(changedWall, out int indexOfChangedWall))
    {
      return;
    }

    // Start from the changed item to improve the perfromance.
    // The preceding items are not affected by the size change of the current item.
    for (int index = indexOfChangedWall + 1; index < this.Items.Count; index++)
    {
      Wall wall = this.Items[index];

      // For example, if the heigth of Wall A has changed by +10 or -20
      // then me must vertically offset all succeeding Wall items by +10 or -20
      wall.YPos += change;
    }
  }

  // The map that stores the index of each Wall for fast lookup.
  // This is to avoid IndexOf calls as this will perform bad for big collections.
  private readonly Dictionary<Wall, int> indexMap = new();
}

MainWindowViewModel.cs

public class MainWindowViewModel : INotifyPropertyChanged
{
  // A binding source collection should always be 
  // a readonly property that returns an ObservableCollection.
  public WallCollection Walls { get; }

  public MainWindowViewModel()
  {
    // Only set the YPos of the first item. 
    // The WallCollection will stack them properly. 
    // If you want to start at YPos == 0 then you don't even have 
    // to set the YPos of the first item. 
    // Any explicit YPos value set will have precedence over the 
    // calculated arrangement of the WallCollection.
    Walls = new WallCollection()
    {
      new Wall { Floor = "Floor 4", Height = 3, Length = 6, YPos = 50, XPos = 50 },
      new Wall { Floor = "Floor 3", Height = 3, Length = 6, XPos = 50 },
      new Wall { Floor = "Floor 2", Height = 3, Length = 6, XPos = 50 },
      new Wall { Floor = "Floor 1", Height = 3, Length = 6, XPos = 50 }
    };
  }

  public event PropertyChangedEventHandler? PropertyChanged;
  protected void OnPropertyChanged([CallerMemberName] string name = null)
  {
    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
  }
}