static void Do(ImmutableArray<int> x)
        {
            if (x.Length == 0)
                return;

            // ...
        }

        static void Do(ImmutableArray<int> x)
        {
            if (x.Length == 0)
                return;

            // ...
        }
        static void Do(ICollection<int> x)
        {
            if (x.Count == 0)
                return;

            // ...
        }

internal void ThrowNullRefIfNotInitialized()
{
    int num = this.array.Length;
}

S>>Наоборот же Документация (см Remarks) не заморачивается такими мелочами.

ImmutableArray<T>.IsEmpty
Gets a value indicating whether this ImmutableArray<T> is empty.

ImmutableArray<T>.Length

Gets the number of elements in the array.

using System;
using System.Collections.Generic;

#IF COMPILE_ME_IF_U_CAN
using System.Collections.Immutable;
#ENDIF

DO ensure that a state where all instance data is set to zero, false, or null (as appropriate) is valid.
This prevents accidental creation of invalid instances when an array of the structs is created. For example, the following struct is incorrectly designed. The parameterized constructor is meant to ensure a valid state, but the constructor is not executed when an array of the struct is created and so the instance field value gets initialized to 0, which is not a valid value for this type.

void MyAlgorithm<T>(T collection) where T : IEnumerable<T>
{...}

void MyAlgorithm<T>(T collection) where T : IQueryable<T>
{...}

void MyAlgorithm<T>(IEnumerable<T> collection)  
{...}

void MyAlgorithm<T>(IQueryable<T> collection) 
{...}

class SmartPtr {
...
  public static implicit operator Box<SmartPtr>(SmartPtr value) {
    if(value.IsEmpty)
      return null;

    return new Box<SmartPtr>(this);
  }
}

S>Ну, т.е. одного типа с неотлавливаемым исключением в произвольный момент времени мало, да?

S>Матчасть читать надо

struct ImmutableArray<T> {
  public SmartPointer() {
    _array = Array.Empty<T>();  
  }

private:
  T[] _array;
}

struct NotNull<T> where T : class {
  public NotNull(T obj) {
    if(obj == null) throw ...;
    _obj = obj;
  }

  NotNull() = delete;    // или объявлен в приватной секции

private:
  T _obj;
}

using MyTypeRef = NotNull<MyType>;

var defaultValue = new MyTypeRef(MyType::DummyObj);
MyTypeRef[] values = new MyTypeRef[42](defaultValue);

Это из-за отсутствия практики оперирования умными указателями.
Их точно так же надо проверять на null, как и обычные, т.е. такие типы надо рассматривать как ссылочные.

S>Могу и буду Аргументацию давай.

Собсно, вообще таких алгоритмов мало, которые можно выразить в дотнете для value и ref-типов в генериках и они будут корректно работать в обоих случаях. Я одно время на этом собаку съел, в поисках классов таких алгоритмов, которые, таки, работают в обоих случаях и в попытках сформулировать ограничения на такие алгоритмы.

S>С другой — народ, который матчасть не изучал, проблем до конца не видит, но хочет, чтоб усё было

А вот за это руки поотрывать и отлучать от программирования на веки вечные (ValueOption[T]):

public GetValueOrDefault() : T { _value }

Ты что творишь-то?
Это же одна из бед дотнета как такового, что некое "дефолтное значение" некоей прикладной структуры может являться не валидным значением, т.е. источником ошибок.

Тебе же специально дали иммутабельный по-умолчанию Nemerle, чтобы ты эффективно боролся именно с подобного рода проблемами — не создавал неинициализированных значений. И тут ты такой — а нате вам протаскивание проблемы прямо в вашу иммутабельность.

S>Именно это команда .net core и делает. Точнее, делала, а затем мегаавральными темпами последний год исправляла. Не получилось игнорить почему-то

S>В смысле, +300% end-to-end throughput за счёт избавления от виртуальных вызовов? Я таки хочу на это посмотреть. Кинь ссылочку, плиз

V>>Вот что бывает, когда средней руки инженер превращается в маньяка-карьериста.

    struct ImmutableArray<T>
    {
        internal T[] _array;

        public bool IsEmpty
        {
            get { return _array == null; }
        }

        public ImmutableArray(T[] a)
        {
            _array = a;
        }
    }

    static class ImmutableArrayExtentions
    {
        private static void CheckNotNull<T>(ImmutableArray<T> ar) 
        {
            if (ar.IsEmpty)
                throw new NullReferenceException();
        }

        public static ImmutableArray<T> ToImmutable<T>(this T[] ar)
        {
            return new ImmutableArray<T>(ar);
        }

        public static int Sum(this ImmutableArray<int> source)
        {
            CheckNotNull(source);
            return Enumerable.Sum(source._array);
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            var ar = new int[] { 1, 2, 3 };
            var imm = ar.ToImmutable();
            var s = imm.Sum();  // ok
            int[] nar = null;
            var nimm = nar.ToImmutable();
            var ns = nimm.Sum();  // exception thrown
        }
    }

не сохраняет в поля пустой immutable array

            Method |          Mean |     StdDev | Scaled | Scaled-StdDev |
------------------ |-------------- |----------- |------- |-------------- |
    TestRefWrapper |   963.0174 ns | 35.6947 ns |   1.00 |          0.00 |
 TestStructWrapper |   870.5784 ns | 12.3793 ns |   0.91 |          0.03 |
          TestList | 1,210.3565 ns | 26.7783 ns |   1.26 |          0.05 |
     TestListReset | 1,228.1166 ns | 51.7045 ns |   1.28 |          0.07 |
         TestArray |   875.6539 ns | 14.3256 ns |   0.91 |          0.03 |

using System;
using System.Collections.Generic;
using System.Linq;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

namespace PerfTestApp
{
    class Program
    {
        static void Main(string[] args)
        {
            if (IntPtr.Size !=8)
                throw new InvalidOperationException("As x64");
            new MemberAccessBenchmark().Run();
        }
    }

    public class MemberAccessBenchmark
    {
        private class RefWrapper
        {
            private int[] _data;

            public RefWrapper(int[] data)
            {
                _data = data;
            }

            public int this[int index] => _data[index];

            public int Length => _data.Length;
        }

        private struct StructWrapper
        {
            private int[] _data;

            public StructWrapper(int[] data)
            {
                _data = data;
            }

            public int this[int index] => _data[index];
            public int Length => _data.Length;
        }

        private RefWrapper _ref = new RefWrapper(Enumerable.Range(1, 1000).ToArray());
        private StructWrapper _val = new StructWrapper(Enumerable.Range(1, 1000).ToArray());
        private List<int> _list = new List<int>(Enumerable.Range(1, 1000).ToArray());
        private List<int> _listReset = new List<int>(Enumerable.Range(1, 1000).ToArray());
        private int[] _array = Enumerable.Range(1, 1000).ToArray();

        public void Run() => BenchmarkRunner.Run(GetType());

        [Setup]
        public void Setup()
        {
            _listReset.Clear();
            _listReset.AddRange(_array);
        }

        [Benchmark(Baseline = true)]
        public long TestRefWrapper()
        {
            var local = _ref;
            var result = 0L;
            for (int i = 0; i < local.Length; i++)
                result += local[i];
            return result;
        }

        [Benchmark]
        public long TestStructWrapper()
        {
            var local = _val;
            var result = 0L;
            for (int i = 0; i < local.Length; i++)
                result += local[i];
            return result;
        }

        [Benchmark]
        public long TestList()
        {
            var local = _list;
            var result = 0L;
            for (int i = 0; i < local.Count; i++)
                result += local[i];
            return result;
        }

        [Benchmark]
        public long TestListReset()
        {
            var local = _listReset;
            var result = 0L;
            for (int i = 0; i < local.Count; i++)
                result += local[i];
            return result;
        }

        [Benchmark]
        public long TestArray()
        {
            var local = _array;
            var result = 0L;
            for (int i = 0; i < local.Length; i++)
                result += local[i];
            return result;
        }
    }
}

        /// <summary>
        /// Gets the number of elements in the array.
        /// </summary>
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        public int Length
        {
            [NonVersionable]
            get
            {
                // We intentionally do not check this.array != null, and throw NullReferenceException
                // if this is called while uninitialized.
                // The reason for this is perf.
                // Length and the indexer must be absolutely trivially implemented for the JIT optimization
                // of removing array bounds checking to work.
                return this.array.Length;
            }
        }

        /// <summary>
        /// Throws a null reference exception if the array field is null.
        /// </summary>
        internal void ThrowNullRefIfNotInitialized()
        {
            // Force NullReferenceException if array is null by touching its Length.
            // This way of checking has a nice property of requiring very little code
            // and not having any conditions/branches.
            // In a faulting scenario we are relying on hardware to generate the fault.
            // And in the non-faulting scenario (most common) the check is virtually free since
            // if we are going to do anything with the array, we will need Length anyways
            // so touching it, and potentially causing a cache miss, is not going to be an
            // extra expense.
            var unused = this.array.Length;
        }

        /// <summary>
        /// Throws an <see cref="InvalidOperationException"/> if the <see cref="array"/> field is null, i.e. the
        /// <see cref="IsDefault"/> property returns true.  The
        /// <see cref="InvalidOperationException"/> message specifies that the operation cannot be performed
        /// on a default instance of <see cref="ImmutableArray{T}"/>.
        ///
        /// This is intended for explicitly implemented interface method and property implementations.
        /// </summary>
        private void ThrowInvalidOperationIfNotInitialized()
        {
            if (this.IsDefault)
            {
                throw new InvalidOperationException(SR.InvalidOperationOnDefaultArray);
            }
        }

string str = GetSomeString();

foreach(char c in str) ...

int sum(IEnumarable<int> collection) {...}
double sum(IEnumarable<double> collection) {...}

int sum<T>(T collection) where T : IEnumerable<int> {...}
double sum<T>(T collection) where T : IEnumerable<double> {...}

        static int Sum<TColl, TEnumerator>(TColl coll)
            where TColl : IMyEnumerable<TEnumerator>
            where TEnumerator : IEnumerator<int>
        {
            int result = 0;
            foreach(int v in coll)
            {
                result += v;
            }

            return result;
        }

        interface IMyEnumerable<out TEnumerator>
        {
            TEnumerator GetEnumerator();
        }

Гадлайнам надо не только следовать, их надо активно разрабатывать в процессе своей деятельности. Собсно, они сами должны оседать как "побочный эффект вычислений".

S>В чём разница между RefWrapper и Lizt<T> — посмотри сам. Сам напросился — нефиг рассказывать про перфоманс с позиции "мне _кажется_, что причина в косвенных вызовах"

            Method |          Mean |    StdDev | Scaled | Scaled-StdDev |
------------------ |-------------- |---------- |------- |-------------- |
    TestRefWrapper | 2,345.5918 us | 7.4546 us |   1.00 |          0.00 |
 TestStructWrapper |   961.5590 us | 6.0217 us |   0.41 |          0.00 |
          TestList | 1,499.5782 us | 4.4925 us |   0.64 |          0.00 |
     TestListReset | 1,497.4722 us | 4.1352 us |   0.64 |          0.00 |
         TestArray |   960.5809 us | 2.4241 us |   0.41 |          0.00 |

            Method |          Mean |    StdDev | Scaled | Scaled-StdDev |
------------------ |-------------- |---------- |------- |-------------- |
    TestRefWrapper |   816.8624 us | 3.9044 us |   1.00 |          0.00 |
 TestStructWrapper |   774.8507 us | 1.6223 us |   0.95 |          0.00 |
          TestList |   996.5568 us | 3.0444 us |   1.22 |          0.01 |
     TestListReset | 1,005.6156 us | 4.9246 us |   1.23 |          0.01 |
         TestArray |   775.9587 us | 3.2324 us |   0.95 |          0.01 |

public long TestRefWrapper()
...
            var result = 0L;
00007FFCF26D06C0  sub         rsp,28h  
00007FFCF26D06C4  xor         eax,eax  
            var local = _ref;
00007FFCF26D06C6  mov         rdx,24E100059A0h  
00007FFCF26D06D0  mov         rdx,qword ptr [rdx]  
            for (int i = 0, e = local.Length; i < e; i++)
00007FFCF26D06D3  xor         ecx,ecx  
00007FFCF26D06D5  mov         rdx,qword ptr [rdx+8]  
00007FFCF26D06D9  mov         r8d,dword ptr [rdx+8]  
00007FFCF26D06DD  mov         r9d,r8d  
00007FFCF26D06E0  test        r9d,r9d  
00007FFCF26D06E3  jle         00007FFCF26D0702  
00007FFCF26D06E5  mov         r10,rdx  
00007FFCF26D06E8  cmp         ecx,r8d  
00007FFCF26D06EB  jae         00007FFCF26D0707  
00007FFCF26D06ED  movsxd      r11,ecx  
00007FFCF26D06F0  mov         r10d,dword ptr [r10+r11*4+10h]  
00007FFCF26D06F5  movsxd      r10,r10d  
00007FFCF26D06F8  add         rax,r10  
00007FFCF26D06FB  inc         ecx  
00007FFCF26D06FD  cmp         ecx,r9d  
00007FFCF26D0700  jl          00007FFCF26D06E5

mov rdx,24E100059A0h      // взяли адрес статического объекта - ссылки _ref
mov rdx,qword ptr [rdx]   // загрузили значение по ссылке - это адрес объекта RefWrapper.
mov rdx,qword ptr [rdx+8] // сразу же прочитали первое поле объекта и запомнили его в rdx

interface IObjectProxy {
    bool IsEmpty { get; }
}

interface IEnumerableProxy<T> : IObjectProxy
{
   IEnumerable<T> ToEnumerable();
   IEnumerator<T> GetEnumerator();
}

interface ICollectionProxy<T> : IEnumerableProxy<T>
{
   ICollection<T> ToCollection();
}

interface IListProxy<T> : ICollectionProxy<T>
{
   ICollection<T> ToCollection();
}

    private static void CheckNotNull<T>(ref T proxy) where T : IObjectProxy 
    {
        if (proxy.IsEmpty)
            throw new NullReferenceException();
    }

    public static int Sum(this T source) where T : IEnumerableProxy<int>
    {
        CheckNotNull(source);
        return Enumerable.Sum(source.ToEnumerable(););
    }

Ну и помним, что методы-хелперы для синтаксиса foreach кушатьинтерфейсов не просят.
Ву а ля или еще нет?

            Method |          Mean |    StdDev | Scaled | Scaled-StdDev |
------------------ |-------------- |---------- |------- |-------------- |
    TestRefWrapper | 2,345.5918 us | 7.4546 us |   1.00 |          0.00 |
 TestStructWrapper |   961.5590 us | 6.0217 us |   0.41 |          0.00 |

internal static class Foo<TElement>
{
    internal static TElement Sum<TEnumerable, TMonoid>(TEnumerable items, TMonoid monoid)
        where TEnumerable : IEnumerable<TElement>
        where TMonoid : IMonoid<TElement>
    {
        // При сравнении объекта value-типа с литералом `null`
        // не будет боксинга в рантайме согласно C# Specification, section 7.10.6.

        if (items == null)
            throw new ArgumentNullException(nameof(items));

        if (monoid == null)
            throw new ArgumentNullException(nameof(monoid));

        TElement result = monoid.Identity;
        foreach (var item in items)
            result = monoid.Combine(result, item);

        return result;
    }
}

int Sum<T>(T coll) where T : IEnumerable<int>

int Sum(IEnumerable<int>)

public static ref int Find3(int[,] matrix, Func<int, bool> predicate)
{
    for (int i = 0; i < matrix.GetLength(0); i++)
        for (int j = 0; j < matrix.GetLength(1); j++)
            if (predicate(matrix[i, j]))
                return ref matrix[i, j];
    throw new InvalidOperationException("Not found");
}

var valItem = MatrixSearch.Find3(matrix, (val) => val == 42);
Console.WriteLine(valItem);
valItem = 24;
Console.WriteLine(matrix[4, 2]);

S>int Sum<T>(T coll) where T : IEnumerable<int>
S>

S>int Sum(IEnumerable<int>)
S>

interface IAdd
{
    void Add(int val);
}

struct Foo : IAdd
{
    public int value;

    void IAdd.Add(int val)
    {
        value += val;
    }

    public void AddValue(int val)
    {
        value += val;
    }

    public void Print(string msg)
    {
        Console.WriteLine(msg + ":" + value);
    }
}

 static void Add_WithConstraints<T>(ref T foo, int val) where T : IAdd
    {
        foo.Add(val);
    }

    Add_WithConstraints<Foo>(ref f, 10);
    f.Print("After Add_WithConstraints");

Perhaps it isn’t entirely obvious to everyone — foo.Add(val) is an interface call using callvirt instruction: callvirt instance void IAdd::Add(int32), because that’s the only way compiler knows how to make the call.
The interesting part is, when we call Add_WithConstraints, the call happens exactly in the same manner, except the code we are calling into looks drastically different:
0:000> !u 00007ff8`cfa707d0
Normal JIT generated code

Program.Add_WithConstraints[[Foo, value]](Foo ByRef, Int32)
Begin 00007ff8cfa707d0, size 3a
>>> push    rbp
sub     rsp,20h
lea     rbp,[rsp+20h]
mov     qword ptr [rbp+10h],rcx           ; this pointer
mov     dword ptr [rbp+18h],edx           ; val
mov rax,7FF8CF964560h                     ; debugger gibberish 
                                          ; but you probably guessed it's for Just My Code
cmp     dword ptr [rax],0
je      00007ff8`cfa707f5
call    clr!JIT_DbgIsJustMyCode (00007ff9`2f534eb0)
nop
mov     rcx,qword ptr [rbp+10h]                  ; this pointer
mov     edx,dword ptr [rbp+18h]                  ; val
call    00007ff8`cfa706c0 (Foo.IAdd.Add(Int32)   ; calls the method without boxing!
nop
nop
lea     rsp,[rbp]
pop     rbp
ret

As you can see, the code is surprisingly simple. No boxing, no interface cast, and a direct call to Foo.IAdd.Add method. No value is lost. And you can observe the side effect:
After Add_WithConstraints:30
The reason is compiler now has enough information to figure out the code is for Foo and the interface call will land exactly on Foo.IAdd.Add, so it skips the formality and calls the function directly. This is both a performance optimization but also comes with observable side-effect.
Conclusion
When you are working with interface on value types, be aware of the potential performance cost of boxing and correctness problem of not observing changes in the callee. If you’d like to avoid that, you can use generic constraints to constraint the interface call so that compiler can optimize out the boxing and interface call altogether and go straight to the right function.
You can find the full code in this gist.

interface IAdd
{
    void Add(int val);
}

Причина в том, что компилятор теперь имеет достаточно информации, чтобы понять, что код для Foo, и вызов интерфейса попадет именно на Foo.IAdd.Add , поэтому он пропускает формальность и вызывает функцию напрямую. Это как оптимизация производительности, но также с заметным побочным эффектом.

using System;
interface ICounter
{
    void Increment();
}
struct Counter: ICounter
{
    int value;
    public override string ToString() {
        return value.ToString();
    }
    void ICounter.Increment() {
        value++;
    }
}
class Program
{
    static void Test<T>() where T: ICounter, new() {
        T x = new T();
        Console.WriteLine(x);
        x.Increment();                        // Modify x
        Console.WriteLine(x);
        ((ICounter)x).Increment();        // Modify boxed copy of x
        Console.WriteLine(x);
    }
    static void Main() {
        Test<Counter>();
    }
}