HonkPerf.NET

Collection of performant (but limited in usage) replacements for BCL's types and methods;

RefLinq

Summary

RefLinq is like Linq, but it must be only used within a method, so behaves more limited than ref structs. Its benefit - it does not make allocations for enumerators and captured variables (given that you use it properly). Its API does not differ much from that of Linq.

So, basically given that you have some sequence, you do .ToRefLinq() on it, and the rest of API is the same. All API which does not make heap allocations is available.

Example:

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

...

var localVar = 5;
var seq =
    arr
    .ToRefLinq()                // magic method
    .Select(c => c + 5)
    .Where(c => c % 2 == 0)
    .Select((c, localVar) => c - 6.0 / localVar, localVar) // capture-less capture
    .Append(3)                  // alloc-less append
    .Append(5)
    .Prepend(3)
    .Concat(arr.ToRefLinq().Select(c => c / 1d))  // concatenation
    ;
return seq.Sum() + seq.Max();

In the example above, no heap allocation happens aside from the one to allocate arr in the first line. Though even that may be optimized if you make stack allocation (and use HonkPerf.NET's FixedReadOnlySpan<T>), but that's on your side.

Similar Libraries

• Hyperlinq
• LinqFaster
• ValueLinq
• LinqAF
• NoAlloq
• StructLinq
• LinqGen

Benchmarks

That's yet another linq library. Why use it? Here's a few benchmarks.

We mark bold the one doing the least allocations and italic the fastest one.

Select & Where

Append & Prepend

Select, Where, Zip, Sum

Select, Where, Append, Prepend, Concat, Sum, Max

Conclusion

There's no "best" linq library. RefLinq is great at avoiding allocations, but sometimes there are faster alternatives (see benchmarks). It provides good API to avoid allocations on captures: you provide the captured function as a last argument, and accept it in the delegate. It also allows to create value delegates identically to how it's done in other libraries. However, it does not offer hundreds of overloads for different use cases to save a few nanoseconds.

Also, the mentioned libraries have different APIs and different coverage of LINQ methods. Some of them don't require the "magic" method, but they may conflict with LINQ then. Some of them lack methods like Append and Prepend, others don't have Zip, etc. RefLinq is not an exception, and it does not have APIs which would require heap allocation.