Collection

Empty(集合判空)

string[] nullArray = null;
List<string> emptyList = new();
int[] notEmptyArray = new[] { 1, 2, 3, 4 };
nullArray.IsEmpty(); //true
emptyList.NotEmpty(); // false
emptyList.IsEmpty(); // true
notEmptyArray.NotEmpty(); // true
notEmptyArray.IsEmpty(); // false

tip

集合为 null 或者元素为空，结果都为 True

无需再对集合做空判断

AllContain(A是否包含B)

string[] strList = { "1", "2", "3", "4", "5", "6" };
strList.AllContain(new[] { "2", "6" }); // True
strList.AllContain("2", "8", "10", "11", "20"); // False

strList.AllContain((x, y) => x == y, new[] { "2", "6" }); // True
strList.AllContain((x, y) => x == y, "2", "8", "10", "11", "20"); // False

tip

A 集合 全部 包含了 B 集合中的元素时为 True

可传入委托进行自定义判断

HasContain(A是否包含B的元素)

string[] strList = { "1", "2", "3", "4", "5", "6" };
strList.HasContain(new[] { "2", "6" }); // True
strList.HasContain(new[] { "2", "8" }); // True
strList.HasContain("7", "8"); // False

strList.HasContain((x, y) => x == y, new[] { "2", "6" }); // True
strList.HasContain((x, y) => x == y, new[] { "2", "8" }); // True
strList.HasContain((x, y) => x == y, "7", "8"); // False

tip

A 集合 部分 包含了 B 集合中的元素时为 True

可传入委托进行自定义判断

Merge(集合合并)

IEnumerable<int[]> nums = new List<int[]>()
{
    new[] {1,2,3},
    new[] {4,5,6},
    new[] {7,8,9},
    new[] {10},
};
var numMergeList = nums.Merge();
numMergeList = nums.Take(2).Merge(nums.TakeLast(2));
numMergeList = nums.Take(2).Merge(new[] { 7, 8, 9, 10 });

numMergeList = nums.Merge((x, y) => x == y, item => item.GetHashCode());
// { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }

tip

Merge 中的参数维数需要小于等于源集合

可通过传入委托在合并的同时去重

SpliteCollection(分割集合)

var nums = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var numSplit = nums.SpliteCollection(2);
/*
    {1,2}
    {3,4}
    {5,6}
    {7,8}
    {9,10}
*/
numSplit = nums.SpliteCollection(3);
/*
    {1,2,3}
    {4,5,6}
    {7,8,9}
    {10}
*/

caution

感觉非常鸡肋，后面可能会删掉

WhereIf

int[] intList = { 1, 1, 2, 2, 3, 3, 4 };
intList = intList.WhereIf(true, item => item > 1)
.WhereIf(false, item => item < 3)
.WhereIf("", item => item != 2)
.ToArray();
// {2,2,3,3,4}

Unique(去重)

int[] intList = { 1, 1, 2, 2, 3, 3, 4 };
intList.Unique();
intList.Unique(item => item);
intList.Unique((x, y) => x == y);
// 1,2,3,4

tip

针对自定义类型可以通过传入委托进行去重

SequenceEqual(集合是否相等)

IEnumerable<UserInfo> userInfos = new List<UserInfo> {
    new UserInfo{UserName="23331",Age=231 },
    new UserInfo{UserName="23332",Age=232 },
    new UserInfo{UserName="23333",Age=233 },
    new UserInfo{UserName="23334",Age=234 },
};
IEnumerable<UserInfo> userInfosCopy = new List<UserInfo> {
    new UserInfo{UserName="23331",Age=231 },
    new UserInfo{UserName="23332",Age=232 },
    new UserInfo{UserName="23333",Age=233 },
    new UserInfo{UserName="23334",Age=234 },
};
IEnumerable<UserInfo> userInfosNotCopy = new List<UserInfo> {
    new UserInfo{UserName="23331",Age=23 },
    new UserInfo{UserName="23332",Age=23 },
    new UserInfo{UserName="23333",Age=23 },
    new UserInfo{UserName="23334",Age=23 },
};
userInfos.SequenceEqual(userInfosCopy); // false
userInfos.SequenceEqual(userInfosCopy, (x, y) => x.UserName == y.UserName); // true
userInfos.SequenceEqual(userInfosCopy, item => item.Age.GetHashCode()); // true

userInfos.SequenceEqual(userInfosNotCopy); // false
userInfos.SequenceEqual(userInfosNotCopy, (x, y) => x.UserName == y.UserName); // true
userInfos.SequenceEqual(userInfosNotCopy, item => item.Age.GetHashCode()); // false

tip

针对自定义类型可以通过传入委托进行去重

Shuffle(打乱顺序)

var nums = new[] { 1, 2, 3, 4, 5 };
nums = nums.Shuffle();
// 可能变成了 2,4,5,1,3 或者其他顺序

caution

暂时基于 Random 实现, 后面可能会考虑更换实现方式

ForEach(遍历)

var sum = 0;
int[] nums = new[] { 1, 2, 3 };
nums.ForEach(item => sum += item);
// sum == 6

AddRange(批量添加)

IEnumerable<int> nums = new[] { 1, 2, 3 };
// IEnumerable 会产生一个新的集合
var enums = nums.AddRange(4, 5);

ICollection<int> nums = new List<int> { 1, 2, 3 };
// ICollection 将直接在原集合上进行修改
nums.AddRange(4, 5, 6);

tip

如果继承了 ICollection 则会使用第二种 AddRange, 不然就是第一种

同时提供了在 AddRange 时去重的重载, 只会对传入的集合去重, 如果需要对原集合进行去重, 最好使用上面的 Unique

var nums = new[] { 1, 2, 3 };
var enums = nums.AddRange((x, y) => x == y, 3, 4, 5);
// enums { 1, 2, 3, 4, 5 }

SelectWithIndex

info

主要是为了方便写 foreach

int[] nums = new[] { 1, 2, 3 };
foreach (var (item, index) in nums.SelectWithIndex());
foreach (var (item, index) in nums.SelectWithIndex(num => num * num));
foreach (var (item, index) in nums.SelectWithIndex(num => num.ToString(), num => num));

tip

可以通过委托决定返回的 item 和 index

In(A元素是否在B集合中)

int[] nums = new[] { 1, 2, 3 };
1.In(nums); // True
4.In(nums); // False

tip

与其他集合扩展一样, 支持使用委托进行判断

int[] nums = new[] { 1, 2, 3 };
1.In(nums, (x,y) => x == y); // True
4.In(nums, (x,y) => x == y); // False

GetItemIn/Intersect(交集)

var list1 = new[] { 1, 2, 3, 4 };
var list2 = new[] { 3, 4, 5, 6 };
list1.GetItemIn(list2); // {3, 4}
list1.Intersect(list2, (a, b) => a == b); // {3, 4}

GetItemNotIn/Except(差集)

var list1 = new[] { 1, 2, 3, 4 };
var list2 = new[] { 3, 4, 5, 6 };
list1.GetItemNotIn(list2); // {1, 2}
list1.Except(list2, (a, b) => a == b); // {1, 2}