using System;

class A
{
    static void Main()
    {
        Foo(1, 1);
    }

    static void Foo(long x, ulong y) { Console.WriteLine(1); }
    static void Foo(ulong? x, params long[] y) { Console.WriteLine(2); }
}

static void Foo(ulong? x, long y) { Console.WriteLine(2); }

Д>А можно ознакомиться с пунктом стандарта?

* чтобы хотя бы для одного аргумента неявное преобразование от этого аргумента к типу соответствующего параметра метода A было лучше, чем неявное преобразование от этого же аргумента к типу соответствующего параметра метода B
И
* ни для одного аргумента неявное преобразование от этого аргумента к типу соответствующего параметра метода B не было бы лучше, чем неявное преобразование от этого же аргумента к типу соответствующего параметра метода A.

* типы соответствующих параметров методов A и B были одинаковы
И
* tie-breaking rules выбирали бы метод A.

using System.Console;

module Program
{
  Main() : void
  {
    Foo(1, 1);
    _ = ReadLine();
  }

  Foo(_ : long, _ : ulong) : void { WriteLine(1) }
  Foo(_ : ulong?, params _ : array[long]) : void { WriteLine(2) }
}

VD>Как думаешь, что выведет этот код?

#pragma indent
using System.Console;

module A
  Foo[T](_x : T) : void
    WriteLine(1);

  Foo(_x : object) : void
    WriteLine(2);

  Main() : void
    Foo(1); // вызывается Foo(_x : object)
    _ = ReadKey()

#pragma indent
using System.Console;
module A
  Foo[T](x : T) : void
    WriteLine(1);
    Foo(x); // вызывается Foo(_x : object)

  Foo(_x : object) : void
    WriteLine(2);

  Main() : void
    Foo.[int](1);
    _ = ReadKey()

#pragma indent
using System;
using System.Console;

module A
  Foo[S](_x : IConvertible) : void // Вызывается этот метод
    WriteLine(1);

  Foo(params _x : array[IComparable]) : void
    WriteLine(2);

  Main() : void
    Foo(1);
    _ = ReadKey()

#pragma indent
using System;
using System.Console;

module A
  Foo[T](_ : T) : void where T : struct
    WriteLine(1);

  Foo(params _ : array[object]) : void
    WriteLine(2);

  Main() : void
    Foo(1); // Error: the type 'System.Object' must be a value type in order to use it as type parameter 'T' in method A.Foo(_N_u1710 : T.922) : void
    _ = ReadKey()

N>  Foo[T](_x : T) : void
N>  Foo(_x : object) : void
...
N>    Foo(1); // вызывается Foo(_x : object)
N>

  Foo[T](_x : T) : void
  Foo(_x : ulong) : void
...
    Foo(1); // вызывается Foo(_x : object)

using System;

static class A
{
    static void Foo(IConvertible x){}
    static void Foo(params IComparable[] x){}
    static void Main()
    {
        Foo(1); // error CS0121: The call is ambiguous between the following methods or properties: 'A.Foo(System.IConvertible)' and 'A.Foo(params System.IComparable[])'
    }
}

    GetBestOverloads (parms : list [OverloadPossibility]) : list [OverloadPossibility]
    {
      match (parms) {
        | [] | [_] => parms // если есть только одна перегрузка, то возвращаем ее и ничего не делаем.
        | _ =>
          def res = RemoveExtensionMethods (parms);      // Первым делом отбрасываем методы-расширения.
          def res = GetMinimal (res, IsBetterOverload);  // Далее выбираем "лучшую перегрузку" исходя из выведенных типов методов.

          def res = // отбрасываем params-методы (методы с переменным числом параметров) если в списке есть не params-методы.
            if (List.Exists (res, AintVarArgs)) 
              List.RevFilter (res, AintVarArgs)
            else res;
            
          def res = // повбывал бы за такие имена. В общем, что-то там отбрасывают...
            if (List.Exists (res, DidntMamboJumbo))
              List.RevFilter (res, DidntMamboJumbo)
            else res;
            
          def res = // отбрасываем джереник-методы если есть не дженерик-методы.
            if (List.Exists (res, AintGeneric))
              List.RevFilter (res, AintGeneric)
            else res;
            
          // Message.Debug ($"gbo: $parms ---> $res");

          res
      }
    }

            if (List.Exists (res, AintVarArgs)) 
              List.RevFilter (res, AintVarArgs)
            else res;