我的想法是，你可以按计数对两个集合进行分组，然后测试超级组列表是否包含子组列表中的每个键，并且在每种情况下，超级计数都大于或等于相应的子计数。我认为我已经通过以下方法实现了这一点：

var subset = new[] { 9, 3, 9 };
var superset = new[] { 9, 10, 5, 3, 3, 3 };

var subGroups = subset.GroupBy(n => n).ToArray();
var superGroups = superset.GroupBy(n => n).ToArray();

var basicResult = subset.All(n => superset.Contains(n));
var advancedResult = subGroups.All(subg => superGroups.Any(supg => subg.Key == supg.Key && subg.Count() <= supg.Count()));

Console.WriteLine(basicResult);
Console.WriteLine(advancedResult);

我做了一些额外的测试，它似乎工作，但你可以测试一些额外的数据集，以确保。

下面是另一个解决方案：

var subset = new[] { 9, 3, 9 };
            var superset = new[] { 9, 10, 5, 3, 3, 3 };

            var subsetGroup = subset.GroupBy(x => x).Select(x => new { key = x.Key, count = x.Count() });
            var supersetDict = superset.GroupBy(x => x).ToDictionary(x => x.Key, y => y.Count());

            Boolean results = subsetGroup.All(x => supersetDict[x.key] >= x.count);

这对我很有效：

var subsetLookup = subset.ToLookup(x => x);
var supersetLookup = superset.ToLookup(x => x);

bool flag =
    subsetLookup
        .All(x => supersetLookup[x.Key].Count() >= subsetLookup[x.Key].Count());

这不是sets和集合操作的工作方式。集合不能包含重复项。
不应将两个数组视为集合，而应视为（无序的）序列。可能的算法如下：从序列superset中制作一个列表，然后从列表中逐个删除序列subset的每个元素，直到在列表中找不到这样的元素为止。

bool IsSubList(IEnumerable<int> sub, IEnumerable<int> super)
{
    var list = super.ToList();
    foreach (var item in sub)
    {
        if (!list.Remove(item))
            return false; // not found in list, so sub is not a "sub-list" of super
    }
    return true; // all elements of sub were found in super
}

var subset = new[] { 9, 3 };
var superset = new[] { 9, 10, 5, 3,1, 3, 3 };

var isSubSet = IsSubList(subset, superset);