C# 有没有办法在一个对象内拥有它；“替换自身”；用另一个物体？

我不确定这是否可能，但如果可能的话，我会喜欢的。我有一个类的实例（即一个对象）

a1

，我希望能够在该对象中调用一个方法，建议它用另一个对象

a2

替换自己。我确实希望原始对象（

a1

）是

a2

，这样，如果在

Main（）

中调用

a1.GetHashCode（）

，它将是与

a2

相同的哈希代码

例如：

class Program
{
    static MyObject a2 = new MyObject(1000);

    static void Main(string[] args)
    {
        MyObject a1 = new MyObject(1);      // Create an Object
        a1.ReplaceMe(ref a2);               // Try to replace it

        Console.WriteLine("X = " + a1.x);
        Console.ReadLine();
    }
}

class MyObject
{
    public int x;

    public MyObject(int x)
    {
        this.x = x;
    }

    public void ReplaceMe(ref MyObject somethingElse)
    {
        this = somethingElse;   // REPLACE ITSELF?  (not allowed)
        return;                 // GAURANTEED TO DIRECTLY RETURN
    }
}

但显然

this=somethingElse，因为
此
为只读。我理解为什么不允许（谁知道执行是否完成），但我可以保证你会立即返回

这有什么办法吗


编辑：通过一个例子，了解我为什么要寻找这样的设计。这是总体目标。想象一下，一个平台可以解析关于人的数据，当它找到关于人的信息时，它会用这些信息创建一个
person
的实例。你可以得到一个把手，像这样做：

Person person1 = platform.GetPerson(based_on_data);

现在，假设平台有两个
Person
实例，它认为是不同的人，但突然出现的信息强烈表明这两个实例实际上指的是同一个人。因此，平台希望将实例合并到一个新对象中，我们称之为
personX

现在，有人在平台上四处游荡，其中一个实例的副本被合并了，它是
person1
。我想做的是用
personX
即时替换
person1
。从字面上说，我希望
person1==personX
为真，而不仅仅是它们是具有相同数据的两个不同对象

因为我不能在飞行中用
personX
替换
person1
，我有一个想法，我不会直接访问
Person
，相反，我会访问
PersonPtr
，平台（飞行中）可以改变它指向的
Person
。
我认为不可能；为什么不创建一个静态方法（在MyObject类之外），使用ref-Object A和ref-Object B作为参数

static void replace(ref object a,ref object b)
{
a = b;
}

工作代码：

class Program
{
    static void replace(ref ObjectA a, ref ObjectA b) {
        a = b;
    }
    static void Main(string[] args)
    {
        ObjectA a = new ObjectA();
        ObjectA b = new ObjectA();
        Console.Write("a: " + a.GetHashCode() + "\n");
        Console.Write("b: " + b.GetHashCode() + "\n");
        Console.Read();
        replace(ref a, ref b);
        Console.Write("a: " + a.GetHashCode() + "\n");
        Console.Write("b: " + b.GetHashCode() + "\n");
        Console.Read();

    }
}
class ObjectA
{
}

通过将一个实例“交换”到另一个实例，您基本上希望能够为包含该实例的变量指定不同的值。实现这一点的一种方法可能是：

class Program
{
    static void Main(string[] args)
    {
        MyObject a1 = null, a2 = null;

        MyObject.Create(i => a1 = i);
        MyObject.Create(i => a2 = i);

        Console.WriteLine("a1 hashcode:" + a1.GetHashCode()); // 46104728
        Console.WriteLine("a2 hashcode:" + a2.GetHashCode()); // 12289376

        a1.SwapWith(a2);

        Console.WriteLine("a1 hashcode:" + a1.GetHashCode()); // 12289376
        Console.WriteLine("a2 hashcode:" + a2.GetHashCode()); // 46104728
    }
}

class MyObject
{
    private Action<MyObject> _assigner;
    private MyObject() { }
    public static void Create(Action<MyObject> assigner = null)
    {
        var newInstance = new MyObject();
        newInstance._assigner = assigner;

        newInstance.Assign();
    }

    public void SwapWith(MyObject replacement)
    {
        replacement._assigner = Interlocked.Exchange(ref this._assigner, replacement._assigner);

        this.Assign();
        replacement.Assign();
    }

    private void Assign()
    {
        if (_assigner != null) _assigner(this);
    }
}

类程序
{
静态void Main（字符串[]参数）
{
MyObject a1=null，a2=null；
创建（i=>a1=i）；
创建（i=>a2=i）；
Console.WriteLine（“a1 hashcode:+a1.GetHashCode（））；//46104728
Console.WriteLine（“a2哈希代码：+a2.GetHashCode（））；//12289376
a1.带（a2）的游泳池；
Console.WriteLine（“a1 hashcode:+a1.GetHashCode（））；//12289376
Console.WriteLine（“a2哈希代码：+a2.GetHashCode（））；//46104728
}
}
类MyObject
{
私人诉讼转让人；
私有MyObject（）{}
公共静态无效创建（操作赋值器=null）
{
var newInstance=newmyObject（）；
newInstance.\u assigner=assigner；
newInstance.Assign（）；
}
带（MyObject替换件）的公共无效SwapWith
{
替换。\分配者=联锁交换（参考本。\分配者，替换。\分配者）；
这个.Assign（）；
替换。赋值（）；
}
私有无效分配（）
{
如果（_assigner！=null）_assigner（this）；
}
}
我觉得这是个XY问题。你为什么要这样做？听起来你有一个重大的设计缺陷（或对OOP的重大误解）如果需要在对象自身的方法中更改对象类型，则无法替换
此
，因为它不能作为
ref
从C#传递。而对所问问题的直接答案是否。这就像是试图在飞机在空中飞行的同时，在座位上切换飞机类型。为什么不呢只有a1=a2。如果您将first设置为next，哈希代码将是相同的@L33TS-仅通过反射复制无法满足GetHashCode（）要求。