重置对象中的自动增量计数器

Question

我有一class含有像这样的自动增长计数器：

class MyClass
{
    private static object sync = new object();
    private static int globalCount;
    private int idUnique;

    public MyClass()
    {
        lock(sync)
        {
            idUnique = ++globalCount; 
        }
    }
}

问题是，在我的应用程序中，当用户删除MyClass的实例时，我希望它重置计数器并为MyClass的其余实例重新计算计数器。

例如：

MyClass a has IdUnique of 1  
MyClass b has IdUnique of 2  
MyClass c has IdUnique of 3  
MyClass d has IdUnique of 4

用户删除b ＆ c以便应用程序更新其余实例，因此a has a IdUnique of 1而d has a IdUnique of 2 。

Answer 1

这样的事情比其他任何事情更像是对象集合的属性。

如果要将对象实例组织为数组类型的结构，则可以将对象在该数组中的位置用作唯一标识符。

（删除项目时，如果您了解我的意思，则将其从数组中删除，导致其“右边”的所有元素都向后移一。）

Answer 2

我不太喜欢...（要清楚：代码应该可以正常工作，但我不喜欢它）。 请注意， Delete()现在是O（n）操作...并且可以在Dispose()进行转换（加上终结器的自动调用）。

一些测试代码：

var insts = new[] { new MyClass(), new MyClass(), new MyClass(), new MyClass() };
Console.WriteLine(string.Join(", ", (object[])insts));
insts[1].Delete();
Console.WriteLine(string.Join(", ", (object[])insts));
insts[3].Delete();
Console.WriteLine(string.Join(", ", (object[])insts));
insts[0].Delete();
Console.WriteLine(string.Join(", ", (object[])insts));
insts[2].Delete();
Console.WriteLine(string.Join(", ", (object[])insts));

和类...请注意，我保留了包含所有实例的静态SortedSet<> 。 我什至在创建MyClass的“排序”（ IComparable<MyClass> ）

class MyClass : IComparable<MyClass> {
    public static SortedSet<MyClass> Instances = new SortedSet<MyClass>();
    private static object sync = new object();
    private int idUnique;
    private int originalIdUnique;

    public MyClass() {
        lock (sync) {
            idUnique = Instances.Count > 0 ? Instances.Max.idUnique + 1 : 1;
            originalIdUnique = idUnique;
            Instances.Add(this);
        }
    }

    // It could be a Dispose()!
    public void Delete() {
        if (idUnique == int.MinValue) {
            return;
        }

        lock (sync) {
            Instances.Remove(this);

            if (Instances.Count > 0 && this.idUnique < Instances.Max.idUnique) {
                var instances = Instances.GetViewBetween(this, Instances.Max);

                foreach (var instance in instances) {
                    instance.idUnique--;
                }
            }

            idUnique = int.MinValue;
        }
    }

    public override string ToString() {
        return string.Format("Id: {0} (OriginalId: {1})", idUnique, originalIdUnique);
    }

    #region IComparable<MyClass> Members

    public int CompareTo(MyClass other) {
        return idUnique.CompareTo(other.idUnique);
    }

    #endregion
}