Collection

Empty(集合判空)

备注

判断集合是否为空, 当集合为 null 或者其中的元素为空时返回 true

using Collapsenav.Net.Tool;
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

AllContain(A是否包含B)

备注

用于判断 A集合是完全包含 B集合, 当 B 被完全包含在 A 中时, 返回 true

using Collapsenav.Net.Tool;
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, "2", "8", "10", "11", "20"); // False
strList.AllContain(new[] { "2", "6" }, (x, y) => x == y); // True
strList.AllContain(new[] { "2", "6" }, x => x); // True

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

备注

用于判断 A集合是否部分包含了 B 集合中的元素, 只要包含一个元素则为 True

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(new[] { "2", "8" }, (x, y) => x == y); // True
strList.HasContain((x, y) => x == y, "7", "8"); // False

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 }

提示

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}
*/

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();
// 1,2,3,4

提示

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

intList.Unique(item => item);
intList.Unique((x, y) => x == y);

SequenceEqual(集合是否相等)

备注

判断两个集合是否相等, 针对自定义类型可以通过传入委托进行去重

IEnumerable<UserInfo> userInfos = new List<UserInfo> {
    new(){UserName="23331",Age=231 },
    new(){UserName="23332",Age=232 },
};
IEnumerable<UserInfo> userInfosCopy = new List<UserInfo> {
    new(){UserName="23331",Age=231 },
    new(){UserName="23332",Age=232 },
};
IEnumerable<UserInfo> userInfosNotCopy = new List<UserInfo> {
    new(){UserName="23331",Age=23 },
    new(){UserName="23332",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

Shuffle

备注

打乱集合内元素的顺序

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

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);

提示

如果继承了 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

信息

返回带index的集合, 主要是为了方便写 foreach

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

提示

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

foreach (var (item, index) in nums.SelectWithIndex(num => num * num));
foreach (var (item, index) in nums.SelectWithIndex(num => num.ToString(), num => num));

In

备注

判断 A元素是否在 B集合中

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

提示

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

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}

Empty(集合判空)​

AllContain(A是否包含B)​

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

Merge(集合合并)​

SpliteCollection(分割集合)​

WhereIf​

Unique(去重)​

SequenceEqual(集合是否相等)​

Shuffle​

ForEach​

AddRange​

SelectWithIndex​

In​

GetItemIn/Intersect(交集)​

GetItemNotIn/Except(差集)​