text: Q:
  
  Creating an Array Vs List
  
  In the below code, 
  is it more efficient (in terms of memory and time) to create a List<string> directly, rather than creating a string[] and calling ToList() on it before passing it to SomeMethod()?
  If you create the string[] and call ToList(), would it create a List<string> object, as well as already having the string[]?
  The reason I ask is that I have seen code where they are creating a string[] and calling ToList() before passing it as an argument to a method with a List<string> parameter, and I wasn't sure if there was any particular reason for that.
  class Program
      {
          static void Main(string[] args)
          {            
              var array = new string[] { "str1", "str2" };
              SomeMethod(array.ToList());
              var list = new List<string> { "str1", "str2" };
              SomeMethod(list);                        
          }
  
          static void SomeMethod(List<string> list)
          {
              //do stuff
          }
      }
  
  A:
  
  Every .ToList() and .ToArray() creates new objects, allocates memory, copies values. So, try to minimize such operations
  Use more common types: IEnumerable, ICollection. Because both list and array are suitable for IEnumerable, for example:
  
  class Program
  {
      static void Main(string[] args)
      {            
          var array = new string[] { "str1", "str2" };
          SomeMethod(array);
          var list = new List<string> { "str1", "str2" };
          SomeMethod(list);                        
      }
  
      static void SomeMethod(IEnumerable<string> list)
      {
          //do stuff
      }
  }
  
  Reference. 
  ToArray Method of List:
  public T[] ToArray()
  {
    T[] objArray = new T[this._size];
    Array.Copy((Array) this._items, 0, (Array) objArray, 0, this._size);
    return objArray;
  }
  
  You can see, it copies data.
  ToList method:
  public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
  {
    if (source == null)
      throw Error.ArgumentNull("source");
    return new List<TSource>(source);
  }
  
  You can see, it creates new list object. And constructor List(IEnumerable<T> collection) copies data.
  
  