.NET/C#：是否可以用另一个对象替换内存中的一个对象？

以这段代码为例：

class Jooky
{
    static long Last;
    public Jooky() { Id += Last++; }
    public long Id { get; set; }
    public string Name { get; set; }
}

class Flooky
{
    public Flooky() { Jooky1 = new Jooky(); Jooky2 = new Jooky(); }
    public Jooky Jooky1 { get; set; }
    public Jooky Jooky2 { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        List<Flooky> Flookies = new List<Flooky>();

        //I build a collection of flookies to emulate the service call of
        //FlookyProxy.GetAllFlookies().
        for (int i = 0; i < 5; i++) Flookies.Add(new Flooky());

        //This makes a collection of all the jookies in all the flookies.
        var Jookies = Flookies.Select(f => f.Jooky1).Union(Flookies.Select(f => f.Jooky2));

        //I get the jooky.
        Jooky Jooky = Jookies.Single(j => j.Id == 2);

        //Fig 1: I just got a jooky out of the collection. One of the flookies
        //has a reference to this jooky. I want to set the jooky to a new
        //reference, but still want the same flooky to reference it.
        Jooky = new Jooky { Name = "Bob" };

        //I get the jooky again
        Jooky = Jookies.Single(j => j.Id == 2);

        //However, this writes an empty string because only the Jooky variable
        //I previously declared was affected.
        Console.WriteLine(Jookies.Single(j => j.Id == 2).Name);

        //Basically, I want the code in Fig 1 above to be the same as:
        //Flooy.Jooky = new Jooky { Name = "Bob" };

        Console.Read();
    }
}

classjooky
{
静态持久；
public Jooky（）{Id+=Last++；}
公共长Id{get；set；}
公共字符串名称{get；set；}
}
一等一等
{
public-Flooky（）{Jooky1=new-Jooky（）；Jooky2=new-Jooky（）；}
公共Jooky Jooky1{get；set；}
public Jooky Jooky2{get；set；}
}
班级计划
{
静态void Main（字符串[]参数）
{
List Flookies=新列表（）；
//我构建了一个flookie集合来模拟
//FlookyProxy.GetAllFlookies（）。
对于（inti=0；i<5；i++）Flookies.Add（newflooky（））；
//这是所有地板上所有Jookie的集合。
var Jookies=Flookies.Select（f=>f.Jooky1）.Union（Flookies.Select（f=>f.Jooky2））；
//我得到了jooky。
Jooky-Jooky=Jookies.Single（j=>j.Id==2）；
//图1：我刚从收藏品中得到一个jooky。一个Flookie
//有此jooky的引用。我想将jooky设置为新的
//引用，但仍然希望相同的flooky引用它。
Jooky=newjooky{Name=“Bob”}；
//我又得到了乔基
Jooky=Jookies.Single（j=>j.Id==2）；
//但是，这会写入一个空字符串，因为只有Jooky变量
//我以前曾声明受到影响。
WriteLine（Jookies.Single（j=>j.Id==2.Name）；
//基本上，我希望上面图1中的代码与以下代码相同：
//Flooy.Jooky=newjooky{Name=“Bob”}；
Console.Read（）；
}
}

基本上，变量A在内存中引用Aa，变量B在内存中引用对象Bb。我想引用内存中与B相同的对象，而不是像

A=B。相反，我想用另一个替换内存中的物理对象，最终像
Aa=Bb

这有可能吗

更新：主要规则：我不能直接引用flooky，所以我不能像
flooky.Jooky1=new Jooky（）
或
Flookies[3]。Jooky1=new Jooky（）
更改：

//Jooky = new Jooky { Name = "Bob" };
Jooky.Name = "Bob" ;

.Single（）
的结果是对实例（对象）的引用。您刚刚用一个对象覆盖了对新对象的引用。旧对象未被更改或覆盖

要了解发生了什么，并调整您的目标，请查看“值类型和引用类型”。有很多书要读


阅读评论后：

如果你的细节（Jookies）将独立于其所有者（Flookies）而改变，那么你只需要另一层间接性

