16

在这个问题中，我想知道这是否以及如何实现。这种技术似乎是非常糟糕的做法，但我正在使用的 API（UnityEditor）似乎正在做这样的事情，我只是好奇。

如果对同一个对象有多个引用，是否可以将一个新对象实例化到同一个内存槽中，以便所有以前的引用都指向新对象？

我发现唯一可行的方法是使用非托管 C++。基本上发生了以下情况：

// Original prefab
GameObject prefab = x;
prefab.tag = "Untagged";

// A copy of the original prefab
GameObject prefabCopy = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
prefabCopy.tag = "EditorOnly";  // Change from initial value "Untagged"

Debug.Log(prefab.tag);     // "Untagged"   - expected
Debug.Log(prefabCopy.tag); // "EditorOnly" - expected

// Replace contents of prefab file with `prefabCopy`
PrefabUtility.ReplacePrefab(prefabCopy, prefab);

// Destroy the copy
DestroyImmediate(prefabCopy);

Debug.Log(prefab.tag);     // "EditorOnly"   - whoa?

一些prefab现在如何指向不同的对象？

注意：请记住，Unity 是在 Mono 风格的 .NET 之上构建的

4

4 回答 4

8

如果您将对象嵌入到另一个用于访问该对象的对象中，则可以这样做。

class ObjectReference<T>
   where T : new()
{
    private T _obj = new T();

    public void CreateNewObject()
    {
        _obj = new T();
    }

    public T Value { get return _obj; }
}

现在您可以创建对类型对象的多个引用，ObjectReference并且只更改本地对象。“真实”对象将通过Value属性访问

稍微不同的方法是创建一个包装器，它实现与“真实”对象相同的接口，从而使包装透明。

interface ISomeInterface
{
    string PropertyA { get; set }
    void MethodB (int x);
}

class TheRealObject : ISomeInterface
{
    public string PropertyA { get; set }

    public void MethodB (int x)
    {
        Console.WriteLine(x);
    }
}

class Wrapper : ISomeInterface
{
    TheRealObject _obj = new TheRealObject();

    public string PropertyA
    { 
        get { return _obj.PropertyA; }
        set { _obj.PropertyA = value; }
    }

    public void MethodB (int x)
    {
        _obj.MethodB(x);
    }

    public void CreateNewObject()
    {
        _obj = new TheRealObject();
    }
}

现在包装器可以像“真实”对象一样使用。您还可以在包装器的构造函数中传递“真实”对象的初始实例，并删除_obj.

于 2012-07-07T18:32:16.700 回答
6

由于对象状态是由字段值定义的，因此您可以将包含字段值的内存从一个对象复制到另一个对象，从而有效地“替换”它：

public static void Replace<T>(T x, T y)
    where T : class
{
    // replaces 'x' with 'y'
    if(x == null) throw new ArgumentNullException("x");
    if(y == null) throw new ArgumentNullException("y");

    var size = Marshal.SizeOf(typeof(T));
    var ptr = Marshal.AllocHGlobal(size);
    Marshal.StructureToPtr(y, ptr, false);
    Marshal.PtrToStructure(ptr, x);
    Marshal.FreeHGlobal(ptr);
}

请注意，此代码需要[StructLayout(LayoutKind.Sequential)]（或LayoutKind.Explicit）为类定义的属性。

于 2012-07-07T18:14:38.130 回答
4

不，那是不可能的。

要真正更改对对象的所有引用，您必须冻结进程中的所有线程，并访问它们的寄存器集和堆栈。这就是垃圾收集器所做的，但对于常规代码是不可能的。

该方法最有可能做的是将一个对象深拷贝到另一个对象上。

于 2012-07-07T18:02:02.653 回答
1

如果它是您要引用的自定义类，我认为您可以让所有引用指向一个假引用...

  1. 创建你的班级 (A)
  2. 创建你的类接口 (IA)
  3. 根据您的接口创建一个包装类，该类仅将所有调用传递给包含的对象（AC）

我添加了一个赋值运算符，因此我将所有 A 对象作为 AC。

class AC:IA  
{  
    IA ref;  
    AC(IA ref)  
    {  
        this.ref = ref;  
    }  

    public void ChangeReference(IA newRef) { ref = newRef;}  
    public static operator = (IA assignedObj)  
    {  
        return (assignedObject is AC) ? assignedObject : new AC(assignedObj);
    }

    // implementation of all methods in A
    public override string ToString() { return ref.ToString(); }  
        ...  
}

现在，如果您愿意，可以使用 ChangeReference 方法将所有内容切换到新的 Reference..

在 C++ 中，您将使用 Reference to Reference

祝你好运

于 2012-07-07T18:31:18.643 回答