Question

我有两种类型：

    public class Type1
    {
        public string Name { get; set; }
    }

    public class Type2
    {
        public string Name { get; set; }
    }

我有一个元素列表（每个元素都是一个对象类型）。一些元素可以是一个数组。（数组可以是type1 []或type2 []）

我的目标是：
在我的元素列表上重复1次 2 - 确定哪个是type1 [] array pr type2 [] array
3 - 获取前一个数组的元素的Name值属性

这就是我所做的：

    foreach (var Myobject in MyList)
    {
        if (myObject.GetType().IsArray)
        {
            var elementType = myObject.GetType().GetElementType()// should me return the element type, ie Type1 or Type2

            //This is where I am stuck, I know that my object is an array but I cannot cast if in type1[] or type2[] array by using elementType
            //The following is not working
            elementType[] myArrat = (elementType[])myObject;

            // And I don't want to hardwrite each case for each possible type like this :
            Type1[] myArrat = (Type1[])myObject;
            Type2[] myArrat = (Type2[])myObject;
            // I want to use the elementType that I got previously

        }
    }

提前感谢您的帮助。

Answer 1

你无法做你想做的事。坦率地说，你可能也不需要这样做。如果您期望不同类型，则意味着您将针对每种类型执行不同的操作。您可以做的是更改Type1和Type2以扩展相同的基类并改为使用基类：

public class TypeBase 
{
   public virtual string Name { get; set; }
}

public class Type1 : TypeBase
{
}

public class Type2 : TypeBase
{
}


foreach (var myobject in MyList)
{
    if (myObject.GetType().IsArray)
    {
        object[] array = (object[]) myObject;
        TypeBase[] yourArray = array.Cast<TypeBase>();
        //use the properties and methods of TypeBase instead of Type1 and Type2
        //mark the methods and properties in TypeBase as virtual and
        //override them on Type1 and Type2 if needed
    }
}

Answer 2

elementType [] myArrat =（elementType []）myObje

elementTypr不是类型名称，因此无法编译。但是这里几乎没有其他问题。首先，您可能希望将MyList元素循环到 flat 数组项：

private static IEnumerable<object> Flat(IEnumerable<object> items)
{
    foreach (var item in items)
    {
        var array = item as Array;
        if (array != null)
        {
            foreach (var arrayItem in array)
                yield return arrayItem;
        }
        else
            yield return item;
    }
}

现在，您可以通过列表进行枚举，而无需担心某些项目是否为数组：

foreach (var item in Flat(Mylist))
{
}

你应该做的是添加一个接口（或抽象基类）来抽象具体类型：

interface INamedObject
{
    string Name { get; set; }
}

class Type1 : INamedObject { ... }
class Type2 : INamedObject { ... }

现在，您可以使用INamedObject返回类型中的Flat()替换对象（不要忘记为yield return添加强制转换）。然后你会像这样使用它：

foreach (var item in Flat(Mylist))
{
    item.Name = ""; // It doesn't matter if it's Type1 or Type2!
}

请注意，如果您不想（!!!）添加基类/接口，那么您仍然可以执行类型检查。这是一个非常糟糕的做法，你应该考虑改变你的设计以避免这种情况。我建议的是 - 至少 - 不要使用GetType()而是直接as投射操作员。

将动态对象转换为c＃中的动态类型数组

2 个答案: