Question

我有两个对象列表

 [Serializable]
 private class MemorySet
 {
    public Dictionary<string, object> _Map;
    public List<object> _Results;
    public List<object> _Storage;
 }
 MemorySet Memory = new MemorySet();

我可以为对象分配键，例如

    _Map.Add("someKey", _Results[_Results.Count - 1]);

我有一个方法

private object Mapper(string key)
{
    if (Memory._Map.ContainsKey(key))
    {
        return Memory._Map[key];
    }
    else if (key.ToLower() == "result")
    {
        return Memory._Results[Memory._Results.Count - 1];
    }
    else if (key.ToLower() == "storage")
    {
        return Memory._Storage[Memory._Storage.Count - 1];
    }
    else if (key.ToLower().Contains("result"))
    {
        int n = Convert.ToInt32(key.ToLower().Split(new string[] { "result" }, StringSplitOptions.None)[1]);
        return Memory._Results[n];
    }
    else if (key.ToLower().Contains("storage"))
    {
        int n = Convert.ToInt32(key.ToLower().Split(new string[] { "storage" }, StringSplitOptions.None)[1]);
        return Memory._Storage[n];
    }
    else return null;
}

现在我必须从_Storage或_Results分配一个对象：

object obj = key != "" ? Mapper(key) : Memory._Storage[Memory._Storage.Count - 1];
if(obj is string) obj as string = "test";

这将改变obj以引用内存中的一些新字符串。但我想改变obj引用的对象。

换句话说，obj将成为＆＃34; test＆＃34;，但基础对象不会被更改。

我理解为什么会发生这种情况，虽然在编写整个引擎时我并没有想象它，现在我遇到了那个问题。在C ++中我们有指针，但在C＃中我不想使用GCHandles或非托管代码来处理那些微不足道的东西，会非常难看。

那么，如何分配对象指向的对象，而不是分配给对象本身？

Answer 1

试试这个

[Serializable]
    private class MemorySet
    {
        public Dictionary<string, object> _Map = new Dictionary<string,object>();
        public List<object> _Results = new List<object>();
        public List<object> _Storage = new List<object>)_;
    }

Answer 2

如果您不想弄乱当前的设计，可以添加一种方法，在与Mapper方法相同的模板上更新数据结构。这就是它的样子：

private void Update(string key, object value)
{
  if (Memory._Map.ContainsKey(key))
  {
    Memory._Map[key] = value;
  }
  else if (key.ToLower() == "result")
  {
    Memory._Results[Memory._Results.Count - 1] = value;
  }
  else if (key.ToLower() == "storage")
  {
    Memory._Storage[Memory._Storage.Count - 1] = value;
  }
  else if (key.ToLower().Contains("result"))
  {
    int n = Convert.ToInt32(key.ToLower().Split(new string[] { "result" }, StringSplitOptions.None)[1]);
    Memory._Results[n] = value;
  }
  else if (key.ToLower().Contains("storage"))
  {
    int n = Convert.ToInt32(key.ToLower().Split(new string[] { "storage" }, StringSplitOptions.None)[1]);
    Memory._Storage[n] = value;
  }
  else
  {
    throw new ArgumentException("Failed to compute valid mapping", nameof(key));
  }
}

也许你也可以在那里添加key == ""模式，我不确定如何完全使用它，但希望你能得到这个想法。

编辑：好的，因此在不同的结构中使用对同一对象的引用。您应该考虑设计一个避免这种情况的MemorySet。如果您仍然认为这是考虑到您需求的正确设计，那么您有一个简单的解决方案：将目标对象包装在其他对象中。

public class ObjectWrapper
{
  public object ObjectOfInterest { get; set; }
}

现在存储ObjectWrapper个对象。然后，您可以更新属性ObjectOfInterest，此更改将反映到包含此ObjectWrapper的所有结构中：

ObjectWrapper wrapper = Mapper(key);
wrapper.ObjectOfInterest = "test";

如何分配引用的对象

2 个答案: