Problem z losowaniem liczb - Random

    public static int[] listaLiczb()
        {
            int a = 5;
            int b = 4;
            int c = 1;
            int d = 0;
            int e = 2;
            int f = 8;
            int g = 3;
            int h = 6;


            int[] tablica1 = new int[] { a, b, f, c, d, e, g, h };

            Random rng = new Random();

            List<int> listaCyfr = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            List<int> listaCyfrWylosowanych = new List<int>();

          for (int i = 0; i < tablica1.Length; i++)
          {
                int temporary;


                while (true)
                {
                    temporary = rng.Next(listaCyfr[0], listaCyfr[listaCyfr.Count - 1]);
                    if (listaCyfrWylosowanych.Contains(temporary)) continue;
                    else
                    {
                        tablica1[i] = temporary;
                        listaCyfrWylosowanych.Add(temporary);
                        listaCyfr.Remove(temporary);
                        break;
                    }
                }
                if (i == 3) listaCyfr.Insert(0, 0);
            
           }

    
            return tablica1;
        }

Random rng = new Random();

Random rng = new Random(Guid.NewGuid().GetHashCode());

 int[] first = listaLiczb();
            int[] next;

            for (int i = 0; i < 100000; i++)
            {
                next = listaLiczb();
                //Thread.Sleep(123);
                if (!next.SequenceEqual(first))
                {
                    Console.WriteLine("New random generated at: {0}",i);
                    break;
                }
            }

            Console.WriteLine("Start Tick: {0}",Environment.TickCount);
            //Thread.Sleep(123);
            int[] newList = listaLiczb();
            int[] newList2 = listaLiczb();
            Console.WriteLine("End Tick: {0}",Environment.TickCount);

using System;
using System.Runtime.InteropServices;

namespace ConsoleApp
{
    [Serializable]
    [ComVisible(true)]
    public class Random
    {
        private const int MBIG = int.MaxValue;

        private const int MSEED = 161803398;

        private const int MZ = 0;

        private int inext;

        private int inextp;

        private int[] SeedArray = new int[56];



        public Random()
            : this(Environment.TickCount)
        {
        }


        public Random(int Seed)
        {
            int num = (Seed == int.MinValue) ? int.MaxValue : Math.Abs(Seed);
            int num2 = 161803398 - num;
            SeedArray[55] = num2;
            int num3 = 1;
            for (int i = 1; i < 55; i++)
            {
                int num4 = 21 * i % 55;
                SeedArray[num4] = num3;
                num3 = num2 - num3;
                if (num3 < 0)
                {
                    num3 += int.MaxValue;
                }
                num2 = SeedArray[num4];
            }
            for (int j = 1; j < 5; j++)
            {
                for (int k = 1; k < 56; k++)
                {
                    SeedArray[k] -= SeedArray[1 + (k + 30) % 55];
                    if (SeedArray[k] < 0)
                    {
                        SeedArray[k] += int.MaxValue;
                    }
                }
            }
            inext = 0;
            inextp = 21;
            Seed = 1;
        }


        protected virtual double Sample()
        {
            return (double)InternalSample() * 4.6566128752457969E-10;
        }

        private int InternalSample()
        {
            int num = inext;
            int num2 = inextp;
            if (++num >= 56)
            {
                num = 1;
            }
            if (++num2 >= 56)
            {
                num2 = 1;
            }
            int num3 = SeedArray[num] - SeedArray[num2];
            if (num3 == int.MaxValue)
            {
                num3--;
            }
            if (num3 < 0)
            {
                num3 += int.MaxValue;
            }
            SeedArray[num] = num3;
            inext = num;
            inextp = num2;
            return num3;
        }

        public virtual int Next()
        {
            return InternalSample();
        }

        private double GetSampleForLargeRange()
        {
            int num = InternalSample();
            if ((InternalSample() % 2 == 0) ? true : false)
            {
                num = -num;
            }
            double num2 = num;
            num2 += 2147483646.0;
            return num2 / 4294967293.0;
        }

        public virtual int Next(int minValue, int maxValue)
        {
            if (minValue > maxValue)
            {
                throw new ArgumentOutOfRangeException();
            }
            long num = (long)maxValue - (long)minValue;
            if (num <= int.MaxValue)
            {
                return (int)(Sample() * (double)num) + minValue;
            }
            return (int)((long)(GetSampleForLargeRange() * (double)num) + minValue);
        }

        public virtual int Next(int maxValue)
        {
            if (maxValue < 0)
            {
                throw new ArgumentOutOfRangeException();
            }
            return (int)(Sample() * (double)maxValue);
        }

        public virtual double NextDouble()
        {
            return Sample();
        }

        public virtual void NextBytes(byte[] buffer)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)(InternalSample() % 256);
            }
        }
    }
}