C# 模仿重写赋值运算符 (=)

Question

我的一个简单的包装类遇到了一些问题。

它看起来像这样：

public class Wrapper<T>
{
  private T _value;

  public Wrapper<T>(T value)
  {
    _value = value;
  }

  public static implicit operator Wrapper<T>(T value)
  {
    return new Wrapper<T>(value);
  }

  public static implicit operator T(Wrapper<T> value)
  {
    return value._value;
  }
}

我已经重写了 T 的隐式转换器和 T 的隐式转换器，因此它的行为几乎就像 T 本身的实例一样。

例如，

Wrapper<int> foo = 42;

但是，在将一个 Wrapper 实例分配给另一个实例时，我遇到了一个小问题，因为我只想分配第二个 Wrapper 类的值。

所以现在，我必须这样做：

Wrapper<int> foo = 42;
Wrapper<int> bar = (int)foo;

或者通过属性公开公开 _value 。

然而，由于这是在图书馆中，并且我不希望用户依赖于记住这一点，你们知道我如何模仿覆盖赋值运算符吗？

只是改变指针（就像将一个类实例分配给另一个类实例时那样）的问题是，我有一个指向这些包装器对象的指针字典，所以我不能让它们一直改变，因为字典会停止那么匹配。

我可以看到这是否有点令人困惑，所以如果我遗漏了任何重要的内容，请随时询问:-)

Answer 1

由于赋值运算符不能重载，因此没有真正好的解决方案。 正如其他人指出的那样，使用结构将为您提供所需的赋值语义，但随后您将面临值语义——通常不是一件好事。

一种选择是重载构造函数：

public Wrapper(Wrapper<T> w)
{
    _value = w._value;
}

这将导致以下语法：

Wrapper<int> foo = 42;
Wrapper<int> bar = new Wrapper<int>(foo);

虽然比您所拥有的更详细，但它读起来更好。

或者您可以添加一个 Clone 方法（不是 ICloneable 接口），这样您就可以编写：

Wrapper<int> bar = foo.Clone();

您可以发挥真正的创意并重载某些运算符，使其基本上不执行任何操作。 但我不建议这样做。 对此类事情使用运算符重载通常会使代码变得神秘并且经常会崩溃。

Answer 2

你可以让 Wrapper一个结构。 但是我不确定这是否适合您的应用程序设计。

Answer 3

如果您查看 Nullable...它的作用与您在这里所做的非常相似，它使用 .Value 属性公开内部值。

仅更改指针（就像将一个类实例分配给另一个类实例时所做的那样）的问题是，我有一个指向这些包装器对象的指针字典，因此我不能让它们一直更改，因为字典将停止匹配。

我不确定我是否遵循这一点，你到底在字典中存储了什么？ 因为如果您要存储引用，CLR 将根据需要更新它们。

Answer 4

不要隐式地双向转换你的包装器。

public class DBValue<T>
{
    public static implicit operator DBValue <T>(T value)
    {
         return new DBValue<T>(value);
    }

    public static explicit operator T(DBValue <T> dbValue)
    {
         return dbValue.Value;
    }

    private readonly T _value;
    public T Value { get { this._value; } }

    public DBValue(T value)
    {
         this._value = value;
    }
}

从 DBValue 转换为 T 是一种有损转换（至少，您会丢失它是来自数据库的值这一事实），并且根据最佳实践应该明确一点。 如果从 DBValue 转换为 T 不会丢失任何内容，那么您不妨只使用返回 T 的属性。

基本上，您已经知道为什么不应该尝试这样做：如果 DBValue 可以代替 T 或相反，编译器（或开发人员）如何知道选择哪个？

要求下游开发人员编写：

string value = MyProperty.Value

或

string value = (string)MyProperty

代替

string value = MyProperty

... 并不是那么繁琐，并且可以确保每个人都确切知道发生了什么。

编辑：

要真正回答问题，您不能覆盖参考分配 - 或使其看起来像您已经这样做 - 但您实际上不需要这样做。

Answer 5

这就是属性的用途。 它们允许您定义分配的含义。 您无法为类或结构本身定义它，因为它们已经由语言定义来执行必要的操作。 只需向类添加一个 Value 属性即可。

或者，编辑您的问题以更广泛地描述您的设计以及此包装器如何融入其中，因为有人可能会建议一种更简单的方法。

Answer 6

