Question

我创建了一个包含不同类型元素的对象数组：

public static int a;
public static string b;
public static ushort c;

object[] myobj = new obj[]{ a, b, c};

如果我想创建一个包含myobj类型数组元素的数组，我该怎么做？

我的意思是这样的：

myobj[] myarray = new myobj[];  <= but to do this, myobj should be a type.

不确定如何解决。

谢谢大家。

Answer 1

创建一个包含所需类型的类型，然后创建一个数组。

public class MyType // can be a struct. Depends on usage.
{
  // should really use properties, I know, 
  // and these should probably not be static
  public static int a;
  public static string b;
  public static ushort c;
}

// elsewhere
MyType[] myobj = new MyType[]{};

不确定为什么你会想要跳过object[]的箍，并且不得不在整个地方投掷。

Answer 2

我们如何使用Dictionary存储您需要的任何类型？

所以，虽然你不会完全拥有myType.a，但你可以拥有足够接近的myType.Values["a"]，使用标准的C＃构造，并为你提供很多灵活性/可维护性

public class MyType
{
    public MyType()
    {
        this.Values = new Dictionary<object, object>();
    }

    public Dictionary<object, object> Values
    {
        get;
        set;
    }
}

样本用法：

using System;
using System.Collections.Generic;

public static class Program
{
    [STAThread]
    private static void Main()
    {
        var myTypes = new MyType[3];

        myTypes[0] = new MyType();
        myTypes[1] = new MyType();
        myTypes[2] = new MyType();

        for (var current = 0; current < myTypes.Length; ++current)
        {
            // here you customize what goes where
            myTypes[current].Values.Add("a", current);
            myTypes[current].Values.Add("b", "myBvalue");
            myTypes[current].Values.Add("c", (ushort)current);
        }

        foreach (var current in myTypes)
        {
            Console.WriteLine(
               string.Format("A={0}, B={1}, C={2}", 
                              current.Values["a"], 
                              current.Values["b"],
                              current.Values["c"]));
        }

 }

另外，如果需要，您可以轻松地向您的类添加indexer属性，以便您可以使用语法myType["a"]访问元素。请注意，在添加或检索值时应添加错误检查。

public object this[object index]
{
    get
    {
        return this.Values[index];
    }

    set
    {                    
        this.Values[index] = value;
    }
}

这是使用索引器的示例。通过＆＃39; 1＆＃39;增加条目所以我们看到了ouptut的不同之处：

for (var current = 0; current < myTypes.Length; ++current)
{
    myTypes[current]["a"] = current + 1;
    myTypes[current]["b"] = "myBvalue2";
    myTypes[current]["c"] = (ushort)(current + 1);
}

foreach (var current in myTypes)
{
    Console.WriteLine(string.Format("A={0}, B={1}, C={2}", 
                                    current["a"], 
                                    current["b"], 
                                    current["c"]));
}

Answer 3

我做了一些改变，但我认为这符合你想做的精神。

由于属性是数组元素的唯一区别特征，因此“静态”没有意义，所以我删除了它。

如果按如下方式定义类：

    public class MyType
    {
        /// <summary>
        /// Need a constructor since we're using properties
        /// </summary>
        public MyType()
        {
            this.A = new int();
            this.B = string.Empty;
            this.C = new ushort();
        }

        public int A
        {
            get;
            set;
        }

        public string B
        {
            get;
            set;
        }

        public ushort C
        {
            get;
            set;
        }
    }

您可以像这样使用它：

using System;

public static class Program
{
    [STAThread]
    private static void Main()
    {
        var myType = new MyType[3];

        myType[0] = new MyType();
        myType[1] = new MyType();
        myType[2] = new MyType();

        for (var i = 0; i < myType.Length; ++i)
        {
            myType[i].A = 0;
            myType[i].B = "1";
            myType[i].C = 2;
        }

        // alternatively, use foreach
        foreach (var item in myType)
        {
            item.A = 0;
            item.B = "1";
            item.C = 2;
        }
    }
}

如何在C＃中创建自定义类型数组？

3 个答案: