How to create a List variable that can contain array of int or string in C#?

sample here

List<object> lst = new List<object>() {  "12",1,"apple"};
lst.ForEach(m => { Console.WriteLine((m is int) ? "int Varible" : "String Varibale"); });

You can only store one Type and its derived types in a generic List, in the case you described you would have to use List<object> or it's non generic counterpart ArrayList, but non-generic collections are not recommended and don't support newer features like LINQ.

So that would look something like:

var list = new List<object> {"lol", 101};

foreach (var value in list)
{
    if(value is string s)
        Console.WriteLine(s);
    if (value is int i)
        Console.WriteLine(i);
}

I'm still not sure exactly what your requirements are, but here's a solution for the most general case.

First

Create a class capable of holding a collection of either integers or strings (but not both). Note that it uses the Collection initialization pattern (twice) (see https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers)

Note that the various GetEnumerator implementations are there only to satisfy the collection initialization pattern. They throw if called, the expectation is that a consumer would call GetIntegerSizes or GetStringSizes.

Here's the code:

public class AdSlotSizes : IEnumerable<int>, IEnumerable<string>
{
    public enum CollectionType
    {
        Uninitialized,
        Integers,
        Strings,
    }

    private List<int> _integerSizes;
    private List<string> _stringSizes;

    public void Add(int sizeToAdd)
    {
        InitializeList(CollectionType.Integers);
        _integerSizes.Add(sizeToAdd);
    }

    public void Add(string sizeToAdd)
    {
        InitializeList(CollectionType.Strings);
        _stringSizes.Add(sizeToAdd);
    }

    public CollectionType SizesCollectionType => _collectionType;

    private CollectionType _collectionType = CollectionType.Uninitialized;

    private void InitializeList(CollectionType forCollectionType)
    {
        CollectionType oppositeCollectionType = (CollectionType)(((int) CollectionType.Strings + 1) - (int) forCollectionType);
        if (_collectionType == oppositeCollectionType)
        {
            throw new ArgumentException($"A single {nameof(AdSlotSizes)} instance can only hold one type of sizes (int or string)");
        }

        if (_collectionType != CollectionType.Uninitialized)
        {
            return;
        }
        _collectionType = forCollectionType;

        if (forCollectionType == CollectionType.Strings)
        {
            _stringSizes = _stringSizes ?? new List<string>();
        }
        if (forCollectionType == CollectionType.Integers)
        {
            _integerSizes = _integerSizes ?? new List<int>();
        }
    }

    public IEnumerable<int> GetIntegerSizes()
    {
        if (_collectionType != CollectionType.Integers)
        {
            throw new ArgumentException("Size collection not initialized for integers");
        }

        foreach (var size in _integerSizes)
        {
            yield return size;
        }
    }

    public IEnumerable<string> GetStringSizes()
    {
        if (_collectionType != CollectionType.Strings)
        {
            throw new ArgumentException("Size collection not initialized for strings");
        }

        foreach (var size in _stringSizes)
        {
            yield return size;
        }
    }

    IEnumerator<string> IEnumerable<string>.GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator<int> IEnumerable<int>.GetEnumerator()
    {
        throw new NotImplementedException();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }

}

Second

Now I create a class that collections AdSlotSizes instances (again, using the collection initialization pattern). It also implements an indexed property (public AdSlotSizes this[int index]), allowing the consumer to index into the collection:

public class GoogleAddSlot : IEnumerable<AdSlotSizes>
{
    private readonly List<AdSlotSizes> _slotSizes = new List<AdSlotSizes>();

    public void Add(AdSlotSizes sizes)
    {
        _slotSizes.Add(sizes);
    }

    public AdSlotSizes this[int index] => _slotSizes[index];

    public IEnumerator<AdSlotSizes> GetEnumerator()
    {
        foreach (var sizes in _slotSizes)
        {
            yield return sizes;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return (IEnumerator < AdSlotSizes > )this.GetEnumerator();
    }
}

Finally, a test method:

public static void TestCollectionSizes()
{
    var slot = new GoogleAddSlot
    {
        {new AdSlotSizes {200, 300, 400} },
        {new AdSlotSizes {"fluid", "solid"}},
    };

    foreach (int size in slot[0].GetIntegerSizes())
    {
        Debug.WriteLine($"Integer Size: {size}");
    }

    foreach (string size in slot[1].GetStringSizes())
    {
        Debug.WriteLine($"String Size: {size}");
    }
}

When run, this test method outputs:

Integer Size: 200
Integer Size: 300
Integer Size: 400
String Size: fluid
String Size: solid