正确锁定线程安全的自生成列表(c#)

我有一个单例IEnumerable，它生成一个数字序列。序列是可交互的(基本上是无限期的)，我只在需要时生成序列中的下一个数字。

public class Generator:IEnumerable<long> {
    private Generator() { }
    private static volatile Generator instance=new Generator();
    private static readonly object syncRoot=new object();
    public static Generator Instance { get { return instance; } }
    private static List<long> numsList=new List<long>();
    private void GenerateNextNumber() {
        long number;
        //Code to generate next number
        numsList.Add(number);
    }
    private long GenerateToNthNumber(int n) {
        lock(syncRoot) {
            while(numsList.Count<n)
                GenerateNextNumber();
        }
        return numsList[n-1];
    }
    public static long GetNthNumber(int n) {
        return Instance.GenerateToNthNumber(n);
    }
    private class GeneratorEnumerator:IEnumerator<long> {
        private int index=0;
        public long Current { get { return GetNthNumber(index); } }
        public void Dispose() { }
        object System.Collections.IEnumerator.Current { get { return GetNthNumber(index); } }
        public bool MoveNext() {
            index++;
            return true;
        }
        public void Reset() {
            index=0;
        }
    }
    public IEnumerator<long> GetEnumerator() {
        return new GeneratorEnumerator();
    }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }
}

这段代码对并发线程中的数字进行枚举和求和。是否有一种方法可以防止每次调用GenerateToNthNumber时都必须锁定?我试过这个代码:

    private long GenerateToNthNumber(int n) {
        if(numsList.Count<n) {
            lock(syncRoot) {
                while(numsList.Count<n)
                    GenerateNextNumber();
            }
        }
        return numsList[n-1];
    }

但是当测试在多个并发线程中枚举和求和数字时，并不是所有的结果最终都是相同的和。我的目标是有非阻塞读取，如果被要求的数字已经生成，如果这是可能的。有更好的方法吗?