Create a C# method to generate auto increment Id

Question

I am new at programming and I am trying in vain to create a function that returns an auto increment id, however the code isn't working and I'm sure there's something missing even though I don't get what is it. Here the code, it was meant to create a function that everytime is called it creates an auto increment id, as if it is on SQL(a primary key):

class Program
{
    static void Main(string[] args)
    {
        string[] dataInsert = new string[10];

        for(int i = 0; i < dataInsert.Length; i++)
        {
            dataInsert[i] = Convert.ToString(generateId());
        }

        for (int i = 0; i < dataInsert.Length; i++)
        {
            Console.WriteLine(dataInsert[i]);
        }

        Console.ReadKey();
    }
    static int generateId()
    {
        int id = 1;
        return id += 1;
    }
}

Answer 1

You can make a static integer that remembers the previously returned id, then increment it as required using Interlocked.Increment():

using System.Threading;


class Program
{
    static int lastId = 0;

    static int generateId()
    {
        return Interlocked.Increment(ref lastId);
    }

    // Remainder of Program unchanged
}

Interlocked.Increment increments a specified variable and stores the result, as an atomic operation and returns the incremented value. It guarantees that duplicate IDs will not get returned when generateId() is called from different threads.

Note the following remark from the documentation:

This method handles an overflow condition by wrapping: if location = Int32.MaxValue, location + 1 = Int32.MinValue. No exception is thrown.

Thus you may want to add logic to generateId() to check for this and throw an exception.

For further reading about static fields and when to use them, see:

• What is the use of static variable in C#? When to use it? Why can't I declare the static variable inside method? which explains when and how to use a static field.

• C# Static variables - scope and persistence which explains that a static field will persist for the lifetime of your AppDomain (which is to a reasonable approximation the lifetime of your application session) and thus its value will not get reset until your program exits.

Update

In comments, the following question is asked: Why is Interlocked.Increment necessary here if we don't know that there are multiple threads (i.e. assuming this is a single-threaded app)?

By this point in time it should always be assumed that an app is multi-threaded. Thread-unsafe patterns should not be used if there is a simple, thread-safe alternative that can be used at no significant additional cost (in either development cost or runtime performance), as is the case here. And since OP self-describes as a Student at University of Madeira they should start out learning thread-safe patterns even when writing console apps so that they don't need to unlearn thread-unsafe techniques later.

Answer 2

Change

static int generateId()
{
    int id = 1;   //This resets the value to 1 every time you enter.
    return id+= 1;
}

To:

private static int id = 1;
static int generateId()
{
    return id++;
}

Your generateId will always return 2 since you're passing out a local value that you initialize to 1 each time it's entered. With my example, Id will be set to 1 when the app is run and then increments. It will always start at 1, though.

Adding explanation of local variables, field variables, and static variables.

When you define a variable like you did, a local variable, it only exists within the scope of the method and will get reinitialized each time the method is called.

You can also define field variables that will exist as long as an instance of an object exists. For example:

public class AutoIncrment
{
    private int id = 1;
    public int GenerateId()
    {
       return id++;
    }
}

You can use it like this:

var idState = new AutoIncrement();

console.WriteLine(idState.GenerateId()); // Outputs 1
console.WriteLine(idState.GenerateId()); // Outputs 2 
console.WriteLine(idState.GenerateId()); // Outputs 3 
console.WriteLine(idState.GenerateId()); // Outputs 4 .. And so on

var idState2 = new AutoIncrement();  // Create a new instance and it starts over

console.WriteLine(idState2.GenerateId()); // Outputs 1
console.WriteLine(idState2.GenerateId()); // Outputs 2 .. And so on
// Go back to idState object and it will keep going from where you last left off
console.WriteLine(idState.GenerateId()); // Outputs 5 

Then there are static variables like in my answer at the top. They exist as part of the class itself. Since the class always exists while the program is running, the variable exists in memory, too.