Question

var abc = new MyObject();
var xyz = abc;

据我了解，xyz和abc是指向相同信息的不同对象。

有没有办法可以重新计算？基本上，我想在赋值发生时增加对象内部的值

Answer 1

没有。 C＃不是C ++;该值实际上并未复制到您粘贴的代码段中（除非MyObject是值类型）。

Answer 2

不，xyz和abc是相同对象的引用。

不，你不能做引用计数。

Answer 3

这样做的唯一方法是利用（隐式）转换运算符重载。可能这不是，Eric et.all的意图，但是如果你仔细设计你的类，它就有效。

在重载运算符中，您可以创建新（左侧）对象并更新任何引用计数器。但是，很明显，这意味着要确保该方案不存在其他方式。即右侧的对象必须始终为正确的类型。使用'var'是完全不可能的。

Answer 4

C＃不允许赋值运算符重载。你可以使用增加/减少引用计数的包装器，但这不是那么漂亮。这是一个粗略的草图：

class RefCounted<T>
{
    private int refCount;
    public readonly T Obj;

    public RefCounted(T obj)
    {
        Obj = obj;
    }

    public void Get()
    {
        refCount++;
    }

    public void Release()
    {
        if (refCount > 0)
        {
            refCount--;
        }
    }
}

class Wrapper<T> : IDisposable
{
    private RefCounted<T> obj;
    private bool disposed = false;

    public Wrapper(RefCounted<T> o)
    {
        o.Get();
        obj = o;
    }

    public Wrapper<T> Copy()
    {
        return new Wrapper<T>(obj);
    }

    public static implicit operator T(Wrapper<T> wrapper)
    {
        return wrapper.obj.Obj;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    private void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                obj.Release();
                obj = null;
            }
            disposed = true;
        }
    }
}

static class Wrapper
{
    public static Wrapper<T> New<T>(T obj)
    {
        return new Wrapper<T>(new RefCounted<T>(obj));
    }
}

以下是一个例子：

public class Task
{
    public int TaskId { get; set; }
    public int ParentId { get; set; }
}

...

var o = Wrapper.New(new Task() { TaskId = 1 });
var o1 = o.Copy();
var o2 = o1.Copy();
((Task) o1).TaskId = 3;
o2.Dispose();
o1.Dispose();
o.Dispose();

您也可以使用using进行作用域，因为包装器实现了IDisposable。

C＃ - 当变量被赋值给另一个变量时，有没有办法做一些工作（复制构造函数？）

4 个答案: