C# 为什么隐式运算符是静态的？

我注意到隐式运算符需要称为static，但实际上它根本不是真正的static。。。为什么隐式运算符不能静态访问，但可以通过实例访问。这与静态完全相反。假设我需要一个静态隐式操作符，以便隐式转换类的静态状态

比如说

a = new b(); // implicitly converts b to a.
a = b(); // implicitly convert the static states of b to a.

例如，b是一个非静态类，因为它有一个表单，但出于所有目的，它是静态的，所有实例共享相同的信息，所以我想隐式地转换类的静态内部结构

我将尝试更详细地介绍我的示例，因为杰夫认为这毫无意义

---

class b

显示一个对话框表单，但它保存了输入到静态变量中的所有信息。这是因为b的实例仅显示对话框窗体，输入的数据是一个逻辑数据块（输入的数据只有一个逻辑实例）。所有静态变量都直接适合

类a

，因此我可以无缝地将

b

中的静态变量转换为

a类

的实例，但是我希望使用隐式运算符来完成此任务，而不是使用单独的方法。但它让我感到遗憾的是，我不能拥有一个实际的静态隐式操作符。也许我误解了static这个词，我只是根据它如何与方法和类一起工作来使用它

没有运算符在类的“静态”上工作（除了可能的

typeof

）。换句话说，这样做是不可能的：

var result = System.Int32 + System.Int32;

public class Foo
{
    public int Member { get; set; }

    private static Foo instance = new Foo();
    public static Foo Instance { get { return instance; } }

    private Foo()
    {
    }

    public static implicit operator int(Foo foo)
    {
        return foo.Member;
    }
}

        // Please don't really do this ;)
        Func<string> InputBox = () => MyNamespace.InputBox.Instance.ToString();

        string result = InputBox();

运算符仅对类的实例起作用

int a = ..., b = ...;
var result = a + b;

所有操作符都必须是静态的，所以不需要在“普通静态”操作符和“静态静态”操作符之间消除歧义

<>你可以考虑使用A。大概是这样的：

var result = System.Int32 + System.Int32;

public class Foo
{
    public int Member { get; set; }

    private static Foo instance = new Foo();
    public static Foo Instance { get { return instance; } }

    private Foo()
    {
    }

    public static implicit operator int(Foo foo)
    {
        return foo.Member;
    }
}

        // Please don't really do this ;)
        Func<string> InputBox = () => MyNamespace.InputBox.Instance.ToString();

        string result = InputBox();

然后您可以将其用作：

int a = Foo.Instance;

在C#中，所有运算符定义都是静态的，请参见示例

-当然是二进制运算符定义，因为将一个或另一个声明为

this

是任意的

-一元运算符定义，以匹配二元运算符定义为静态的主题

---

按惯例是这样做的。

如果

运算符不是
静态的
，它就不能处理
空的
操作数

这同样适用于隐式转换运算符的情况：

public class MyClass
{
    public MyClass(int x)
    {
        this.X = x;
    }

    public int X { get; private set; }

    public static implicit operator int(MyClass operand)
    {
        if (operand == null)
        {
            return 0;
        }    
        return operand.X;
    }
}

internal class Program
{
    internal static void Main(string[] args)
    {
        MyClass x = null;
        int y = x; // What instance would a non-static operator use here?
    }
}

下面是我的第二个答案，试图猜测你潜在的问题（而不是像我在第一个答案中那样回答标题中的问题）：

从编辑的问题和评论来看，您似乎正在尝试：

确保只有一个
InputBox
类的实例
将输入框类中的数据转换为
字符串
我会确保您确实只需要强制执行
InputBox
类的一个实例，但是如果这个需求是有根据的，那么您可以使用Singleton模式并重写
ToString
实例方法来执行类似的操作：

class InputBox
{
   static InputBox Instance = new InputBox();

   int someNumber;

   string someText;

   private InputBox()
   {
   }

   // ...    

   public override string ToString()
   {
       return someNumber.ToString() + " " + someText;
   }
}

用法：

string result = InputBox.Instance.ToString();

附录：

如果它真的是关于您想要使用的语法，您可以添加如下委托：

var result = System.Int32 + System.Int32;

public class Foo
{
    public int Member { get; set; }

    private static Foo instance = new Foo();
    public static Foo Instance { get { return instance; } }

    private Foo()
    {
    }

    public static implicit operator int(Foo foo)
    {
        return foo.Member;
    }
}

        // Please don't really do this ;)
        Func<string> InputBox = () => MyNamespace.InputBox.Instance.ToString();

        string result = InputBox();

但是任何阅读你的代码的人都会哭；）
 所有用户定义的运算符都是静态的。我不理解你的问题。你的例子毫无意义，你的问题也没有意义。标准隐式转换的行为就像一个不可见的非静态方法。我想要一个行为类似于不可见静态方法的隐式转换。杰夫：到底什么是没有意义的？我有静态变量。由于显示表单，该类仅为非静态类。但所有数据都保存在静态变量中。我想以静态方式隐式转换静态变量，但隐式运算符的常规行为类似于非静态方法。@codecamp您可以逐个转换所有静态变量。如果你想强制转换一个完整的静态类，你不能，它是静态的，你不能有它的实例化。如果你想得到它的一个实例，并使用它，然后你不希望它是静态的。
深奥的语法混乱
终于有人理解我了。所以我不能隐式转换一个静态类，即使它在逻辑上可以隐式转换？不。你必须创建一个类似
静态MyClass ToMyClass（）
的方法。
typeof
如何工作？我问这个问题的唯一原因是因为我想看看我是否能让C#表现得像一种函数式编程语言。现在我有了一个解决方案，它使用了
new
关键字，但这很愚蠢，因为我没有理由使用新关键字，而只是显示一个始终是相同表单的表单。
typeof
是一种语言功能。它内置于C#中，不能在自定义运算符中重写或模仿它的行为。我真的不确定这将如何使C#的行为更像一种函数式语言，但请参阅我的另一个解决方案的更新。typeof是在编译时计算的。静态隐式运算符的行为与不可见的非静态方法完全一样。没有办法使隐式运算符的行为像不可见的静态方法一样？@codecamp您一直在说“隐式运算符”。我想指出的是，所有自定义运算符定义，二进制和一元，在C#中都声明为静态的，对于implicit定义没有什么特别之处。Patashu，我想创建一个静态的隐式转换。我不明白是什么使操作符是静态的。但我知道一件事，它的行为完全像一个非静态方法。这对我来说是矛盾的。我不能直接从类的实例访问静态对象，但我只能从完全相反的角度访问静态隐式对象；类的实例。我明白，自从体育运动以来，我想做的事情很少见