Question

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

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--;

不够方便。我刚检查了Visual Studio Debugger。这不够好（快）足够。必须再次暂停，更改和运行代码。如果改变的静态变量将改变对象的字段，则所呈现的方法将是好的。

Answer 1

简而言之：不，你不能这样做......至少，不是无缝的。

如上所述，这通常被认为是一个坏主意™。没有对值类型的引用封装，也没有简单的方法来实现无缝的包装类来执行它，因为您不能重载赋值运算符。您可以使用Nullable<T>类型的技术在那里获得分数，但不能再进一步。

最大的绊脚石是赋值算子。对于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;
    }
}

这将保留特定类型的值，将自动转换为适用的类型（例如，Refable<double>将隐式转换为double），但所有分配必须通过引用完成Value属性。

使用示例：

Refable<double> rd1 = new Refable<double>(1.5);
Refable<double> rd2 = d1;

// get initial value
double d1 = rd1;

// set value to 2.5 via second reference
rd2.Value = 2.5;

// get current value
double d2 = rd1;

// Output should be: 1.5, 2.5
Console.WriteLine("{0}, {1}", d1, d2);

Answer 2

你真正想做的是让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();
    }
}

如何使值类型成为ref类型？

2 个答案: