Zurücksetzen einen Auto-Increment-Zähler in Objekt

Question

Ich habe ein class einen Auto-Increment-Zähler wie folgt enthält:

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

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

Das Problem ist, in meiner Anwendung, wenn der Benutzer eine Instanz von MyClass löscht, I‘ Ich mag es, den Zähler zurückzusetzen und den Zähler für die verbleibenden Instanzen von MyClass neu zu berechnen.

Zum Beispiel:

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

Der Benutzer löscht b & c so die App aktualisiert die restlichen Instanzen so a has a IdUnique of 1 und d has a IdUnique of 2.

Answer 1

ich es nicht sehr gerne viel ... (um klar zu sein: der Code sollte richtig funktionieren, aber ich mag es nicht). Beachten Sie, dass Delete() jetzt eine O (n) Operation ist ... Und es könnte in eine Dispose() konvertiert werden (plus der automatische Anruf vom Finalizer).

Einige Testcode:

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)); 

und die Klasse ... Beachten Sie, dass ich eine statische SortedSet<> bin zu halten, die alle Instanzen enthält. Ich bin auch eine „Bestellung“ von MyClass (die 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 
} 

Answer 2

Eine solche Sache ist mehr eine Eigenschaft einer Sammlung Ihrer Objekte als alles andere.

Wenn Sie Ihre Objektinstanzen in einer Array-artigen Struktur organisieren würden, könnten Sie die Position Ihres Objekts in diesem Array als eindeutigen Bezeichner verwenden.

(Wenn ein Element zu löschen, können Sie es aus dem Array löschen davon verursacht alle Elemente der „richtigen“ durch eine Verschiebung zurück, wenn Sie meine Bedeutung bekommen.)