C#：将特定 Enum 类型的数组作为 params object[] 参数传递

Question

When attempting to pass in an array of a specific enum type as a function argument via params object[], I am unable to pass in an actual array without casting to object[] first. But if I do so I do not have access to the original enum type.

Given the enum and function shown below, this works fine:

var works = SomeFunction(Season.Fall, Season.Winter);

However, this fails because it cannot implicitly convert to object, so it passes array as first argument as opposed to individual arguments:

var seasons = new Season[] {Season.Fall, Season.Winter};
var fail = SomeFunction(seasons);

It also cannot cast to object[] because then later it is unable to determine the original type. How can I use a predetermined array to pass it in?

[Flags]
public enum Season : byte
{
    None = 0,
    Spring = 1,
    Summer = 2,
    Fall = 4,
    Winter = 8
}

...

public Something SomeFunction(params object[] values) 
{
     ...
     foreach (var value in values)
     {
          var type = value.GetType();
          ...
     }
}

UPDATE: it works to convert the Season[] array to object[], but that seems hokey:

var seasons = new object[original.Length];
for (int i = 0; i < original.Length; i++)
{
       seasons[i] = original[i];
}

Answer 1

It's as simple as converting an object[] containing the enums as opposed to casting the array:

var original = new Season[] {Season.Fall, Season.Winter};

var selectedSeasons = new object[original.Length];
for (int i = 0; i < original.Length; i++)
{
       selectedSeasons[i] = original[i];
}

var works = SomeFunctionWithObjectParamsArgs(selectedSeasons);

Yes, ultimately changing the function signature to be generic would be best, but doesn't apply in my case (third-party API).

Answer 2

This code compiles in .NET 3.5, 4.0, and 4.5. Are you getting a compiler error when you build?

class Program
{
    static void Main(string[] args)
    {
        var p = new Program();
        p.SampleFunc(Seasons.Winter, Seasons.Fall);
    }

    void SampleFunc(params object[] elements)
    {
        foreach(var element in elements)
        {
            if (element is Seasons)
            {
                // do something.
            }
        }
    }

    enum Seasons
    {
        Winter, Spring, Summer, Fall
    }
}

Answer 3

I think this does it...

public enum MyEnum
{
    EnumValue1,
    EnumValue2,
    EnumValue3
}

class Program
{
    static void Main(string[] args)
    {
        var TheEnumList =(from list in Enum.GetValues(typeof (MyEnum)).Cast<int()
                          select new {EnumValueInstance = (MyEnum) list})
                         .ToList();
        TheEnumList.ForEach(enumItem => Console.WriteLine(enumItem.EnumValueInstance));
        var result = SomeFunction(TheEnumList);
        Console.WriteLine(result);
        Console.ReadKey();
    }

    public static MyEnum SomeFunction(params object[] values)
    {
        dynamic obj = values[0];
        return obj[0].EnumValueInstance;
    }
}

Answer 4

Consider using the Cast<>() LINQ Method instead of a for loop, this looks cleaner:

var seasons = SomeFunction(seasons.Cast<object>().ToArray());

There's no other way you can cast an array of value types to an array of objects , you can't leverage array covariance in this case because it only works between arrays of compatible reference types.