C#类自动递增ID

创建一个静态实例变量，并对其使用Interlocked.Increment(ref nextId)。

class Robot {
    static int nextId;
    public int RobotId {get; private set;}
    Robot() {
        RobotId = Interlocked.Increment(ref nextId);
    }
}

注意#1：使用nextId++仅在非并发环境中有效；即使从多个线程分配机器人，Interlocked.Increment也能工作。

编辑这不涉及重新使用机器人ID。如果您需要重用，解决方案要复杂得多：您需要一个可重用ID的列表，以及访问该列表的代码周围的ReaderWriterLockSlim。

class Robot : IDisposable {
    static private int nextId;
    static private ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
    static private IList<int> reuseIds = new List<int>();
    public int RobotId {get; private set;}
    Robot() {
        rwLock.EnterReadLock();
        try {
            if (reuseIds.Count == 0) {
                RobotId = Interlocked.Increment(ref nextId);
                return;
            }
        } finally {
            rwLock.ExitReadLock();
        }
        rwLock.EnterWriteLock();
        try {
            // Check the count again, because we've released and re-obtained the lock
            if (reuseIds.Count != 0) {
                RobotId = reuseIds[0];
                reuseIds.RemoveAt(0);
                return;
            }
            RobotId = Interlocked.Increment(ref nextId);
        } finally {
            rwLock.ExitWriteLock();
        }
    }
    void Dispose() {
        rwLock.EnterWriteLock();
        reuseIds.Add(RobotId);
        rwLock.ExitWriteLock();
    }
}

注2：如果您想在较大ID之前重用较小的ID（而不是像我编码的那样在稍后发布的ID之前重用先前发布的ID），您可以将IList<int>替换为SortedSet<int>，并围绕从集合中获取要重用的ID的部分进行一些调整。

这将完成任务，并以良好的线程安全方式进行操作。当然，这取决于你自己处理机器人，等等。显然，对于大量的机器人来说，这不会有效率，但有很多方法可以解决这个问题。

  public class Robot : IDisposable
  {
    private static List<bool> UsedCounter = new List<bool>();
    private static object Lock = new object();
    public int ID { get; private set; }
    public Robot()
    {
      lock (Lock)
      {
        int nextIndex = GetAvailableIndex();
        if (nextIndex == -1)
        {
          nextIndex = UsedCounter.Count;
          UsedCounter.Add(true);
        }
        ID = nextIndex;
      }
    }
    public void Dispose()
    {
      lock (Lock)
      {
        UsedCounter[ID] = false;
      }
    }

    private int GetAvailableIndex()
    {
      for (int i = 0; i < UsedCounter.Count; i++)
      {
        if (UsedCounter[i] == false)
        {
          return i;
        }
      }
      // Nothing available.
      return -1;
    }

以及一些测试代码。

[Test]
public void CanUseRobots()
{
  Robot robot1 = new Robot();
  Robot robot2 = new Robot();
  Robot robot3 = new Robot();
  Assert.AreEqual(0, robot1.ID);
  Assert.AreEqual(1, robot2.ID);
  Assert.AreEqual(2, robot3.ID);
  int expected = robot2.ID;
  robot2.Dispose();
  Robot robot4 = new Robot();
  Assert.AreEqual(expected, robot4.ID);
}

不是这样，但是您可以使用静态int，它在类中初始化，并在调用构造函数时递增。

class Robot()
{
    static int nrOfInstances = 0;
    init _id;
    Robot()
    {
        _id = Robot.nrOfInstances;
        Robot.nrOfInstances++;
    }
}

（我希望语法是正确的，这里没有编译器。）

如果你想重新使用一个删除的机器人ID，不要使用计数器，而是使用一个静态列表并将其添加到列表中。

然而，最好将已使用ID的列表保存在另一个类中，这样就根本不需要静态ID。在使用静态之前一定要三思。您可以将使用的ID列表保存在名为"RobotCreator"、"RobotHandler"、"RobotFactory"的类中（与设计模式不同）。

没有这样的内置功能。你必须自己实现它，比如持有一个比特数组来标记使用过的id，然后在每次创建新机器人时搜索第一个未使用的id。

顺便说一句，自动递增（在数据库意义上）实际上意味着即使一个或多个以前使用的值不再与对象关联，也要继续递增计数器。

这里有一些代码：

public class Robot 
{
    private static const int MAX_ROBOTS = 100;
    private static bool[] usedIds = new bool[MAX_ROBOTS];
    public int Id { get; set; }
    public Robot()
    {
         this.Id = GetFirstUnused();             
    }
    private static int GetFirstUnused()
    {
         int foundId = -1;
         for(int i = 0; i < MAX_ROBOTS; i++)
         {
             if(usedIds[i] == false)
             {
                 foundId = i;
                 usedIds[i] = true;
                 break;
             }
         }
         return foundId;
    }
}

有更复杂的算法/数据结构可以在小于O（N）的时间内找到第一个未使用的，但这超出了我的文章范围。：）

public static void beAddedTo<T>(this T item, Dictionary<int, T> dic) where T : m.lib.RandId
{
    Random ran = new Random();
    var ri = ran.Next();
    while (Program.DB.Rooms.ContainsKey(ri)) ri = ran.Next();
    item.Id = ri;
    dic.Add(item.Id, item);
}

不是增量的，但您可以添加和删除项目多少次您想要。（最大项目应低于int.Max/2）