{"repo":"Cysharp/ZLinq","free":true,"listed":false,"github":"https://github.com/Cysharp/ZLinq","clone":"git clone https://github.com/Cysharp/ZLinq.git","description":"Zero allocation LINQ with LINQ to Span, LINQ to SIMD, and LINQ to Tree (FileSystem, JSON, GameObject, etc.) for all .NET platforms and Unity, Godot.","language":"C#","stars":5237,"topics":["c-sharp","linq","unity"],"license":"MIT","category":"dev_tool","readme_excerpt":"ZLinq\n===\n[![CI](https://github.com/Cysharp/ZLinq/actions/workflows/build-debug.yaml/badge.svg)](https://github.com/Cysharp/ZLinq/actions/workflows/build-debug.yaml)\n[![Benchmark](https://github.com/Cysharp/ZLinq/actions/workflows/benchmark.yaml/badge.svg)](https://github.com/Cysharp/ZLinq/actions/workflows/benchmark.yaml)\n[![NuGet](https://img.shields.io/nuget/v/ZLinq)](https://www.nuget.org/packages/ZLinq)\n[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/Cysharp/ZLinq)\n\nZero allocation LINQ with LINQ to Span, LINQ to SIMD, and LINQ to Tree (FileSystem, JSON, GameObject, etc.) for all .NET platforms(netstandard2.0, 2.1, net8, net9) and Unity, Godot.\n\n![](img/benchmarkhead.jpg)\n\nUnlike regular LINQ, ZLinq doesn't increase allocations when adding more method chains, and it also has higher basic performance. You can check various benchmark patterns at [GitHub Actions/Benchmark](https://github.com/Cysharp/ZLinq/actions/runs/19324633887). ZLinq shows high performance in almost all patterns, with some benchmarks showing overwhelming differences.\n\nAs a bonus, LINQ operators and optimizations equivalent to .NET 10 can be used in .NET Framework 4.8 (netstandard2.0) and Unity (netstandard2.1).\n\n```bash\ndotnet add package ZLinq\n```\n\n```csharp\nusing ZLinq;\n\nvar seq = source\n    .AsValueEnumerable() // only add this line\n    .Where(x => x % 2 == 0)\n    .Select(x => x * 3);\n\nforeach (var item in seq) { }\n```\n\n* **99% compatibility** with .NET 10's LINQ (including new `Shuffle`, `RightJoin`, `LeftJoin`, `Sequence`, `InfiniteSequence` operators)\n* **Zero allocation** for method chains through struct-based Enumerable via `ValueEnumerable`\n* **LINQ to Span** to full support LINQ operations on `Span<T>` using .NET 9/C# 13's `allows ref struct`\n* **LINQ to Tree** to extend tree-structured objects (built-in support for FileSystem, JSON, GameObject)\n* **LINQ to SIMD** to automatic application of SIMD where possible and customizable arbitrary operations\n* Optional **Drop-in replacement** Source Generator to automatically accelerate all LINQ methods\n\nIn ZLinq, we have proven high compatibility and performance by running [dotnet/runtime's System.Linq.Tests](https://github.com/Cysharp/ZLinq/tree/main/tests/System.Linq.Tests) as a drop-in replacement, passing 9000 tests.\n\n![](img/testrun.png)\n\nPreviously, value type-based LINQ implementations were often experimental, but ZLinq fully implements all methods to completely replace standard LINQ in production use, delivering high performance suitable even for demanding applications like games. The performance aspects are based on my experience with previous LINQ implementations ([linq.js](https://github.com/neuecc/linq.js/), [SimdLinq](https://github.com/Cysharp/SimdLinq/), [UniRx](https://github.com/neuecc/UniRx), [R3](https://github.com/Cysharp/R3)), zero-allocation implementations ([ZString](https://github.com/Cysharp/ZString), [ZLogger](https://github.com/Cysharp/ZLogger)), and high-performance serializers ([MessagePack-CSharp](https://github.com/MessagePack-CSharp/MessagePack-CSharp/), [MemoryPack](https://github.com/Cysharp/MemoryPack)).\n\nZLinq achieves zero-allocation LINQ implementation using the following structs and interfaces.\n\n```csharp\npublic readonly ref struct ValueEnumerable<TEnumerator, T>(TEnumerator enumerator)\n    where TEnumerator : struct, IValueEnumerator<T>, allows ref struct\n{\n    public readonly TEnumerator Enumerator = enumerator;\n}\n\npublic interface IValueEnumerator<T> : IDisposable\n{\n    bool TryGetNext(out T current); // as MoveNext + Current\n\n    // Optimization helper\n    bool TryGetNonEnumeratedCount(out int count);\n    bool TryGetSpan(out ReadOnlySpan<T> span);\n    bool TryCopyTo(scoped Span<T> destination, Index offset);\n}\n```\n\nBesides changing to a struct-based approach, we've integrated MoveNext and Current to reduce the number of iterator calls. Also, some operators don't need to hold Current, which allows minimizing the struct size. Additionally, being struct-based, we efficiently separate internal state by copying the Enumerator instead of using GetEnumerator. With .NET 9/C# 13 or later, `allows ref struct` enables natural integration of `Span<T>` into LINQ.\n\n```csharp\npublic static ValueEnumerable<Where<TEnumerator, TSource>, TSource> Where<TEnumerator, TSource>(this ValueEnumerable<TEnumerator, TSource> source, Func<TSource, Boolean> predicate)\n    where TEnumerator : struct, IValueEnumerator<TSource>, allows ref struct\n````\n\nOperators have this method signature. C# cannot infer types from generic constraints([dotnet/csharplang#6930](https://github.com/dotnet/csharplang/discussions/6930)). Therefore, the traditional Struct LINQ approach required implementing all operator combinations as instance methods, resulting in [100,000+ methods and massive assembly sizes](https://kevinmontrose.com/2018/01/17/linqaf-replacing-linq-and-not-allocating/). However, in ZLinq, we've successfully avoided all the boilerplate method implementations by devising an approach that properly conveys types to C# compiler.\n\nAdditionally, `TryGetNonEnumeratedCount(out int count)`, `TryGetSpan(out ReadOnlySpan<T> span)`, and `TryCopyTo(Span<T> destination, Index offset)` defined in the interface itself enable flexible optimizations. To minimize assembly size, we've designed the library to achieve maximum optimization with minimal method additions. For example, `TryCopyTo` works efficiently with methods like `ToArray` when combined with `TryGetNonEnumeratedCount`. However, it also allows copying to smaller-sized destinations. By combining this with Index, we can optimize `First`, `Last`, and `ElementAt` using just `TryCopyTo` by passing a single-element Span along with an Index.\n\nIf you're interested in architecture, please read my blog post [**\"ZLinq\", a Zero-Allocation LINQ Library for .NET**](https://neuecc.medium.com/zlinq-a-zero-allocation-linq-library-for-net-1bb0a3e5c749) where I wrote the details.\n\nGetting Started\n---\nYou can install package from [NuGet/ZLinq](https://www.nuget.org/packages/ZLinq). For Unity usage, refer to the [Unity section](#unity). For Godot usage, refer to the [Godot section](#godot).\n\n```bash\ndotnet add package ZLinq\n```\n\nUse `using ZLinq;` and call `AsValueEnumerable()` on any iterable type to use ZLinq's zero-allocation LINQ.\n\n```csharp\nusing ZLinq;\n\nvar source = new int[] { 1, 2, 3, 4, 5 };\n\n// Call AsValueEnumerable to apply ZLinq\nvar seq1 = source.AsValueEnumerable().Where(x => x % 2 == 0);\n\n// Can also be applied to Span (only in .NET 9/C# 13 environments that support allows ref struct)\nSpan<int> span = stackalloc int[5] { 1, 2, 3, 4, 5 };\nvar seq2 = span.AsValueEnumerable().Select(x => x * x);\n```\n\nEven if it's netstandard 2.0 or below .NET 10, all operators up to .NET 10 are available.\n\nYou can method chain and foreach like regular LINQ, but there are some limitations. Please see [Difference and Limitation](#difference-and-limitation) for details. ZLinq has drop-in replacements that apply ZLinq without needing to call `AsValueEnumerable()`. For more information, see [Drop-in replacement](#drop-in-replacement). Detailed information about [LINQ to Tree](#linq-to-tree) for LINQ-ifying tree structures (FileSystems and JSON) and [LINQ to SIMD](#linq-to-simd) for expanding SIMD application range can be found in their respective sections.\n\nAdditional Operators\n---\nIn ZLinq, we prioritize compatibility, so we try to minimize adding custom operators. However, the following methods have been added to enable efficient processing with zero allocation:\n\n### `AsValueEnumerable()`\n\nConverts existing collections to a type that can be chained with ZLinq. Any `IEnumerable<T>` can be converted, but for the following types, conversion is done with zero allocation without `IEnumerable<T>.GetEnumerator()` allocation. Standard supported types are `T[]`, `List<T>`, `ArraySegment<T>`, `Memory<T>`, `ReadOnlyMemory<T>`, `ReadOnlySequence<T>`, `Dictionary<TKey, TValue>`, `Queue<T>`, `Stack<T>`, `LinkedList<T>`, `HashSet<T>`, `ImmutableArray<T>`, `Span<T>`, `ReadOnlySpan<T>`. However, conversion from `ImmutableArray<T>` requires `.NET 8` or higher, and conversion from `Span<T>`, `ReadOnlySpan<T>` requires `.NET 9` or higher.\n\nWhen a type is declared as `IEnumerable<T>` or `ICollection<T>` rather than concrete types like `T[]` or `List<T>`, generally additional allocations occur when using foreach. In `ZLinq`, even when these interfaces are declared, if the actual type is `T[]` or `List<T>`, processing is performed with zero allocation.\n\nConvert from `System.Collections.IEnumerable` is also supported. In that case, using `AsValueEnumerable()` without specifying a type converts to `ValueEnumerable<, object>`, but you can also cast it simultaneously by `AsValueEnumerable<T>()`.\n\n```csharp\nIEnumerable nonGenericCollection = default!;\nnonGenericCollection.AsValueEnumerable(); // ValueEnumerable<, object>\nnonGenericCollection.AsValueEnumerable<int>(); // ValueEnumerable<, int>\n```\n\n### `ValueEnumerable.Range()`, `ValueEnumerable.Repeat()`, `ValueEnumerable.Empty()`\n\n`ValueEnumerable.Range` operates more efficiently when handling with `ZLinq` than `Enumerable.Range().AsValueEnumerable()`. The same applies to `Repeat` and `Empty`. The Range can also handle step increments, `INumber<T>`, `DateTime`, and more. Please refer to the [Range and Sequence](#range-and-sequence) section for details.\n\n### `Sequence`, `InfiniteSequence` for all .NET Platforms\n\n`Sequence` and `InfiniteSequence` were added in .NET 10. They require `INumber<T>`, but `INumber<T>` was introduced in `.NET 7`. `ZLinq` implements `INumber<T>` methods the same as standard LINQ, but additionaly adds primitive type overloads(`byte/sbyte/ushort/char/short/uint/int/ulong/long/float/double/decimal`) to support all .NET Platforms(includes .NET Standard 2.0). Additionaly, as a bonus, `DateTime` and `DateTimeOffset` overload exists.\n\n### `Average() : where INumber<T>`, `Sum() : where INumber<T>`\n\nSys","default_branch":"main","files":692,"tree":[".claude/settings.local.json",".editorconfig",".github/FUNDING.yml",".github/codecov.yml",".github/copilot-instructions.md",".github/dependabot.yaml",".github/workflows/benchmark.yaml",".github/workflows/benchmark_on_release.yaml",".github/workflows/build-debug.yaml",".github/workflows/build-release.yaml",".github/workflows/pr-harness.yaml",".github/workflows/stale.yaml",".gitignore","CLAUDE.md","Directory.Build.props","Icon.png","LICENSE","README.md","ZLinq.slnx","exclusion.dic","img/ZLinqIntellisense.jpg","img/axis.jpg","img/benchmarkhead.jpg","img/big_precise.jpg","img/dropin.jpg","img/godot.jpg","img/icon.jpg","img/linqaf_intellisense.jpg","img/original.pptx","img/screen_3.jpg","img/small_precise.jpg","img/testrun.png","img/title_bench.jpg","img/typeinference.jpg","img/unityforeach.png","img/uploader.md","img/using.jpg","opensource.snk","sandbox/.editorconfig","sandbox/Benchmark/Benchmark.csproj","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/BaseBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/ColdStartBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/DefaultBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/InProcessBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/InProcessMonitoringBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/NuGetVersionsBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/SystemLinqBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/BenchmarkConfigs/TargetFrameworksBenchmarkConfig.cs","sandbox/Benchmark/BenchmarkDotNet/EventProcessors/BenchmarkEventProcessor.cs","sandbox/Benchmark/BenchmarkDotNet/ExtensionMethods/ConsumerExtensions.BinaryOperations.cs","sandbox/Benchmark/BenchmarkDotNet/ExtensionMethods/ConsumerExtensions.UnaryOperations.cs","sandbox/Benchmark/BenchmarkDotNet/ExtensionMethods/ConsumerExtensions.cs","sandbox/Benchmark/BenchmarkDotNet/ExtensionMethods/SummariesExtensions.cs","sandbox/Benchmark/BenchmarkDotNet/ExtensionMethods/SummaryTableExtensions.cs","sandbox/Benchmark/BenchmarkDotNet/Filters/TargetFrameworkFilter.cs","sandbox/Benchmark/BenchmarkDotNet/Filters/ZLinqBenchmarkFilter.cs","sandbox/Benchmark/BenchmarkDotNet/Filters/ZLinqNuGetVersionFilter.cs","sandbox/Benchmark/Benchmarks/AllAnyPredicateWithCapturedLambda.cs","sandbox/Benchmark/Benchmarks/AsValueEnumerableBench.cs","sandbox/Benchmark/Benchmarks/CastOfType.cs","sandbox/Benchmark/Benchmarks/DistinctBattle.cs","sandbox/Benchmark/Benchmarks/HugeChain.cs","sandbox/Benchmark/Benchmarks/IterateBenchmark.cs","sandbox/Benchmark/Benchmarks/LinqAf/LinqAfCrazy.cs","sandbox/Benchmark/Benchmarks/LinqAf/LinqAfJoin.cs","sandbox/Benchmark/Benchmarks/LinqAf/LinqAfToLookup.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.AggregateBy00.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.Count00.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.CountBy00.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.GroupBy00.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.Order00.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.Where00.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.Where01.cs","sandbox/Benchmark/Benchmarks/LinqPerfBenchmarks.cs","sandbox/Benchmark/Benchmarks/LookupBattle.cs","sandbox/Benchmark/Benchmarks/Net80OptimizedBenchmark.cs","sandbox/Benchmark/Benchmarks/Net90OptimizedBenchmark.cs","sandbox/Benchmark/Benchmarks/OrderTakeBenchmark.cs","sandbox/Benchmark/Benchmarks/ReadMeBenchmark.cs","sandbox/Benchmark/Benchmarks/ReadMeBenchmark2.cs","sandbox/Benchmark/Benchmarks/Select4.cs","sandbox/Benchmark/Benchmarks/Select4_Consume.cs","sandbox/Benchmark/Benchmarks/SelectFromEnumerableArray.cs","sandbox/Benchmark/Benchmarks/SelectFromSourceTypes.cs","sandbox/Benchmark/Benchmarks/ShuffleBench.cs","sandbox/Benchmark/Benchmarks/SimdAggregate.cs","sandbox/Benchmark/Benchmarks/SimdAny.cs","sandbox/Benchmark/Benchmarks/SimdCount.cs","sandbox/Benchmark/Benchmarks/SimdRange.cs","sandbox/Benchmark/Benchmarks/SimdSelect.cs","sandbox/Benchmark/Benchmarks/SimdSum.cs","sandbox/Benchmark/Benchmarks/SimdZip.cs","sandbox/Benchmark/Benchmarks/StringJoinBenchmark.cs","sandbox/Benchmark/Benchmarks/TakeLastBenchmark.cs","sandbox/Benchmark/Benchmarks/TakeRangeBench.cs","sandbox/Benchmark/Benchmarks/VectorizableUpdate.cs","sandbox/Benchmark/Benchmarks/WhereBenchmark.cs","sandbox/Benchmark/Benchmarks/WhereCountPredicate.cs","sandbox/Benchmark/Benchmarks/WhereSelectBenchmark.cs","sandbox/Benchmark/Benchmarks/WhereSelectStringJoin.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/ConcatBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/ExceptBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/GroupJoinBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/IntersectBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/JoinBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/LeftJoinBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/RightJoinBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/UnionBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/BinaryOperations/ZipBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Others/CopyToBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Others/SelectFromEnumerableBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Others/ToArrayPoolBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/AggregateBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/AggregateByBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/AllBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/AnyBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/AverageBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ContainsBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/CountBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/CountByBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ElementAtBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ElementAtOrDefaultBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/FirstBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/FirstOrDefaultBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/LastBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/LastOrDefaultBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/LongCountBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/MaxBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/MinBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/SequenceEqualBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/SingleBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/SingleOrDefaultBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/SumBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToArrayBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToDictionaryBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToFrozenDictionaryBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToFrozenSetBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToHashSetBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToImmutableArrayBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToImmutableDictionaryBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToImmutableHashSetBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToImmutableListBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToImmutableSortedDictionaryBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToImmutableSortedSetBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToListBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/Sinks/ToLookupBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/AppendBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/CastBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/DefaultIfEmptyBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/DistinctBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/DistinctByBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/GroupByBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/OfTypeBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/OrderBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/OrderByBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/OrderByDescendingBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/OrderDescendingBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/PrependBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/ReverseBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/SelectBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/SelectManyBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/ShuffleBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/SkipBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/SkipLastBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/SkipWhileBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/TakeBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/TakeLastBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/TakeWhileBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/ThenByBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/ThenByDescendingBenchmark.cs","sandbox/Benchmark/Benchmarks/ZLinq/MicroBenchmarks/UnaryOperations/WhereBenchmark.cs","sandbox/Benchmark/Categories.cs","sandbox/Benchmark/Constants.cs","sandbox/Benchmark/ExtensionMethods/TypeExtensions.cs","sandbox/Benchmark/ExtensionMethods/ValueEnumerableExtensions.SystemLinq.cs","sandbox/Benchmark/ExtensionMethods/ValueEnumerableExtensions.ZLinq.cs","sandbox/Benchmark/ExtensionMethods/ValueEnumerableExtensions.cs","sandbox/Benchmark/Models/BenchmarkReport.cs","sandbox/Benchmark/Program.cs","sandbox/Benchmark/Properties/launchSettings.json","sandbox/Benchmark/README.md","sandbox/Benchmark/TestData/BenchmarkBase/EnumerableBenchmarkBase.cs","sandbox/Benchmark/TestData/BenchmarkBase/EnumerableBenchmarkBase_WithBasicTypes.cs","sandbox/Benchmark/TestData/DataGenerators/CustomGenerators/SampleClassGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/CustomGenerators/SampleReadOnlyRecordStructGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/CustomGenerators/SampleRecordGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/CustomGenerators/SampleRecordStructGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/CustomGenerators/SampleStructGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/DataGeneratorContext.cs","sandbox/Benchmark/TestData/DataGenerators/DefaultDataGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/IDataGenerator.cs","sandbox/Benchmark/TestData/DataGenerators/IDataItemGenerator.cs","sandbox/Benchmark/TestData/Models/SampleClass.cs","sandbox/Benchmark/TestData/Models/SampleReadOnlyRecordStruct.cs","sandbox/Benchmark/TestData/Models/SampleRecordClass.cs","sandbox/Benchmark/TestData/Models/SampleRecordStruct.cs","sandbox/Benchmark/TestData/Models/SampleStruct.cs","sandbox/Benchmark/TestData/Models/TestCollection_IList.cs","sandbox/Benchmark/TestData/TestDataGenerator.cs","sandbox/Benchmark/TestData/TestDataSource.cs","sandbox/ConsoleApp/ConsoleApp.csproj","sandbox/ConsoleApp/Empty.cs","sandbox/ConsoleApp/ExtensionTest.cs","sandbox/ConsoleApp/Program.cs","sandbox/ConsoleAppNativeAOT/ConsoleAppNativeAOT.csproj","sandbox/ConsoleAppNativeAOT/Program.cs","sandbox/ConsoleAppNet6/ConsoleAppNet6.csproj","sandbox/ConsoleAppNet6/Program.cs","sandbox/ConsoleAppNetFramework48/App.config","sandbox/ConsoleAppNetFramework48/ConsoleAppNetFramework48.csproj","sandbox/ConsoleAppNetFramework48/Program.cs","sandbox/ConsoleAppNetFramework48/Properties/AssemblyInfo.cs","src/FileGen/Commands.cs","src/FileGen/DropIn/Array.cs","src/FileGen/DropIn/ForExtension.cs","src/FileGen/DropIn/IEnumerable.cs","src/FileGen/DropIn/List.cs","src/FileGen/DropIn/Memory.cs","src/FileGen/DropIn/ReadOnlyMemory.cs","src/FileGen/DropIn/ReadOnlySpan.cs","src/FileGen/DropIn/Span.cs","src/FileGen/DropinGen.cs","src/FileGen/FileGen.csproj","src/FileGen/LinqTemplate.cs","src/FileGen/Program.cs","src/FileGen/Properties/launchSettings.json","src/ZLinq.DropInGenerator/DiagnosticDescriptors.cs","src/ZLinq.DropInGenerator/DropInGenerator.cs","src/ZLinq.DropInGenerator/Properties/launchSettings.json","src/ZLinq.DropInGenerator/RoslynExtensions.cs","src/ZLinq.DropInGenerator/StringExtensions.cs","src/ZLinq.DropInGenerator/ZLinq.DropInGenerator.csproj","src/ZLinq.DropInGenerator/bin/Debug/netstandard2.0/ZLinq.DropInGenerator.dll.meta","src/ZLinq.DropInGenerator/bin/Debug/netstandard2.0/package.json","src/ZLinq.DropInGenerator/bin/Debug/netstandard2.0/package.json.meta","src/ZLinq.FileSystem/FileSystemInfoTraversable.cs","src/ZLinq.FileSystem/ZLinq.FileSystem.csproj","src/ZLinq.Godot/NodeTraverser.cs","src/ZLinq.Godot/NodeTraverserExtensions.cs","src/ZLinq.Godot/ZLinq.Godot.csproj","src/ZLinq.Json/JsonNodeTraversable.cs","src/ZLinq.Json/ZLinq.Json.csproj","src/ZLinq.Unity/.vsconfig","src/ZLinq.Unity/Assets/NuGet.config","src/ZLinq.Unity/Assets/NuGet.config.meta","src/ZLinq.Unity/Assets/Packages.meta","src/ZLinq.Unity/Assets/Scenes.meta","src/ZLinq.Unity/Assets/Scenes/NewBehaviourScript.cs","src/ZLinq.Unity/Assets/Scenes/NewBehaviourScript.cs.meta","src/ZLinq.Unity/Assets/Scenes/SampleScene.unity","src/ZLinq.Unity/Assets/Scenes/SampleScene.unity.meta","src/ZLinq.Unity/Assets/ZLinq.Unity.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/External.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/External/UnityCollections.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/External/UnityCollections/UnityCollectionsExtensions.cs","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/External/UnityCollections/UnityCollectionsExtensions.cs.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/External/UnityCollections/ZLinq.Unity.UnityCollections.asmdef","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/External/UnityCollections/ZLinq.Unity.UnityCollections.asmdef.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/GameObjectTraverser.cs","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/GameObjectTraverser.cs.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/NativeArrayExtensions.cs","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/NativeArrayExtensions.cs.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/OfComponent.cs","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/OfComponent.cs.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/TransformTraverser.cs","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/TransformTraverser.cs.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/VisualElementTraverser.cs","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/VisualElementTraverser.cs.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/ZLinq.Unity.asmdef","src/ZLinq.Unity/Assets/ZLinq.Unity/Runtime/ZLinq.Unity.asmdef.meta","src/ZLinq.Unity/Assets/ZLinq.Unity/package.json","src/ZLinq.Unity/Assets/ZLinq.Unity/package.json.meta","src/ZLinq.Unity/Assets/packages.config","src/ZLinq.Unity/Assets/packages.config.meta","src/ZLinq.Unity/Packages/manifest.json","src/ZLinq.Unity/Packages/packages-lock.json","src/ZLinq.Unity/ProjectSettings/AudioManager.asset","src/ZLinq.Unity/ProjectSettings/ClusterInputManager.asset","src/ZLinq.Unity/ProjectSettings/DynamicsManager.asset","src/ZLinq.Unity/ProjectSettings/EditorBuildSettings.asset","src/ZLinq.Unity/ProjectSettings/EditorSettings.asset","src/ZLinq.Unity/ProjectSettings/GraphicsSettings.asset","src/ZLinq.Unity/ProjectSettings/InputManager.asset","src/ZLinq.Unity/ProjectSettings/MemorySettings.asset","src/ZLinq.Unity/ProjectSettings/NavMeshAreas.asset","src/ZLinq.Unity/ProjectSettings/NetworkManager.asset","src/ZLinq.Unity/ProjectSettings/PackageManagerSettings.asset","src/ZLinq.Unity/ProjectSettings/Physics2DSettings.asset","src/ZLinq.Unity/ProjectSettings/PresetManager.asset","src/ZLinq.Unity/ProjectSettings/ProjectSettings.asset","src/ZLinq.Unity/ProjectSettings/ProjectVersion.txt","src/ZLinq.Unity/ProjectSettings/QualitySettings.asset","src/ZLinq.Unity/ProjectSettings/SceneTemplateSettings.json","src/ZLinq.Unity/ProjectSettings/TagManager.asset","src/ZLinq.Unity/ProjectSettings/TimeManager.asset","src/ZLinq.Unity/ProjectSettings/UnityConnectSettings.asset","src/ZLinq.Unity/ProjectSettings/VFXManager.asset","src/ZLinq.Unity/ProjectSettings/VersionControlSettings.asset","src/ZLinq.Unity/ProjectSettings/XRSettings.asset","src/ZLinq/ITraverser.cs","src/ZLinq/Internal/DictionarySlim.cs","src/ZLinq/Internal/EnumeratorHelper.cs","src/ZLinq/Internal/HashSetSlim.cs","src/ZLinq/Internal/Polyfill/ArgumentNullException.cs","src/ZLinq/Internal/Polyfill/ArraySegmentExtensions.cs","src/ZLinq/Internal/Polyfill/BitOperations.cs","src/ZLinq/Internal/Polyfill/CollectionsMarshal.cs","src/ZLinq/Internal/Polyfill/EnumerableExtensions.cs","src/ZLinq/Internal/Polyfill/GC.cs","src/ZLinq/Internal/Polyfill/MemoryExtensions.cs","src/ZLinq/Internal/Polyfill/RuntimeHelpers.cs","src/ZLinq/Internal/Polyfill/StringExtensions.cs","src/ZLinq/Internal/RandomShared.cs","src/ZLinq/Internal/RefBox.cs","src/ZLinq/Internal/RefStack.cs","src/ZLinq/Internal/RentedArrayBox.cs","src/ZLinq/Internal/RentedRingBuffer.cs","src/ZLinq/Internal/SegmentedArrayProvider.cs","src/ZLinq/Internal/SingleSpan.cs","src/ZLinq/Internal/Throws.cs","src/ZLinq/Internal/ValueQueue.cs","src/ZLinq/Internal/ValueStringBuilder.cs","src/ZLinq/Linq/Aggregate.cs","src/ZLinq/Linq/AggregateBy.cs","src/ZLinq/Linq/All.cs","src/ZLinq/Linq/Any.cs","src/ZLinq/Linq/Append.cs","src/ZLinq/Linq/AsValueEnumerable.cs","src/ZLinq/Linq/Average.cs","src/ZLinq/Linq/Cast.cs","src/ZLinq/Linq/Chunk.cs","src/ZLinq/Linq/Concat.cs","src/ZLinq/Linq/Contains.cs","src/ZLinq/Linq/CopyTo.cs","src/ZLinq/Linq/Count.cs","src/ZLinq/Linq/CountBy.cs","src/ZLinq/Linq/DefaultIfEmpty.cs","src/ZLinq/Linq/Distinct.cs","src/ZLinq/Linq/DistinctBy.cs","src/ZLinq/Linq/ElementAt.cs","src/ZLinq/Linq/Empty.cs","src/ZLinq/Linq/Except.cs","src/ZLinq/Linq/ExceptBy.cs","src/ZLinq/Linq/First.cs","src/ZLinq/Linq/GroupBy.cs","src/ZLinq/Linq/GroupJoin.cs","src/ZLinq/Linq/Index.cs","src/ZLinq/Linq/InfiniteSeqeunce.Primitives.cs","src/ZLinq/Linq/InfiniteSequence.DateTime.cs","src/ZLinq/Linq/InfiniteSequence.cs","src/ZLinq/Linq/Intersect.cs","src/ZLinq/Linq/IntersectBy.cs","src/ZLinq/Linq/Join.cs","src/ZLinq/Linq/JoinToString.cs","src/ZLinq/Linq/Last.cs","src/ZLinq/Linq/LeftJoin.cs","src/ZLinq/Linq/LongCount.cs","src/ZLinq/Linq/Max.cs","src/ZLinq/Linq/MaxBy.cs","src/ZLinq/Linq/Min.cs","src/ZLinq/Linq/MinBy.cs","src/ZLinq/Linq/OfType.cs","src/ZLinq/Linq/OrderBy.cs","src/ZLinq/Linq/Prepend.cs","src/ZLinq/Linq/Range.cs","src/ZLinq/Linq/Repeat.cs","src/ZLinq/Linq/Reverse.cs","src/ZLinq/Linq/RightJoin.cs","src/ZLinq/Linq/Select.cs","src/ZLinq/Linq/SelectMany.cs","src/ZLinq/Linq/Sequence.DateTime.cs","src/ZLinq/Linq/Sequence.Primitives.cs","src/ZLinq/Linq/Sequence.cs","src/ZLinq/Linq/SequenceEqual.cs","src/ZLinq/Linq/Shuffle.SkipTake.cs","src/ZLinq/Linq/Shuffle.cs","src/ZLinq/Linq/Single.cs","src/ZLinq/Linq/Skip.cs","src/ZLinq/Linq/SkipLast.cs","src/ZLinq/Linq/SkipWhile.cs","src/ZLinq/Linq/Sum.cs","src/ZLinq/Linq/Take.cs","src/ZLinq/Linq/TakeLast.cs","src/ZLinq/Linq/TakeWhile.cs","src/ZLinq/Linq/ToArray.cs","src/ZLinq/Linq/ToArrayPool.cs","src/ZLinq/Linq/ToDictionary.cs","src/ZLinq/Linq/ToFrozenCollections.cs","src/ZLinq/Linq/ToHashSet.cs","src/ZLinq/Linq/ToImmutableCollections.cs","src/ZLinq/Linq/ToList.cs","src/ZLinq/Linq/ToLookup.cs","src/ZLinq/Linq/TryGetNonEnumeratedCount.cs","src/ZLinq/Linq/Union.cs","src/ZLinq/Linq/UnionBy.cs","src/ZLinq/Linq/Where.cs","src/ZLinq/Linq/Zip.cs","src/ZLinq/Simd/Aggregate.cs","src/ZLinq/Simd/All.cs"],"storefront":"/r/Cysharp","claimed":false,"request_supported":{"post":"https://gitbuyer.com/r/Cysharp/ZLinq/request-supported","requests":0},"note":"indexed from public GitHub; nothing is for sale on this page. Clone it from GitHub. Paid listings live at /search."}