Implementation in C# of LINQ concept with struct to reduce drastically memory allocation and improve performance. Introduce IRefStructEnumerable to improve performance when element are fat struct.

• Installation
• Usage
• Performances
• Features
  • BCL bindings
  • Transformers
  • Converters
  • LINQ Extensions
  • Other Extensions
• IRefStructEnumerable

This library is distributed via NuGet. To install StructLinq :

PM> Install-Package StructLinq

StructLinq use massively generic concept and struct "specialization".

using StructLinq;
 
int[] array = new [] {1, 2, 3, 4, 5};

int result = array
                .ToStructEnumerable()
                .Where(x => (x & 1) == 0, x=>x)
                .Select(x => x *2, x => x)
                .Sum();

x=>x is used to avoid boxing (and allocation) and to help generic type parameters inference. You can also improve performance by using struct for Where predicate and select function.

All benchmark results are in here. For example following linq sequence:

   list
     .Where(x => (x & 1) == 0)
     .Select(x => x * 2)
     .Sum();

can be replace by:

  list
    .ToStructEnumerable()
    .Where(x => (x & 1) == 0)
    .Select(x => x * 2)
    .Sum();

or if you want zero allocation by:

 list
   .ToStructEnumerable()
   .Where(x => (x & 1) == 0, x=>x)
   .Select(x => x * 2, x=>x)
   .Sum(x=>x);

or if you want zero allocation and better performance by:

  var where = new WherePredicate();
  var select = new SelectFunction();
  list
    .ToStructEnumerable()
    .Where(ref @where, x => x)
    .Select(ref @select, x => x, x => x)
    .Sum(x => x);

Benchmark results are:

BenchmarkDotNet=v0.12.1, OS=Windows 10.0.19042
Intel Core i7-8750H CPU 2.20GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
.NET Core SDK=5.0.101
  [Host]     : .NET Core 5.0.1 (CoreCLR 5.0.120.57516, CoreFX 5.0.120.57516), X64 RyuJIT
  DefaultJob : .NET Core 5.0.1 (CoreCLR 5.0.120.57516, CoreFX 5.0.120.57516), X64 RyuJIT

StructLinq is significatively faster than default LINQ implementation.

Duck typing with foreach is available with zero allocation for IStructEnumerable.

Following class have a StructLinq extension method for IStructEnumerable:

• IEnumerable<T>
• T[]
• List<T> (in Struct.Linq.BCL)
• Dictionary<TKey, TValue> (in Struct.Linq.BCL)
• Hashset<T> (in Struct.Linq.BCL)
• ImmutableArray<T> (in Struct.Linq.BCL)

Following converters are available for :

• ToArray
• ToList (in Struct.Linq.BCL)
• ToEnumerable

Following extensions are available for :

• Aggregate
• All
• Any
• Concat
• Contains
• Count
• Distinct(zero allocation)
• ElementAt
• ElementAtOrDefault
• Empty
• Except(zero allocation)
• First
• FirstOrDefault
• Intersect(zero allocation)
• Last
• LastOrDefault
• Max
• Min
• OrderBy(zero allocation)
• OrderByDescending
• Range
• Repeat
• Reverse(zero allocation)
• Select
• SelectMany
• Skip
• SkipWhile
• Sum
• Take
• TakeWhile
• Union(zero allocation)
• Where

• LongCount
• UIntCount
• Order
• TryFirst

    public interface IRefStructEnumerable<out T, out TEnumerator>
        where TEnumerator : struct, IRefStructEnumerator<T>
    {
        TEnumerator GetEnumerator();
    }

    public interface IRefStructEnumerator<T>
    {
        bool MoveNext();

        void Reset();

        ref T Current { get; }
    }

ref Current allows to avoid copy. I should be very useful when T is a fat struct.

Duck typing with foreach with ref is available with zero allocation for IRefStructEnumerable.

Following class have a StructLinq extension method for IRefStructEnumerable:

• T[]
• List<T> (in Struct.Linq.BCL)

Following converters are available for :

• ToArray
• ToList (in Struct.Linq.BCL)
• ToEnumerable

Following extensions are available for :

• All
• Any
• Concat
• Contains
• Count
• Distinct
• ElementAt
• ElementAtOrDefault
• Except
• First
• FirstOrDefault
• Intersect
• Last
• Select
• Skip
• SkipWhile
• Sum
• Take
• TakeWhile
• Union
• Where

• LongCount
• UIntCount
• TryFirst