一个简单的建议：


不要存储对详细信息的引用（因为它们会更改）
而是存储一个DetailId（JookyId1、JookyId2）
将详细信息保存在字典中（
字典
）
在Owner中创建一个（只读）属性，通过在字典中查找来获取Detail1

如果要用另一个对象替换和对象而不只是指定引用，则只需将所有数据字段复制到另一个对象即可。不确定我是否正确理解了您的问题。
当您处理引用时，对引用的每个赋值都会更改引用指向的对象

所以，当你说：

Jooky-Jooky=Jookies.Single（j=>j.Id==2）

您正在创建一个对Jookie的引用
Id==2
。然后，当你说
Jooky=newjooky{Name=“Bob”}，您正在告诉您创建的引用指向您刚刚创建的Jooky

因此，如果您想为
Flookies[0]
对象的
Jookie1
属性（它是对Jookie对象的引用的占位符）设置一个新值，您必须说：

Flookies[0].Jooky1=newjooky{Name=“Bob”}（如@Ashley John的回答所述）

这样，您就告诉了
Flookies[0]。Jooky1
参考指向
新的Jooky{Name=“Bob”}对象

有关详细说明，请参阅。
您可以用C#编写不安全的代码，这使您能够在直接内存上操作

有关详细信息，请查看此处：


<>你会注意到你可以使用熟悉的指针（*）和C和C++的地址（）。p>
下面是一个不安全交换的示例，我认为这正是您所追求的：
如果您有权访问
Jookie
类，则可以添加一个属性，该属性保存
Jookie
的父
Flookie
：

class Jooky 
{
    static long Last;
    public Jooky(Flooky parent) 
    {
        Id += Last++; 
        Parent = parent;
    }
    public long Id { get; set; }
    public string Name { get; set; }
    public Flooky Parent { get; private set; }
}

然后访问父级
Flookie
并将其更改为
Jookie1
属性：

Flookie flookie = Jookies.Single(j => j.Id == 2).Parent;
flookie.Jookie1 = new Jookie { Name = "Bob" }

也许这在哈瓦杜建议的不安全代码中是可能的，但在安全代码中肯定是不可能的。重要的是要理解为什么做你想做的事情是不安全的。它不仅破坏了封装，还破坏了类型安全性。考虑这个例子。

class Me : IHaveCar
{
    BuickCentury myCentury = new BuickCentury(2004);

    public Car Car { get { return myCentury; } }

    public void Drive()
    {
        myCentury.CruiseWithAuthority();
    }
}

class EvilOilChangeService
{
    public void ChangeOil(IHaveCar customer)
    {
        Car car = customer.Car;
        // here's the fictional "replace object in memory" operator
        car <<== new VolkswagenBeetle(2003);
    }
}

Me类：IHaveCar
{
别克世纪迈森图里=新别克世纪（2004）；
公共汽车{获取{返回迈森图里；}
公共车道（）
{
myCentury.CruiseWithAuthority（）；
}
}
类别转换服务
{
公共车辆更换机油（IHaveCar客户）
{
Car=customer.Car；
//下面是虚构的“替换内存中的对象”操作符
你为什么要这样做？clr为你处理了很多事情。
LinkedList
也可能对你有好处。一般性意见：不要以大写字母开头局部变量名。不要像上一段那样使用命名约定。允许你做你想做的事情会破坏封装。flooky对jooky i非常满意t's current get-更改flooky的jooky的唯一方法应该是通过给flooky的消息（例如方法或属性设置器）。我认为他希望它是cha
class Me : IHaveCar
{
    BuickCentury myCentury = new BuickCentury(2004);

    public Car Car { get { return myCentury; } }

    public void Drive()
    {
        myCentury.CruiseWithAuthority();
    }
}

class EvilOilChangeService
{
    public void ChangeOil(IHaveCar customer)
    {
        Car car = customer.Car;
        // here's the fictional "replace object in memory" operator
        car <<== new VolkswagenBeetle(2003);
    }
}