Wolfgang.Extensions.IEnumerable 1.4.0

Wolfgang.Extensions.IEnumerable

A collection of extension methods for IEnumerable<T> in .NET.

📦 Installation

dotnet add package Wolfgang.Extensions.IEnumerable

NuGet Package: Wolfgang.Extensions.IEnumerable

📄 License

This project is licensed under the MIT License. See the LICENSE file for details.

📚 Documentation

• GitHub Repository: https://github.com/Chris-Wolfgang/IEnumerable-Extensions
• API Documentation: https://Chris-Wolfgang.github.io/IEnumerable-Extensions/
• CHANGELOG: CHANGELOG.md
• Contributing Guide: CONTRIBUTING.md

🚀 Quick Start

using System.Collections.Generic;
using System.Linq;
using Wolfgang.Extensions.IEnumerable;

var items = new[] { 1, 2, 3, 4, 5 };

items.ForEach(Console.WriteLine);                 // prints 1..5 (eager)

var doubled = items
    .Do(x => Console.WriteLine($"seen: {x}"))     // lazy passthrough side-effect
    .Select(x => x * 2)
    .ToList();

items.IsEmpty();                                  // false
((int[]?)null).IsNullOrEmpty();                   // true (only IsNullOrEmpty accepts null)
items.None(x => x > 10);                          // true
items.None();                                     // false (has items)

var shuffled = items.Shuffle().ToList();          // random order (Fisher-Yates)

None of these methods mutate the source sequence — ForEach and Do invoke your Action<T> for its side effects but never modify the upstream items themselves. Only IsNullOrEmpty accepts a null source (returns true); every other method throws ArgumentNullException when source is null. Methods that take an action / predicate also throw on a null callback.

✨ Features

Methods

Examples

using System.Collections.Generic;
using System.Linq;
using Wolfgang.Extensions.IEnumerable;

// ForEach vs Do
new[] { 1, 2, 3 }.ForEach(Console.WriteLine);       // 1 2 3 (eager, void)
var pipeline = new[] { 1, 2, 3 }
    .Do(x => Console.WriteLine($"tap: {x}"))        // lazy passthrough
    .Where(x => x > 1);                             // logs only when enumerated

// Emptiness
new int[0].IsEmpty();                                // true
((IEnumerable<int>?)null).IsNullOrEmpty();           // true (null-tolerant)
// ((IEnumerable<int>?)null).IsEmpty();              // throws ArgumentNullException

// None
new[] { 1, 2, 3 }.None();                            // false
new[] { 1, 2, 3 }.None(x => x < 0);                  // true

// Shuffle
var deck = Enumerable.Range(1, 52).Shuffle().ToList();

// ToEnumerable — strip the concrete type for test fixtures that need to
// exercise the non-ICollection slow path.
IEnumerable<int> slowPath = new List<int> { 1, 2, 3 }.ToEnumerable();
// slowPath is List<int>      // false
// slowPath is ICollection<int> // false

🎯 Target Frameworks

🛠️ Building from Source

Prerequisites

• .NET 10.0 SDK
• Optional: PowerShell Core for formatting scripts

Build Steps

git clone https://github.com/Chris-Wolfgang/IEnumerable-Extensions.git
cd IEnumerable-Extensions
dotnet restore
dotnet build --configuration Release
dotnet test --configuration Release

🤝 Contributing

Contributions are welcome! Please see CONTRIBUTING.md for code quality standards, build and test instructions, and pull request guidelines.