重置对象中的自动插入计数器

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＆amp;c因此，该应用更新剩余实例，因此a has a IdUnique of 1和d has a IdUnique of 2。

Answer 1

这样的东西更像是对象的 collection 的属性。

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

（删除项目时，您将其从数组中删除，从而导致所有元素的"右"元素，如果您有我的含义，则将其删除。）

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
}