创造你自己的“int”或“字符串”班级

Question

我反汇编了 .NET“系统”DLL，并查看了变量类（字符串、整数、字节等）的源代码，看看是否可以弄清楚如何创建一个可以接受值的类。我注意到“Int32”类继承了以下内容：IComparable、IFormattable、IConvertible、IComparable、IEquatable。

String 和 Int32 类是不可继承的，我无法弄清楚这些继承的接口中的哪些内容允许这些类保存值。我想要的是这样的：

public class MyVariable : //inherits here
{
     //Code in here that allows it to get/set the value
} 

public static class Main(string[] args)
{
     MyVariable a = "This is my own custom variable!";
     MyVariable b = 2976;

     if(a == "Hello") { }
     if(b = 10) { }
     Console.WriteLine(a.ToString());
     Console.WriteLine(a.ToString());
}

Answer 1

您可以通过重载运算符来做到这一点。 MSDN 上有一个教程。

假设您想要一个可以是字符串或整数的类型（例如 Haskell 的 两者之一）：

public sealed class StringOrInt32
{
    private string stringValue;
    private int int32Value;
    private bool isString;

    public bool IsString { get { return isString; } }
    public bool IsInt32 { get { return !isString; } }

    public string StringValue
    {
        get
        {
            if(!isString) throw new InvalidOperationException();
            return stringValue;
        }
    }

    public int Int32Value
    {
        get
        {
            if(isString) throw new InvalidOperationException();
            return int32Value;
        }
    }

    public StringOrInt32(string value)
    {
        isString = true;
        stringValue = value;
    }

    public StringOrInt32(int value)
    {
        isString = false;
        int32Value = value;
    }

    // Allows writing this:
    // StringOrInt32 foo = "Hello world!";
    public static implicit operator StringOrInt32(string value)
    {
        return new MyVariable(value);
    }

    // Allows writing this:
    // StringOrInt32 foo = 42;
    public static implicit operator StringOrInt32(int value)
    {
        return new MyVariable(value);
    }

    // Allows writing this:
    // StringOrInt32 foo = "Hello world!;
    // string bar = (string)foo;
    // Though foo.StringValue directly would be better
    public static explicit operator string(StringOrInt32 value)
    {
        return value.StringValule;
    }

    // Allows writing this:
    // StringOrInt32 foo = 42;
    // int bar = (int)foo;
    // Though foo.Int32Value directly would be better
    public static explicit operator int(StringOrInt32 value)
    {
        return value.Int32Value;
    }

    public static bool operator==(StringOrInt32 left, StringOrInt32 right)
    {
        if(left.IsString != right.IsString)
            return false;
        if(left.IsString)
            return left.StringValue == right.StringValue;
        else
            return left.Int32Value == right.Int32Value;
    }

    public static bool operator!=(StringOrInt32 left, StringOrInt32 right)
    {
        return !(left == right)
    }

    // Don't forget to override object.Equals(), object.GetHashCode(),
    // and consider implementing IEquatable<StringOrInt32>
    // Also, null checks, etc
}

Answer 2

C# 中的内置类型被“特殊”处理，因为代码中的文字值 1234 被定义为 System.Int32 类型，而文字值 “some string” 被定义为 System.Int32 类型。 code> 被定义为 System.String 类型。

因此，为了支持您想要的代码类型，您需要提供可以从 int 和 string（以及其他任何类型）转换为您的类型的转换运算符。查看 MSDN 中的转换运算符主题。

Answer 3

通常，您希望创建一个新类型来存储新的数据表示形式。在上面的示例中，您使用 MyVariable 来存储字符串 - 字符串类型已经擅长这样做。

如果您想存储不同类型的数据，例如在一个易于发送的包中存储字符串和 int 的组合，您可以按照上面开始的方式进行操作：

public class MyVariable
{
    public string Name { get; set; }
    public int Age { get; set; }
} 

然后：

MyVariable personOne = new MyVariable { Name = "John", Age = 34 };
MyVariable personTwo = new MyVariable { Name = "Joe", Age = 312 };

IComparable 和 IFormattable 等接口允许您的新类型以特定方式使用，例如 IComparable 可以传递到排序列表，因为它能够将其自身与另一个实例进行比较并相应地对它们进行“排名”。

Answer 4

“int”和“string”是内置类型。如果没有可辨别的领域，你将无法制作出类似的产品。但是，您可以创建一些外观和行为几乎与内置类型完全相同的东西。

最好的例子是Nullable。这提供了所有值类型的可为空版本，并且可以像内置一样进行分配：

int? x = 0;
int? y = null;

其工作方式是 Nullable 覆盖显式和隐式转换。通过这种方式，您可以将 int 等内置类型分配给自定义 Nullable，并且 Nullable.op_Implicit 中的代码会透明地处理转换。

这是一个完整的示例：

public struct MyVariable
{
    private int _intValue;
    private string _stringValue;

    public override bool Equals(object obj)
    {
        if (!(obj is MyVariable))
        {
            return false;
        }
        var y = (MyVariable) obj;
        return _stringValue == y._stringValue && _intValue == y._intValue;
    }

    public override int GetHashCode()
    {
        return (_stringValue ?? _intValue.ToString()).GetHashCode();
    }

    public override string ToString()
    {
        return _stringValue ?? _intValue.ToString();
    }

    public static implicit operator MyVariable(string value)
    {
        return new MyVariable { _stringValue = value };
    }

    public static implicit operator MyVariable(int value)
    {
        return new MyVariable { _intValue = value };
    }

    public static bool operator==(MyVariable variable, string value)
    {
        return variable._stringValue == value;
    }

    public static bool operator ==(MyVariable variable, int value)
    {
        return variable._intValue == value;
    }

    public static bool operator !=(MyVariable variable, string value)
    {
        return variable._stringValue == value;
    }

    public static bool operator !=(MyVariable variable, int value)
    {
        return variable._intValue == value;
    }

    public static void Test()
    {
        MyVariable a = "This is my own custom variable!";
        MyVariable b = 2976;

        if (a == "Hello") { }
        if (b == 10) { }
        Console.WriteLine(a.ToString());
        Console.WriteLine(a.ToString());
    }
}