Initialize list with both a single object and another list of objects

I think the best you can do is:

List<MyObject> newList = new[] { object1 }.Concat(listOfObjects).ToList();

If the order of the elements is not important, you can use:

List<MyObject> newList = new List<MyObject>(listOfObjects) { object1 };

This works by using the List<T> constructor which accepts an IEnumerable<T>, then the collection initializer to add the other items. For example, the following:

static void Main()
{
    int test = 2;
    List<int> test2 = new List<int>() { 3, 4, 5 };
    List<int> test3 = new List<int>(test2) { test };

    foreach (var t in test3) Console.WriteLine(t);

    Console.ReadKey();
}

Will print:

3
4
5
2

Note that the order is different than your original, however, as the individual item is added last.

If the order is important, however, I would personally just build the list, placing in your first object in the initializer, and calling AddRange:

List<MyObject> newList = new List<MyObject> { object1 };
newList.AddRange(listOfObjects);

This makes the intention very clear, and avoids construction of temporary items (which would be required using LINQ's Concat, etc).

This can be achieved with the help of extension methods, e.g.

public static class CollectionExtensions
{
    public static void Add<T>(this ICollection<T> collection, IEnumerable<T> itemsToAdd)
    {
        foreach (var item in itemsToAdd)
        {
            collection.Add(item);
        }
    }
}

Usage is exactly as it was suggested in the question:

var newList = new List<MyObject>
   {
      object1,
      listOfObjects
   };

Some explanation can be found in the C# Programming Guide about Object and Collection Initializers (I could not find better words):

Collection initializers let you specify one or more element initializers when you initialize a collection type that implements IEnumerable and has Add with the appropriate signature as an instance method or an extension method.