0

我有 2 个数组smallArray，bigArray例如

 void myFun(TypeA a, TypeA b, TypeA c, TypeA d)
 {
      TypeA[] smallArray = new TypeA[]{a,b,c,d}
      TypeA[] bigArray = new TypeA[]{a,b,a,b,c,c,c,d,d,a,c,b,d,a,d,...}
 }

bigArray仅包含来自的成员smallArray。现在我想交换 中的所有对象bigArray，但要保持结构顺序，并尽量减少操作次数。

例如，我的理想结果将是{aa,bb,aa,bb,cc,cc,cc,dd,dd,aa,cc,bb,dd,aa,dd,...}……aa的新对象TypeA

所以我将我的代码重新设计成这样：

class TypeB
{
    public TypeA Value {get; set;}
}

void myFun(TypeB a2, TypeB b2, TypeB c2, TypeB d2) // where a2.Value = a, b2.Value = b...
{
    TypeB[] smallArray = new TypeB[]{a2,b2,c2,d2}
    TypeB[] bigArray = new TypeB[]{a2,b2,a2,b2,c2,c2,c2,d2,d2,a2,c2,b2,d2,a2,d2,...}
}

我将目标对象“装箱”到包装器中，并将包装的对象存储在数组中。现在，当我更新 中的对象值时，会同时更新 中smallArray的成员值。bigArray

这种技术常用吗？还是有其他方法可以简化它？

更新

现在TypeA变成string这样你至少可以理解这个问题。

我有 2 个数组smallArray，bigArray例如

string[] smallArray = new string[] {"a","b","c","d"}
string[] bigArray = new string[] {"a","b","a","b","c","c","c","d","d","a","c","b","d","a","d",...}

bigArray仅包含来自的成员smallArray。现在我想交换 中的所有对象bigArray，但要保持结构顺序，并尽量减少操作次数。

例如，我理想中的新 bigArry 会变成{"aa","bb","aa","bb","cc","cc","cc","dd","dd","aa","cc","bb","dd","aa","dd",...}

所以我将我的代码重新设计成这样：

class TypeB
{
    public string Value {get; set;}
}

void myFun(TypeB a2, TypeB b2, TypeB c2, TypeB d2) // where a2.Value = "a", b2.Value = "b"...
{
    TypeB[] smallArray = new TypeB[]{a2,b2,c2,d2}
    TypeB[] bigArray = new TypeB[]{a2,b2,a2,b2,c2,c2,c2,d2,d2,a2,c2,b2,d2,a2,d2,...}
}

我将其“装箱”string到包装器中，并将包装的对象存储在数组中。现在，当我更新 中的对象值时，会同时更新 中smallArray的成员值。bigArray

所以在示例中我只需要更新 4 个对象而不是整个bigArray.

这种技术常用吗？还是有其他方法可以简化它？

4

3 回答 3

2

基本上，答案是“是的，你可以做到”。一种更简单的方法可能是让 bigArray 为 int 类型，并将索引存储到 smallArray 中：

TypeB[] smallArray = new TypeB[] { a2, b2, c2, d2 };
int[] bigArray = new int[] { 0, 1, 0, 1, 2, 2, 2, 2, 3, 3, 0, 2, 1, 3, 1, 3 };

这样，bigArray 的级别间接保持不变，但 smallArray 没有任何间接。此外，这强制 bigArray 不包含任何不在 smallArray 中的元素（超出范围的索引除外）。

为了能够说更多，您应该向我们提供更详细的用例描述。您的应用程序对性能至关重要吗？记忆约束怎么样？

于 2012-10-04T11:33:18.433 回答
1

是的。每个列表或数组都存储指针。当您将这些指针指向一个众所周知的位置时，即内存中保留对象的属性，无论它是作为单例维护，还是在数组或静态变量中，您都可以在一个中心的地方。如果没有合适的例子，这不是一种常用的做法，但我可以想象有合适的情况可以做到这一点。

于 2012-10-04T11:32:45.610 回答
0

如果我声明一个引用类型，

 class SomeClass
 {
 }

然后实例化一个变量给它，

 var someInstance = new SomeClass()

然后像这样声明另一个变量，

 var someInstance2 = someInstance

内存中只有一个实例，SomeClass但我有两个变量someInstance，并且someInstance2该引用或指向该SomeClass实例。

所以，如果我声明两个新实例SomeClass，请注意new关键字，

var a = new SomeClass();
var b = new SomeClass();

然后使用它们初始化两个新数组

var smallArray = new SomeClass[] { a, b }
var bigArray = new SomeClass[] { a, b, a, a, b, b, b, a }

我只实例化了两个新的SomeClass. 我制作了两个新数组，其中包含十个引用或指针的总和，但没有额外的SomeClass引用。

唯一一次创建引用类型的新实例是在使用new关键字时（有一些无关紧要的例外。）这有帮助吗？

因此，如果我想将数组的所有成员替换为其他成员，我可以编写这样的函数，

public static class ArrayExtension
{
    void Substitute<T>(this T[] array, IDictionary<T, T> subsitute)
    {
         for (var i = 0; i < array.Length; i++)
         {
              if (substitute.ContainsKey(array[i])
              {
                  array[i] = substitute[array[i]];   
              }
         }
    } 
}

我可以这样称呼，

var substitutes = new Dictionary
    {
        { Key = a, Value = aa },
        { Key = b, Value = bb },
        { Key = c, Value = cc },
        { Key = d, Value = dd }
    }

bigArray.Substitute(substitutes);
于 2012-10-04T11:31:08.260 回答