//
// Warning:
//
//   -|
//   -|
//   -|===============================
//   -|
//   -|
//
class Problem
{
    static void foo(params object[] ps)
    {
        System.Console.WriteLine("got {0} parameters for great good", ps.Length);
    }

    public static void Main()
    {
        foo(null, null, null, null);
        foo(null, null, null);
        foo(null, null);
        foo(null); // HUH WHAT THE HELL
        foo();
    }
}

_FR>Ответы специалистов, кстати, в первом же результате поиска

object[] x = new object[] { "fred", "he", "is", "not", "null" };

foo(params x) // ps: x (5 параметров-строк)
foo(x) // ps: object[] { x } (один параметр-массив)

def foo(*ps):
    print(len(ps), len(ps[0]) if len(ps) > 0 else '*')

x = ["fred", "he", "is", "not", "null"]

foo(x, x, x) # 3 5
foo(x, x)    # 2 5
foo(x)       # 1 5
foo()        # 0 *

foo(*x) # 5 4

Кё>class Problem
Кё>{
Кё>    static void foo(params object[] ps)
Кё>    {
Кё>        System.Console.WriteLine("got {0} parameters for great good", ps.Length);
Кё>    }

Кё>    public static void Main()
Кё>    {
Кё>        foo(null, null, null, null);
Кё>        foo(null, null, null);
Кё>        foo(null, null);
Кё>        foo(null); // HUH WHAT THE HELL
Кё>        foo();
Кё>    }
Кё>}

object obj = null;
foo(obj); // HUH WHAT THE HELL

_FR>>Ответы специалистов, кстати, в первом же результате поиска

Кё>object[] x = new object[] { "fred", "he", "is", "not", "null" };

Кё>foo(params x) // ps: x (5 параметров-строк)
Кё>foo(x) // ps: object[] { x } (один параметр-массив)

using System.Diagnostics;

static class Program
{
  static void Main() {
    Test();
    Test(0); // Никакой не "попугай", не разводите напраслину, учите матчасть
    Test(0, 1);
    Test(0, 1, 2, 3);
    Test(null); // А вот тут очень ясно, что будет происходить
  }

  static void Test(params int[] values) {
    if(values == null) {
      Debug.Print("values == null");
    } else {
      Debug.Print("values.Length == {0}", values.Length);
    }//if
  }
}

_FR>Ну почему сразу гриль-то? Вот в режиме настройки времени кнопка таймера устанавливает время. Мне это не мешает готовить пищу.

class Problem
{
    static void foo(params object[] ps)
    {
        System.Console.WriteLine("{0} {1}", ps.Length, (ps.Length > 0 ? ps[0].GetType() : null));
    }

    static void bar<T>(T x)
    {
        foo(x); // 1 System.Object[]
    }

    public static void Main()
    {
        object[] x = new object[] { "fred", "he" };

        foo(x); // 2 System.String
        bar(x); 
    }
}

int[] arr = new int[0, 1, 2];
foo(arr);//Что ожидаете в этом случае?

int[] arr = null;
foo(arr);//А в этом случае?

void Foo(params object[] args) {
  Bar(args);
}


void Bar(params object[] args) {
  ...
}

type Foo =
     static member Bar([<System.ParamArray>] ps : obj array) =
            printfn "got %d parameters for great good" ps.Length

Foo.Bar(null, null, null, null)
Foo.Bar(null, null, null)
Foo.Bar(null, null)
Foo.Bar(null) (* аналогично *)
Foo.Bar()

Кё>//
Кё>// Warning:
Кё>

using System;
using System.Collections.Generic;

class Problem
{
    static void Main()
    {
        var x = new[] { new List<string>(), new List<string>() };

        Bar1(x);
        Bar2(x);
    }

    static void Bar1<T>(T[] x) where T : IList<string> 
    {
        Foo(x);
    }

    static void Bar2<T>(T[] x) where T : List<string>  
    {
        Foo(x);
    }

    static void Foo(params object[] x)
    {
        Console.WriteLine(x.Length);
    }
}

open System
open System.Collections.Generic

type Problem =
     static member Bar1(x: #IList<string>[]) = Problem.Foo(x)
     static member Bar2(x:  #List<string>[]) = Problem.Foo(x)
     static member Foo([<ParamArray>] x: obj[]) = printfn "%d" x.Length

let xs : List<string>[] = [| |]

Problem.Bar1(xs) // 1
Problem.Bar2(xs) // 1