Generating new random items from a list
There is lots that can be improved here. I won't repeat the great points that others have already made. Some thoughts:


Why are all these methods public?  Do you intend that CheckListLength is going to be called by code external to this class?  Only make things public that are part of the public surface of the class.
Why are any of these methods instance methods?  There is no instance data. They could all be static.
The contract of the primary method is bizarre. Summing up: you require that the user pass in two lists. If the first is empty, it becomes a copy of the second. The second list is then never touched again. Random items are chosen from the first list, and removed.  Think about how many ways there are for that to go horribly wrong. What if the user passes in two completely different lists? What if they pass in two references to the same list?  This is a disaster waiting to happen.
Consider the cost.  Suppose the method is used as it is supposed to be: we pass in an empty list and a list with N items. We wish to get out the N items in a random order. Now, I will tell you this crucial fact: the cost of removing an item from a list at random is on average proportional to the number of items in the list.  That's because lists are packed. If you have a million items in a list and you remove item number 123, then item 124 has to be moved into slot 123, item 125 has to be moved into slot 124, and so on up to item 1000000 being moved into slot 999999.  You are performing that operation N times, and the cost each time is proportional to N. If you work out the math you'll find that on average, if you use this method to fully randomize a list, then you are performing about N2/2 operations.  That's nothing if N is 4, but it is a trillion if N is a million; you will wait a long time to get your list randomized.
Your goal of producing a random sequence without modifying the original list is a really good one.  There are two far easier ways to do that, and I encourage you to try both of them.  They are:


First: make a method with this signature:

public static List&lt;T&gt; ProduceShuffle&lt;T&gt;(this IList&lt;T&gt; original)


You can have the method take a Random if you like as well.

the action of the method is:


Make a copy of the original list.
Loop from the end of the list to the beginning of the list
Each time through the loop, choose a random number less than or equal to the current index. This is key; you must not choose a random number covering the entire size of the list, otherwise the shuffle is biased.
Swap the element at the current index with the element at the randomly chosen index.


This is the Knuth Shuffle, also called the Fischer-Yates shuffle, and it is very efficient. Can you implement the code from my description? Can you produce an argument that this shuffle is both efficient and unbiased?

The second way to do it is much shorter but slightly less efficient.

public static List&lt;T&gt; ProduceShuffle&lt;T&gt;(this IEnumerable&lt;T&gt; original, Random random)
{
    return original.OrderBy(x =&gt; random.NextDouble()).ToList();
}


That is: generate a random fraction associated with each element. Produce a sorted sequence -- without modifying the original sequence -- that is sorted by that random element. Then turn that thing into a list and return it.

I note that some people on StackOverflow will tell you to sort by a new guid rather than by a random number because guids are random. This is a bad idea. Guids are unique; that guids happen to gain their uniqueness through randomness is an implementation detail subject to change. Use guids as a source of uniqueness, not as a source of randomness.