-1

我在静态类中有一个静态双变量。当我创建一个特定的类时，我使用 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--;

不够方便。我刚刚检查了 Visual Studio 调试器。它不够好（快）。必须再次暂停、更改和运行代码代码。如果更改的静态变量会更改对象的字段，我提出的方法会很好。

4

2 回答 2

1

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

如前所述，这通常被认为是 A Bad Idea™。没有值类型的引用封装，也没有简单的方法来实现无缝包装类来做到这一点，因为您不能重载赋值运算符。您可以使用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);
于 2013-09-16T01:40:14.667 回答
0

你真正想做的是有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();
    }
}
于 2013-09-16T01:49:19.283 回答