C# 如何使值类型成为引用类型？

在静态类中有一个静态双变量。当我创建一个特定的类时，我使用double变量作为构造函数的参数之一。通过更改静态类中的变量来操作对象字段的最简单方法是什么。 为清晰起见，代码：

public static class Vars
{
    public static double Double1 = 5.0;
}
public class ClassFoo
{
    public double Field1;
    public ClassFoo(double number)
    {
        Field1 = number;
    }
}
class Program
{
    static void Main(string[] args)
    {
        ClassFoo Foo = new ClassFoo(Vars.Double1);
        Console.WriteLine(Foo.Field1 + " " + Vars.Double1); //5 5
        Vars.Double1 = 0.0;
        Console.WriteLine(Foo.Field1 + " " + Vars.Double1); //5 0
        //Foo.Field1 need to be a reference to Vars.Double1
    }
}

编辑超出问题范围的内容（无需更多答案，找到其他解决方案）：

我经常更改一些值（字段）（在运行时，或者至少我希望在运行时更改它们），以查找适合我的值。实施：

if(KeyDown)
  variable++; 
if(OtherKeyDown)
  variable--;

---

还不够方便。我刚刚检查了VisualStudio调试器。这不够好（快）。必须暂停、更改并再次运行代码。若改变静态变量会改变对象的场，那个么我提出的方法将是好的

简而言之：不，你不能这么做。。。至少，不是天衣无缝的

如前所述，这通常被认为是一个坏主意™. 没有值类型的引用封装，也没有实现无缝包装类的简单方法，因为不能重载赋值运算符。您可以使用

Nullable

类型中的技术来部分实现这一点，但不能再进一步

最大的障碍是赋值运算符。对于

Nullable

类型，这很好。因为它是非引用的（新值是不同的），所以隐式转换运算符就足够了。对于引用类型，您需要能够重载赋值运算符，以确保赋值更改包含的数据，而不是替换包装器实例

最接近完整参考的是：

public class Refable<T> where T : struct
{
    public T Value { get; set; }

    public Refable(T initial = default(T))
    {
        Value = initial;
    }

    public static implicit operator T(Refable<T> self)
    {
        return self.Value;
    }
}

---

您真正想要做的是让

Vars

成为一个常规类，而不是一个静态类。对于需要处理

Vars

中包含的变量的所有方法和类，可以传入对该

Vars

实例的引用

下面是一个非常简单的示例程序，说明了上述内容。请注意，您可能会做很多事情来改进程序的设计，但这至少会让您朝着正确的方向前进，而不是试图让语言去做它不能或不应该做的事情

public class SharedVars {
    public static double Foo = 0.0;
}

public class ClassFoo {
    private SharedVars mySharedVars;

    public ClassFoo(SharedVars sharedVars) {
        // save a reference to the shared variables container class for future use
        mySharedVars = sharedVars;
    }

    // here's an example use
    public void ProcessKeyDown() {
        mySharedVars.foo++;
    }
}

class Program {
    static void Main(string[] args) {
        SharedVars sharedVars = new SharedVars();
        ClassFoo foo = new ClassFoo(sharedVars);
        // ... some stuff happens ...
        if(KeyDown)
            foo.ProcessKeyDown();
    }
}

---

这不是个好主意。代码中发生的魔法越少越好。为什么不让

Vars.Double1

成为非静态的，并在需要时引用

Double1

传递

Vars的实例呢？这只是个坏主意。我可以看到你的未来：大量错误和调试时间。@MaciejSzpakowski-调试的目的是什么？如果你给我们提供更多的背景，我们可能会提出一个替代方案。
public class SharedVars {
    public static double Foo = 0.0;
}

public class ClassFoo {
    private SharedVars mySharedVars;

    public ClassFoo(SharedVars sharedVars) {
        // save a reference to the shared variables container class for future use
        mySharedVars = sharedVars;
    }

    // here's an example use
    public void ProcessKeyDown() {
        mySharedVars.foo++;
    }
}

class Program {
    static void Main(string[] args) {
        SharedVars sharedVars = new SharedVars();
        ClassFoo foo = new ClassFoo(sharedVars);
        // ... some stuff happens ...
        if(KeyDown)
            foo.ProcessKeyDown();
    }
}