这不是Distinct所做的。
它将从序列中返回不同的元素，从而删除重复的元素。
您只希望从没有重复项的项开始;

var numbers = new int[] { 11, 11, 11, 14, 11 };

foreach (var i in numbers.GroupBy(i => i).Where(g => g.Count() == 1).Select(g => g.Key))
    Console.WriteLine(i);

很明显，你想要第一个非重复值，所以你会得到这样的结果;

var numbers = new int[] { 11, 11, 11, 14, 11 };
    
int? firstNonDuplicate = numbers.GroupBy(i => i).Where(g => g.Count() == 1).Select(g => g.Key).FirstOrDefault();
    
Console.WriteLine(firstNonDuplicate);

虽然这里有不同的空检查，这只是证明了一点。

如果使用distinct，则返回所有distinct元素。按以下方式获取唯一值

int[] numbers = { 11, 11, 11, 14, 11 };
            Console.WriteLine(numbers.GroupBy(i => i).Where(g => g.Count() == 1).Select(g => g.Key).First());

一般来说，你应该按一个键对你的集合进行分组，然后按包含元素的数量对其进行过滤：

var groupings=  numbers.GroupBy(x => x)
                       .Where(x => x.Count() == 1)
                       .Select(x => x.Key);

现在，这给了你 * 所有 * 唯一的数字。你的问题有点模糊，因为你想要一个唯一的数字-而不是唯一的数字，所以有解释的余地，如果有多个数字，应该发生什么。
选项1：只取第一个结果：

var uniques = numbers.GroupBy(x => x)
                       .Where(x => x.Count() == 1)
                       .Select(x => x.Key)
                       .First();

选项1.1对结果进行排序，取最小（或最大）的结果

var uniques = numbers.GroupBy(x => x)
                       .Where(x => x.Count() == 1)
                       .Select(x => x.Key)
                       .OrderBy(x => x)
                       .First();

选项2：确保只有一个唯一的数字，否则抛出：

var uniques = numbers.GroupBy(x => x)
                       .Where(x => x.Count() == 1)
                       .Select(x => x.Key)
                       .Single();

注意：如果没有唯一的数字，Single()和First()将抛出，其中SingleOrDefault()和FirstOrDefault()将返回int的默认值，即0，这可能导致错误的结果。您可以考虑将其更改为int?，以便在没有唯一编号的情况下返回null。

你可以尝试下面的代码。

var numbers = new int[] { 11, 11, 11, 14, 11, 11 };
    var uniqueList = numbers.GroupBy(n => n).Where(item => item.Count() == 1).Select(item => item.Key);

    foreach (var item in uniqueList)
        Console.WriteLine(item);

我为你做了一个特别的方法。我对这个问题的处理有点原始。由于这种方法，你可以很容易地找到唯一的变量。

public static int[] getUniqiue(int[] vs)
        {
            List<int> vs1 = new List<int>(vs);
            List<int> vs2 = new List<int>(vs);
            List<int> ee = new List<int>();
            List<int> vs3 = new List<int>();
            int i = 0;
            foreach (var item in vs1)
            {
                vs2.Remove(item);
                if(vs3.Contains(item) || vs2.Contains(item))
                {
                    vs3.Add(item);
                }
                else
                {
                    ee.Add(item);
                }
                i++;
            }
            return ee.ToArray();
        }

从整数数组中返回唯一元素非常简单，通过使用字典，创建一个新的字典来存储每个元素在数组中出现的次数，然后使用LINQ迭代字典以找到频率为1的所有元素，这意味着这些元素是唯一的。元素是键，频率是值.

public static int UniqueElement(int[] arr) { 
          var dict = new Dictionary<int, int>();
          foreach(int i in arr)
          {
            if(dict.ContainsKey(i))
              {
                //element already exists just increment the frequency
                dict[i]++;
              }
            else
             {
                //element has occurred one times, add it and 1 to the dictionary
                dict.Add(i, 1); 
             }
         }
        //find keys or elements with a frequency or value of 1 and return to the calling function
        if(dict.Where(x=> x.Value == 1).Count() > 0)
        {
            return dict.Where(x => x.Value == 1).FirstOrDefault().Key;
        }
        //if no unique element is found then 0 will be returned to the calling function
        return 0;
    }