creating a list of lists of tuples

So first of all this is my first stackoverflow pull so I am sorry if my explanation is shit.
So I am working on a game right now in c#. It also does work right now so the solution I am looking for isnt necessary, however I really would like to sum up a big part of my code.

The code is the following:

I have a baseclass called Item.

    public class Item
    {
        string name;
        //and more
    }

From this class I inherit multiple different classes
which looks smth like this:

    public class TestItem : Item
    {
        //stuff
    }

    public class AnotherItem: Item
    {
        //stuff
    }

And now to the problem:

My shop looks currently something like this:

    ShopInventory shopInventory;
    foreach ((AnotherItem item,int price) in shopInventory.anotherItems) 
    {
        //display item in a specific way
    }
    foreach ((TestItem item,int price) in shopInventory.testItems)
    {
        //display item in a specific way
    }
    //and so on

It is in a method so we dont need global variables and can use things like "var", and
as you can see it replicates itself. So I know I can shorten it:

shopInventory.testItems is a tuple which looks like this:

    public class ShopInventory{
    public List <Tuple<TestItem, int>>testItems = new List<Tuple<TestItem , int>>();
    //and
    public List <Tuple<AnotherItem, int>>anotherItems= new List<Tuple<AnotherItem , int>>();
    //and more..
}

which displays the Item and a price.
And now I would like to create a list of those lists so I can shorten the big displaying part from above to something like

        foreach (var tempList in listOfLists )
        {
                foreach ((var item, int price) in tempList)
                {
                    //display item in a specific way
                }
        }

I tried things like

    var listOfLists = new List<List<Tuple<Item,int>>>();
    //or 

    var listOfLists = new List<List<Tuple<object,int>>>();
    //and 
    var listOfLists = new List<List<Tuple<dynamic,int>>>();
     

but if I try to add a list now:

    listOfLists.Add(shopInventory.testItems);

the add line just gets red underlined.
however if I create something like:

    var listOfLists = new List<List<Tuple<AnotherItem,int>>>();
    listOfLists.Add(shopInventory.anotherItems);

It works, but I can obviously only store objects of type "AnotherItem" into it.
I also thought if I use the base class Item I shouldnt get any problems but .. yea didnt worked as planned.
If you think about "why doesnt he just add the prices to the item itself" well it is because the item itself is also used in the players inventory and therefore doesnt need another variable which represents its price. I could create another class like shopItem, however if I would do that I would need to duplicate every other class and inherit from it and I thought like.. using tuple would be more efficient.. and I dont need to do like 5 more scripts just because of a price.

If you have any ideas pls let me know. I am only "ok" in programming so if you have any other ideas I am also looking forward for it.

You have several design problems here:

1. Why does the shop have distinct lists for different types of items? Do you want to change your logic every time you are selling a new type of item? Use one single lists of type List<Item>.

2. There is no inheritance between tuples. This makes it very hard to program against different types of tuples and impossible to unify lists of different tuple types. Simply integrate the price in the Item class and avoid tuples.

Better structure:

public abstract class Item
{
    public string Name { get; set; }
    public decimal Price { get; set; }
}

public class TestItem : Item
{
    public string Test { get; set; }
}

public class AnotherItem : Item
{
    public Color Color { get; set; }
}

Based on this class hierarchy, you can declare the shop inventory as:

public class ShopInventory
{
    public List<Item> Items { get; } = new();
}

And now you can loop with:

foreach (Item item in shopInventory.Items) {
    Console.WriteLine($"{item.Name} at {item.Price:C} is a {item.GetType().Name}");
}

You can then still work on a specific type of item by using a filter:

foreach (AnotherItem item in shopInventory.Items.OfType<AnotherItem>()) {
    Console.WriteLine($"{item.Name} at {item.Price:C} has color {item.Color}");
}