维持序数集合的适当顺序

我有一个简单的域对象：

class FavoriteFood
{
    public string Name;
    public int Ordinal;
 }

我想要一个这个域对象的集合来维护正确的序数。例如，给定4种最喜欢的食物：

Name: Banana, Ordinal: 1
Name: Orange, Ordinal: 2
Name: Pear, Ordinal: 3
Name: Watermelon, Ordinal: 4

如果我把梨的序数改为4，西瓜的序数应该会改为3。

如果我添加一种新的最喜欢的食物（草莓），序号为3，它应该会将梨增加到4，西瓜增加到5。

如果我把Pear的序数改为2，它应该把Orange改为3。

如果我把西瓜的序数改为1，香蕉会变成2，橘子会变成3，梨会变成4。

实现这一目标的最佳方法是什么？

UPDATE：域对象的name属性是动态的，并且基于用户输入。对象必须具有此Ordinal属性，因为用户可以更改他们喜爱的食物的显示顺序。这个序数值保存在数据库中，当填充结构时，我不能保证项目是按序数顺序添加的。

我遇到的问题是，当底层域对象发生更改时，没有一个好的方法来更新列表中的其余项。例如：

var favoriteFoods = new List<FavoriteFood>();
var banana = new FavoriteFood { Name = "Banana", Ordinal = 1};
favoriteFoods.Add(banana);
favoriteFoods.Add(new FavoriteFood { Name = "Orange", Ordinal = 2 });
banana.Ordinal = 2;
// at this point both Banana and Orange have the same ordinal in the list. How can we make sure that Orange's ordinal gets updated too?

到目前为止，我已经尝试过做以下工作：

class FavoriteFood : INotifyPropertyChanging
{
    public string Name;
    public int Ordinal
    {
        get { return this.ordinal; }
        set
        {
            var oldValue = this.ordinal;
            if (oldValue != value && this.PropertyChanging != null)
            {
                this.PropertyChanging(new FavoriteFoodChangingObject { NewOrdinal = value, OldOrdinal = oldValue }, new PropertyChangingEventArgs("Ordinal"));
            }
            this.ordinal = value;
        }
    }
    internal struct FavoriteFoodChangingObject
    {
        internal int NewOrdinal;
        internal int OldOrdinal;
    }
    // THIS IS A TEMPORARY WORKAROUND
    internal int ordinal;
    public event PropertyChangingEventHandler PropertyChanging;
 }
 public class FavoriteFoodCollection : IEnumerable<FavoriteFood>
 {
    private class FavoriteFoodOrdinalComparer : IComparer<FavoriteFood>
    {
        public int Compare(FavoriteFood x, FavoriteFood y)
        {
            return x.Ordinal.CompareTo(y.Ordinal);
        }
    }
    private readonly SortedSet<FavoriteFood> underlyingList = new SortedSet<FavoriteFood>(new FavoriteFoodOrdinalComparer());
    public IEnumerator<FavoriteFood> GetEnumerator()
    {
        return this.underlyingList.GetEnumerator();
    }
    public void AddRange(IEnumerable<FavoriteFood> items)
    {
        foreach (var i in items)
        {
            this.underlyingList.Add(i);
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
    private void UpdateOrdinalsDueToRemoving(FavoriteFood item)
    {
        foreach (var i in this.underlyingList.Where(x => x.Ordinal > item.Ordinal))
        {
            i.ordinal--;
        }
    }
    public void Remove(FavoriteFood item)
    {
        this.underlyingList.Remove(item);
        this.UpdateOrdinalsDueToRemoving(item);
    }
    public void Add(FavoriteFood item)
    {
        this.UpdateOrdinalsDueToAdding(item);
        this.underlyingList.Add(item);
        item.PropertyChanging += this.item_PropertyChanging;
    }
    private void item_PropertyChanging(object sender, PropertyChangingEventArgs e)
    {
        if (e.PropertyName.Equals("Ordinal"))
        {
            var ordinalsChanging = (FavoriteFood.FavoriteFoodChangingObject)sender;
            this.UpdateOrdinalsDueToEditing(ordinalsChanging.NewOrdinal, ordinalsChanging.OldOrdinal);
        }
    }
    private void UpdateOrdinalsDueToEditing(int newOrdinal, int oldOrdinal)
    {
        if (newOrdinal > oldOrdinal)
        {
            foreach (var i in this.underlyingList.Where(x => x.Ordinal <= newOrdinal && x.Ordinal > oldOrdinal))
            {
                //i.Ordinal = i.Ordinal - 1;
                i.ordinal--;
            }
        }
        else if (newOrdinal < oldOrdinal)
        {
            foreach (var i in this.underlyingList.Where(x => x.Ordinal >= newOrdinal && x.Ordinal < oldOrdinal))
            {
                //i.Ordinal = i.Ordinal + 1;
                i.ordinal++;
            }
        }
    }
    private void UpdateOrdinalsDueToAdding(FavoriteFood item)
    {
        foreach (var i in this.underlyingList.Where(x => x.Ordinal >= item.Ordinal))
        {
            i.ordinal++;
        }
    }
}

这可以正常工作，但使用内部Ordinal字段是一个奇怪的解决方法。它是必需的，这样PropertyChangingEvent就不会被无限引发。