Question

我试图将对象与int值（例如

）进行比较

if (myObject - 5 == 0)
    doSomething();

我的课程看起来像这样：（删除了大多数setter / getters，所以不要介意所有变量都是私有的）

public class SomeClass
{
    public string name;
    private int minValue;
    private int maxValue;
    private int currValue;

    public int getCurrentValue()
    {
        return currValue;
    }
}

我想要达到的目标是：

someClassInstance - 5;

是平等的

someClassInstance.getCurrentValue() - 5;

我可以覆盖对象作为一个int（它自己的变量）而不仅仅是一个对象吗？

Answer 1

可能是运营商的情况吗？

public class SomeClass {
  ...

  public static int operator -(SomeClass left, int right) {
    if (Object.ReferenceEquals(null, left))
      throw new ArgumentNullException("left");

    return left.getCurrentValue() - right;
  }
}

...

SomeClass someClassInstance = new SomeClass(...);

int result = someClassInstance - 5;

另一种可能性（基于隐式运算符）是在需要时将 SomeClass隐式转换为int：

public class SomeClass {
  ...

  // Whenever int is requiered, but SomeClass exists make a conversion
  public static implicit operator int(SomeClass value) {
    if (Object.ReferenceEquals(null, value))
      throw new ArgumentNullException("value");

    return value.getCurrentValue();
  }
}

...

SomeClass someClassInstance = new SomeClass(...);

int result = someClassInstance - 5;

Answer 2

实际上你可以更好地覆盖operator int，这样你可以用更少的重载做更多的计算：

using System;

namespace Demo
{
    public class SomeClass
    {
        public string name;
        private int minValue;
        private int maxValue;
        public int currValue;

        public int getCurrentValue()
        {
            return currValue;
        }

        public static implicit operator int(SomeClass value)
        {
            if (value == null)
                throw new ArgumentNullException("value");

            return value.currValue;
        }
    }

    internal class Program
    {
        private void run()
        {
            var test = new SomeClass {currValue = 5};

            if (test - 5 == 0)
                Console.WriteLine("It worked");

            if (test + 5 == 10)
                Console.WriteLine("This also worked");
        }

        private static void Main()
        {
            new Program().run();
        }
    }
}

Answer 3

您可以尝试混合使用implicit conversions和operator overloading，但根据我的经验，您永远不会让它像您希望的那样无缝地工作（并且您可以在C ++中使用它）。

如果我是你，我会将getCurrentValue更改为属性：

public int CurrentValue
{
    get {return currValue};
}

并使用someClassInstance.CurrentValue -5

覆盖对象返回值

3 个答案: