Оптимизация алгоритма

                    int l = Convert.ToInt32(Setting.getWin() * Setting.getFs());
                    if (signal_input1.Count <l)
                    {
                        progressBar2.Invoke(new Action(() => progressBar2.Value=(signal_input1.Count * 100) / l));
                    }
                    if (signal_input1.Count > l)
                    {
                        progressBar2.Invoke(new Action(() => progressBar2.Value = 100));
                        signal_input1 = signal_input1.GetRange(signal_input1.Count - l, l);
                        signal_input2 = signal_input2.GetRange(signal_input2.Count - l, l);
                        signal_input3 = signal_input3.GetRange(signal_input3.Count - l, l);
                        signal_input4 = signal_input4.GetRange(signal_input4.Count - l, l);
                    }

                signal_drow1.AddRange(signal_input1.ToArray());
                signal_drow2.AddRange(signal_input2.ToArray());
                signal_drow3.AddRange(signal_input3.ToArray());
                signal_drow4.AddRange(signal_input4.ToArray());
                if (signal_drow1.Count>count)
                {
                     signal_drow1= signal_drow1.GetRange(signal_drow1.Count - count, count);                    
                }
                if (signal_drow2.Count > count)
                {
                    signal_drow2 = signal_drow2.GetRange(signal_drow2.Count - count, count);
                    
                }
                if (signal_drow3.Count > count)
                {
                    signal_drow3 = signal_drow3.GetRange(signal_drow3.Count - count, count);
                   
                }
                if (signal_drow4.Count > count)
                {
                    signal_drow4 = signal_drow4.GetRange(signal_drow4.Count - count, count);
                }

    [Serializable]
    public class LimitedQueue<T> : IEnumerable<T>
    {
        T[] items;
        int start = 0;
        int count = 0;
 
        public LimitedQueue(int capacity)
        {
            items = new T[capacity];
        }
 
        public void AddRange(IEnumerable<T> items)
        {
            foreach (var item in items)
                Enqueue(item);
        }
 
        public void Enqueue(T item)
        {
            items[start] = item;
            count++;
            if (count >= items.Length)
                count = items.Length;
            start = (start + 1) % items.Length;
        }
 
        public T Dequeue()
        {
            if (Count == 0)
                throw new Exception("Queue is empty");
 
            count--;
            start = (start - 1 + items.Length) % items.Length;
            return items[start];
        }
 
        public T Peek()
        {
            if (Count == 0)
                throw new Exception("Queue is empty");
 
            if (start == 0)
                return items[items.Length - 1];
            else
                return items[start - 1];
        }
 
        public int Count
        {
            get
            {
                return count;
            }
        }
 
        public void Clear()
        {
            start = 0;
            count = 0;
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            for (int i = 0; i < count; i++)
                yield return items[(start - i + items.Length) % items.Length];
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

public T [] ToArray()
        {            
            return items;
        }

using System.Linq;
...
var array = queue.ToArray();

public T[] ToArray()
        {
            T[] arr = new T[count];
            for (int i = 0; i < count; i++)
                arr[i] = items[i];
            return arr;
        }

        public T[] ToArray()
        {
            var res = new T[count];
            var l = items.Length;
 
            for (int i = 0; i < res.Length; i++)
                res[i] = items[(start - i + l) % l];
 
            return res;
        }

List.add(item);
if(List.count>capasity)
   List.RemoveAt(0);

[Serializable]
    public class LimitedQueue<T> : Queue<T>
    {
        private int? maxCapacity { get; set; }
 
        public LimitedQueue() { maxCapacity = null; }
        public LimitedQueue(int capacity) { maxCapacity = capacity; }
 
        public void Add(T newElement)
        {
            if (this.Count == (maxCapacity ?? -1)) this.Dequeue();
            this.Enqueue(newElement);
        }
        public void AddRange(T[] arr)
        {
            foreach (var i in arr)
                Add(i);
        }
 
    }