11878501063

Committed 17 Nov 2024 11:34AM UTC coverage: 55.617% (+0.07%) from 55.55%

Build # 11878501063

Build Type

Pull #3584

github

Committed by

web-flow

Commit Message

Merge c14575c18 into 8d946b419

Pull Request Pull Request #3584: Remove some ToArrays to reduce memory allocations

Run Details

5879 of 9122 branches covered (64.45%)

Branch coverage included in aggregate %.

27 of 36 new or added lines in 4 files covered. (75.0%)

3 existing lines in 1 file now uncovered.

21924 of 40868 relevant lines covered (53.65%)

84818.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.37

/src/Neo.Extensions/Collections/CollectionExtensions.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// CollectionExtensions.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.


using System;
using System.Collections.Generic;
using System.Linq;


namespace Neo.Extensions
{
    public static class CollectionExtensions
    {
        /// <summary>
        /// Removes the key-value pairs from the dictionary that match the specified predicate.
        /// </summary>
        /// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
        /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
        /// <param name="dict">The dictionary to remove key-value pairs from.</param>
        /// <param name="predicate">The predicate to match key-value pairs.</param>
        /// <param name="afterRemoved">An action to perform after each key-value pair is removed.</param>
        public static void RemoveWhere<TKey, TValue>(
            this IDictionary<TKey, TValue> dict,
            Func<KeyValuePair<TKey, TValue>, bool> predicate,
            Action<KeyValuePair<TKey, TValue>>? afterRemoved = null)
        {
            var items = dict.Where(predicate).ToList();
            foreach (var item in items)
            {
                if (dict.Remove(item.Key))
                    afterRemoved?.Invoke(item);
            }
        }

        /// <summary>
        /// Chunks the source collection into chunks of the specified size.
        /// For example, if the source collection is [1, 2, 3, 4, 5] and the chunk size is 3, the result will be [[1, 2, 3], [4, 5]].
        /// </summary>
        /// <typeparam name="T">The type of the elements in the collection.</typeparam>
        /// <param name="source">The collection to chunk.</param>
        /// <param name="chunkSize">The size of each chunk.</param>
        /// <returns>An enumerable of arrays, each containing a chunk of the source collection.</returns>
        /// <exception cref="ArgumentNullException">Thrown when the source collection is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when the chunk size is less than or equal to 0.</exception>
        public static IEnumerable<T[]> Chunk<T>(this IReadOnlyCollection<T> source, int chunkSize)
        {
            if (source is null)
                throw new ArgumentNullException(nameof(source));

            if (chunkSize <= 0)
                throw new ArgumentOutOfRangeException(nameof(chunkSize), "Chunk size must > 0.");

            using IEnumerator<T> enumerator = source.GetEnumerator();
            for (var remain = source.Count; remain > 0;)
            {
                var chunk = new T[Math.Min(remain, chunkSize)];
                for (var i = 0; i < chunk.Length; i++)
                {
                    if (!enumerator.MoveNext()) // Additional checks
                        throw new InvalidOperationException("unexpected end of sequence");
                    chunk[i] = enumerator.Current;
                }
                remain -= chunk.Length;
                yield return chunk;
            }
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// CollectionExtensions.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12
13	using System;
14	using System.Collections.Generic;
15	using System.Linq;
16
17
18	namespace Neo.Extensions
19	{
20	public static class CollectionExtensions
21	{
22	/// <summary>
23	/// Removes the key-value pairs from the dictionary that match the specified predicate.
24	/// </summary>
25	/// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
26	/// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
27	/// <param name="dict">The dictionary to remove key-value pairs from.</param>
28	/// <param name="predicate">The predicate to match key-value pairs.</param>
29	/// <param name="afterRemoved">An action to perform after each key-value pair is removed.</param>
30	public static void RemoveWhere<TKey, TValue>(
31	this IDictionary<TKey, TValue> dict,
32	Func<KeyValuePair<TKey, TValue>, bool> predicate,
33	Action<KeyValuePair<TKey, TValue>>? afterRemoved = null)
34	{	1✔
35	var items = dict.Where(predicate).ToList();	1✔
36	foreach (var item in items)	5✔
37	{	1✔
38	if (dict.Remove(item.Key))	1✔
39	afterRemoved?.Invoke(item);	1!
40	}	1✔
41	}	1✔
42
43	/// <summary>
44	/// Chunks the source collection into chunks of the specified size.
45	/// For example, if the source collection is [1, 2, 3, 4, 5] and the chunk size is 3, the result will be [[1, 2, 3], [4, 5]].
46	/// </summary>
47	/// <typeparam name="T">The type of the elements in the collection.</typeparam>
48	/// <param name="source">The collection to chunk.</param>
49	/// <param name="chunkSize">The size of each chunk.</param>
50	/// <returns>An enumerable of arrays, each containing a chunk of the source collection.</returns>
51	/// <exception cref="ArgumentNullException">Thrown when the source collection is null.</exception>
52	/// <exception cref="ArgumentOutOfRangeException">Thrown when the chunk size is less than or equal to 0.</exception>
53	public static IEnumerable<T[]> Chunk<T>(this IReadOnlyCollection<T> source, int chunkSize)
54	{	5✔
55	if (source is null)	5!
NEW 56	throw new ArgumentNullException(nameof(source));	×
57
58	if (chunkSize <= 0)	5✔
59	throw new ArgumentOutOfRangeException(nameof(chunkSize), "Chunk size must > 0.");	1✔
60
61	using IEnumerator<T> enumerator = source.GetEnumerator();	4✔
62	for (var remain = source.Count; remain > 0;)	14✔
63	{	8✔
64	var chunk = new T[Math.Min(remain, chunkSize)];	8✔
65	for (var i = 0; i < chunk.Length; i++)	1,046✔
66	{	515✔
67	if (!enumerator.MoveNext()) // Additional checks	515!
NEW 68	throw new InvalidOperationException("unexpected end of sequence");	×
69	chunk[i] = enumerator.Current;	515✔
70	}	515✔
71	remain -= chunk.Length;	8✔
72	yield return chunk;	8✔
73	}	6✔
74	}	2✔
75	}
76	}

neo-project / neo / 11878501063

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous