Czy istnieje sztuczka w tworzeniu ogólnej listy anonimowego typu?

Przydałby się List<dynamic>.

 var myList = new List<dynamic>();
 myList.Add(new {Tank = new Tank(), AttackingTank = new Tank()});

 Console.WriteLine("AttackingTank: {0}", myList[0].AttackingTank);

Oto hack:

var myList = Enumerable.Empty<int>()
    .Select(dummy => new { AttackingTank = default(Tank), TargetTank = default(Tank), })
    .ToList();

Jeśli Tank jest typem klasy, możesz napisać (Tank)null zamiast default(Tank). Możesz również użyć jakiegoś Tank przykładu, który masz pod ręką.

EDIT:

Lub:

var myList = Enumerable.Repeat(
    new { AttackingTank = default(Tank), TargetTank = default(Tank), },
    0).ToList();

Jeśli stworzysz metodę generyczną, nie będziesz musiał używać Enumerable.Empty. Może tak być:

static List<TAnon> GetEmptyListWithAnonType<TAnon>(TAnon dummyParameter)
{
    return new List<TAnon>();
}

Ma być wywoływana z TAnon wnioskowane z użycia, oczywiście, jak w:

var myList = GetEmptyListWithAnonType(new { AttackingTank = default(Tank), TargetTank = default(Tank), });

Możesz po prostu mieć metodę generyczną, która pobiera params i zwraca ją:

public static IList<T> ToAnonymousList<T>(params T[] items)
{
  return items;
}

Więc teraz możesz powiedzieć:

var list=ToAnonymousList
(
  new{A=1, B=2},
  new{A=2, B=2}
);

Warto zauważyć, że w końcu istnieje możliwość użycia takiej składni. Został wprowadzony w C # 7.0

var tanks = new List<(Tank AttackingTank, Tank TargetTank)>();

(Tank, Tank) tTank = (new Tank(), new Tank());
tanks.Add(tTank);

var a = tanks[0].AttackingTank;
var b = tanks[0].TargetTank;

A może ExpandoObject ?

dynamic tuple = new ExpandoObject(); 
tuple.WhatEverYouWantTypeOfTank = new Tank(); // Value of any type

EDITS:

dynamic tuple = new ExpandoObject();
tuple.AttackingTank = new Tank();
tuple.TargetTank = new Tank();

var mylist = new List<dynamic> { tuple };

//access to items
Console.WriteLine(mylist[0].AttackingTank);

Lub jeszcze bardziej proste

        var tupleList = (
           new[] {
                new { fruit = "Tomato", colour = "red"},
                new { fruit = "Tomato", colour = "yellow"},
                new { fruit = "Apple", colour = "red"},
                new { fruit = "Apple", colour = "green"},
                new { fruit = "Medlar", colour = "russet"}
            }).ToList();

Który traci funkcję statyczną.

Żeby dodać jeszcze jeden przydatny kawałek. Czasami używam odpowiedzi Alexa, ale doprowadza mnie to do szaleństwa próbując ją wyśledzić, gdy jej potrzebuję, ponieważ nie jest to oczywiste(znajduję się w poszukiwaniu " new {").

Więc dodałem następującą małą statyczną metodę (chciałbym, żeby była to metoda rozszerzenia, ale jakiego typu?):

public static List<T> CreateEmptyListOf<T>(Func<T> itemCreator)
{
    return Enumerable
        .Empty<object>()
        .Select(o => itemCreator())
        .ToList();
}

To izoluje część, która jest inna za każdym razem, gdy potrzebuję tego wzoru od tych, które są takie same. Nazywam to tak:

var emptyList = Ext.CreateEmptyListOf(() => new { Name = default(string), SomeInt = default(int) });

Możesz utworzyć listę obiektów:

List<object> myList = new List<object>();

Następnie dodaj Typ anonimowy do listy:

myList.Add(new {Name = "me", phone = 123});