C# params object[] strange behavior

by

Nice find!

Is this undefined behavior?

No. This is by-design behaviour. Weird design, but by design.

Does that depend on the .Net framework version / Mono version?

No. All versions of C# have this behaviour.

This is a consequence of the collision of some interesting rules of C#.

The first relevant rule is: a method with a params array may be called in either “normal” or “expanded” form. Normal form is as if there was no “params”. Expanded form takes the params and bundles them up into an array that is automatically generated. If both forms are applicable then normal form wins over expanded form.

Now, that perhaps seems sensible; if you have an array of objects in hand, odds are good that you want to pass the array of objects, not an array that contains an array of objects.

The second relevant rule is that C# allows unsafe array covariance when the element type is a reference type. That is, an array of strings may be converted to an array of objects implicitly. You’ll note that this has two implications. First, it means that when you have an array of objects, it might actually be an array of strings, so putting, say, a turtle into that array of objects might cause a type error. This is very surprising! You expect that every array of objects can take any object, but that is not true in C#. Some arrays of objects are lying.

The second implication is: since putting that turtle into what is really an array of strings must throw, it means that every time you put something into an array of base type, the runtime must verify that the types check. So array writes are extra expensive in C# on every write, so that the vanishingly small minority of bad writes can be caught.

This is a mess, and this is why unsafe array covariance tops my list of unfortunate C# features.

The combination of these two rules explains your observations. The array of strings is convertible to an array of objects, and therefore the method is applicable in normal form.

For the array of ints, well, covariance does not apply to value types. So the array of ints is not convertible to an array of objects, so the method is not applicable in its normal form. But an array of ints is an object, so it is applicable in expanded form.

See also:

Why does params behave like this?

Your question is arguably a duplicate of:

Is there a way to distingish myFunc(1, 2, 3) from myFunc(new int[] { 1, 2, 3 })?

More Related Contents:

  1. Why does “int[] is uint[] == true” in C#
  2. C# Cast Entire Array?
  3. Casting array to IEnumerable
  4. Difference between List and array when initiating [closed]
  5. Using C# to check if string contains a string in string array
  6. Object cannot be cast from DBNull to other types
  7. Convert json to a C# array?
  8. How do I cast int to enum in C#?
  9. How do I sort a two-dimensional (rectangular) array in C#?
  10. Default parameter for value must be a compile time constant?
  11. c# Using Parameters.AddWithValue in SqlDataAdapter
  12. How to sum up an array of integers in C#
  13. Two dimensional array slice in C#
  14. Conversion from List to array T[]
  15. finding closest value in an array
  16. Does foreach evaluate the array at every iteration?
  17. How to cast Object to its actual type?
  18. Sorting an array of folder names like Windows Explorer (Numerically and Alphabetically) – VB.NET
  19. The limitation on the size of .Net array
  20. ‘casting’ with reflection
  21. List array duplicates with count
  22. Converting an int[] to byte[] in C#
  23. C#: Dynamic runtime cast
  24. Differences between a multidimensional array “[,]” and an array of arrays “[][]” in C#?
  25. Most efficient way to append arrays in C#?
  26. Why does my C# array lose type sign information when cast to object?
  27. convert string array to string
  28. How can I safely convert a byte array into a string and back? [duplicate]
  29. Why do arrays in .net only implement IEnumerable and not IEnumerable?
  30. Is string actually an array of chars or does it just have an indexer?

Leave a Comment