我刚刚研究了一下，让类成为结构体确实不是一个选择，因为它在无参数构造函数中有一些逻辑，而且它继承了一个抽象类，其中包含内部抽象函数。

我不能使用接口，因为这会使这些函数公开，这会完全破坏逻辑。

如果有帮助的话我可以发布整个课程，但是有点长（130 行）
或者我可以在单独的服务器上进行折腾，如果那样会更好吗？ （尽管这损害了这个问题的完整性，因为我最终可能会从该服务器中删除它）

另外，在不写一篇完整的文章的情况下解释该类确实很困难:-/

无论如何，我会尝试说明我遇到的问题。

假设有 2 个表类：CustomerTable 和 UserTable：

public class CustomerTable
{
  Wrapper<string> Name;
}

public class UserTable
{
  Wrapper<string> Name;
}

现在的问题是其他一些开发人员可能会使用上面的代码，如下所示：

CustomerTable customer = new CustomerTable();
UserTable user = new UserTable();
user.Name = customer.Name; // This breaks my internal dictionary

为了使其正常工作，开发人员应该做的是：

user.Name = (string)customer.Name;

然而问题是，谁在他们的正常人在写代码的时候会想到这一点吗？

即使我使用了 Value 属性，开发人员仍然必须记住编写

user.Name = customer.Name.Value; // or user.Name.Value = ....

开发人员可能会再次忘记这一点，并且突然他会遇到异常，或者更糟：数据未持久保存到数据库中。

所以我的问题确实是，我希望包装器完全透明（它应该可以使用，就好像它实际上是它所包装的类/基元一样）。
然而，当从一个包装器分配到另一个包装器时，我的内部逻辑就会崩溃。

唷，写了很多，还有很多代码——如果我写得太过头了，请告诉我。

Answer 7

AJ Lane 我明白你的意思，我想你是对的 - 我只是想让这个库的使用尽可能简单。

从 DbValue 到 T 的隐式转换的原因是简单地调用需要 T 的函数。

例如

literalSomething.Text = Server.HtmlEncode(SomeTable.SomeStringColumn);

，

literalSomething.Text = Server.HtmlEncode((string)SomeTable.SomeStringColumn);

这要求转换是隐式的。

话虽这么说，我只是在输入此内容时阅读了您的评论，我可以看到这确实是一个问题。

我想我会回到通过属性公开价值，它只需要开发人员输入更多内容，我认为这会让代码变得丑陋。

想象一下 DbValue：

if (someValue.Value.HasValue) // someValue is DbValue<int?>

但是话又说回来，“丑陋”的代码可能比仅仅阅读它的行为与您所期望的不同的代码更好。

我想这个问题最终会成为一个“最佳实践”问题。

总而言之，我将创建一个 Value 属性并使用它来代替隐式转换，而使用该库的开发人员将不得不忍受这一点。

感谢您的投入:-)

Answer 8

这张旧帖子剧照需要更多信息才能完成。 显然，由于 = 运算符无法重载，因此无法实现最初所需的行为，同样，C# 也无法“欺骗”将对象转换为其自己的类型……它始终会归结为类引用赋值。 但 Steffen 的进一步帖子表明，Wrapper 类不仅用于局部变量，还用作类字段类型。 可以使用所需的语义，并通过使用类属性而不是公共字段来维护内部字典的完整性。

---

甚至可以保留原始给定的Wrapper类及其隐式运算符，这里的代码可以工作：

public class CustomerTable
{
    private Wrapper<string> _Name;
    public Wrapper<string> Name {
        get { return _Name; }
        set { _Name = (string)value; }
    }
}

public class UserTable
{
    private Wrapper<string> _Name;
    public Wrapper<string> Name {
        get { return _Name; }
        set { _Name = (string)value; }
    }
}

如果进行此更改，它不会破坏现有代码，因为它仍然允许设置属性的各种模式：

CustomerTable customer = new CustomerTable();
UserTable user = new UserTable();

user.Name = customer.Name; //*** No longer breaks internal data structures

user.Name = "string literal";  // Works as expected with implicit cast operator
user.Name = (string)customer.Name; // Still allowed with explicit/implicit cast operator
user.Name = customer.Name.Value; // Also works if Value property is still defined

因为这仍然没有回答原始问题，所以仍然可以使用 Wrapper 类如果它在类属性上下文之外使用，即在对象之间传递，等等，就会出现问题。也许可以通过正确的类设计（包括使用属性设置/获取访问器）来消除整个包装类。