[MustBeListAndContain(Constants.regex_media_id, minimumItems:3, maximumItems: 10, removeDuplicates: true, ErrorMessage = "Ids do not match required format")]
    public List<string> Ids { get; set; }

    [MustBeListAndContain("^[1-3]{1}$", minimumItems: 1, maximumItems: 3, removeDuplicates: true, ErrorMessage = "Types do not match required format")]
    public List<string> Types { get; set; }

The full code

public class MustBeListAndContainAttribute : ValidationAttribute
{
    private Regex regex = null;
    public bool RemoveDuplicates { get; }
    public string Separator { get; }
    public int MinimumItems { get; }
    public int MaximumItems { get; }

    public MustBeListAndContainAttribute(string regexEachItem,
        int minimumItems = 1, 
        int maximumItems = 0,
        string separator = ",",
        bool removeDuplicates = false) : base()
    {
        this.MinimumItems = minimumItems;
        this.MaximumItems = maximumItems;
        this.Separator = separator;
        this.RemoveDuplicates = removeDuplicates;

        if(!string.IsNullOrEmpty(regexEachItem))
            regex = new Regex(regexEachItem, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);            
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var listOfdValues = (value as List<string>)?[0];

        if (string.IsNullOrWhiteSpace(listOfdValues)) return new ValidationResult(this.ErrorMessage);

        var list = new List<string>();

        list.AddRange(listOfdValues.Split(new[] { Separator }, System.StringSplitOptions.RemoveEmptyEntries));

        if (RemoveDuplicates) list = list.Distinct().ToList();

        var prop = validationContext.ObjectType.GetProperty(validationContext.MemberName);
        prop.SetValue(validationContext.ObjectInstance, list);
        value = list;

        if (regex != null)
            if (list.Any(c => string.IsNullOrWhiteSpace(c) || !regex.IsMatch(c)))
                return new ValidationResult(this.ErrorMessage);

        return null;
    }
}

public class MustBeListAndContainAttribute : ValidationAttribute
{
    private Regex regex = null;
    public bool RemoveDuplicates { get; }
    public string Separator { get; }
    public int MinimumItems { get; }
    public int MaximumItems { get; }

    public MustBeListAndContainAttribute(string regexEachItem,
        int minimumItems = 1,
        int maximumItems = 0,
        string separator = ",",
        bool removeDuplicates = false) : base()
    {
        this.MinimumItems = minimumItems;
        this.MaximumItems = maximumItems;
        this.Separator = separator;
        this.RemoveDuplicates = removeDuplicates;

        if (!string.IsNullOrEmpty(regexEachItem))
            regex = new Regex(regexEachItem, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var listOfdValues = (value as List<string>)?[0];

        if (string.IsNullOrWhiteSpace(listOfdValues))
        {
            if (MinimumItems > 0)
                return new ValidationResult(this.ErrorMessage);
            else
                return null;
        };

        var list = new List<string>();

        list.AddRange(listOfdValues.Split(new[] { Separator }, System.StringSplitOptions.RemoveEmptyEntries));

        if (RemoveDuplicates) list = list.Distinct().ToList();

        var prop = validationContext.ObjectType.GetProperty(validationContext.MemberName);
        prop.SetValue(validationContext.ObjectInstance, list);
        value = list;

        if (regex != null)
            if (list.Any(c => string.IsNullOrWhiteSpace(c) || !regex.IsMatch(c)))
                return new ValidationResult(this.ErrorMessage);

        return null;
    }
}

I created a cool (I think) set of validation attributes that does that conversion for you automatically, besides some validation that you might need in your case as well.

My version is for strings, because attributes don't accept generics yet :(; but it should be easy for you to adapt:

public class ListMustContainElementsAttribute : ValidationAttribute
{
    public ListMustContainElementsAttribute(int MinimumItems = 1, int MaximumItems = 0) : base()
    {
        this.MinimumItems = MinimumItems;
        this.MaximumItems = MaximumItems;
    }

    public int MinimumItems { get; }
    public int MaximumItems { get; }
 
    public override bool IsValid(object value)
    {
        var list = value as IList;
        if (list == null) return false;
        if (MinimumItems > list.Count) return false;
        if (MaximumItems > 0)
            if (MaximumItems < list.Count) return false;

        return true;
    }
}

public class ListMustContainStringElementsAttribute : ListMustContainElementsAttribute
{
    private Regex regex = null;
    private bool removeDuplicates = false;

    public ListMustContainStringElementsAttribute(string regexEachItem, int MinimumItems = 1, int MaximumItems = 0, bool RemoveDuplicates = false) : base(MinimumItems, MaximumItems)
    {
        regex = new Regex(regexEachItem, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);
         removeDuplicates = RemoveDuplicates;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var commaSeparatedValues = (value as List<string>)?[0];

        if (string.IsNullOrWhiteSpace(commaSeparatedValues)) return new ValidationResult(this.ErrorMessage);

        var list = new List<string>();

        list.AddRange(commaSeparatedValues.Split(new[] { "," }, System.StringSplitOptions.RemoveEmptyEntries));

        if (removeDuplicates) list = list.Distinct().ToList();

        var prop = validationContext.ObjectType.GetProperty(validationContext.MemberName);
        prop.SetValue(validationContext.ObjectInstance, list);
        value = list;

        if(!base.IsValid(value)) return new ValidationResult(this.ErrorMessage);

        if (regex != null)
            if (list.Any(c => string.IsNullOrWhiteSpace(c) || !regex.IsMatch(c))) return new ValidationResult(this.ErrorMessage);

        return null;
    }
}

then the normal expected usage:

    [Required]
    [ListMustContainStringElements(Constants.RegexId, 3, 10, true, ErrorMessage = "Ids do not match required format")]
    public List<string> Ids { get; set; }

My solution was to create an attribute to validate strings, it does a bunch of extra common features, including regex validation that you can use to check for numbers only and then later I convert to integers as needed...

This is how you use:

    [MustBeListAndContain(Constants.regex_media_id, minimumItems:3, maximumItems: 10, removeDuplicates: true, ErrorMessage = "Ids do not match required format")]
    public List<string> Ids { get; set; }

    [MustBeListAndContain("^[1-3]{1}$", minimumItems: 1, maximumItems: 3, removeDuplicates: true, ErrorMessage = "Types do not match required format")]
    public List<string> Types { get; set; }

The full code

public class MustBeListAndContainAttribute : ValidationAttribute
{
    private Regex regex = null;
    public bool RemoveDuplicates { get; }
    public string Separator { get; }
    public int MinimumItems { get; }
    public int MaximumItems { get; }

    public MustBeListAndContainAttribute(string regexEachItem,
        int minimumItems = 1, 
        int maximumItems = 0,
        string separator = ",",
        bool removeDuplicates = false) : base()
    {
        this.MinimumItems = minimumItems;
        this.MaximumItems = maximumItems;
        this.Separator = separator;
        this.RemoveDuplicates = removeDuplicates;

        if(!string.IsNullOrEmpty(regexEachItem))
            regex = new Regex(regexEachItem, RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);            
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        var listOfdValues = (value as List<string>)?[0];

        if (string.IsNullOrWhiteSpace(listOfdValues)) return new ValidationResult(this.ErrorMessage);

        var list = new List<string>();

        list.AddRange(listOfdValues.Split(new[] { Separator }, System.StringSplitOptions.RemoveEmptyEntries));

        if (RemoveDuplicates) list = list.Distinct().ToList();

        var prop = validationContext.ObjectType.GetProperty(validationContext.MemberName);
        prop.SetValue(validationContext.ObjectInstance, list);
        value = list;

        if (regex != null)
            if (list.Any(c => string.IsNullOrWhiteSpace(c) || !regex.IsMatch(c)))
                return new ValidationResult(this.ErrorMessage);

        return null;
    }
}