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

这样的东西更像是对象的集合的属性而不是其他东西。

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

（当删除一个项目时，你将它从数组中删除，导致它的所有元素都向前移动一个，如果你理解了我的意思。）

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
}

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

2 个答案: