C# 基于标准类型拥有自己的类型

我想有自己的类型是基于标准类型

例如，我想要Dzeta类型，它将作为int工作

所以我想写这样的东西：

Dzeta i = 0;
i++;

等等

---

有人能告诉我如何做这样的事情吗？

您不能从任何值类型结构派生。 您只能创建自己的：

public struct Dzeta
{

}

此外，如果需要，您可以重载运算符：

public static Dzeta operator +(Dzeta dz1, Dzeta dz2)
{
   return new Dzeta (/* some operations */);
}

您还可以重载cast运算符，以便在使用int的情况下使用类，cast将自动完成：

public static explicit operator int(Dzeta d)
{
    //return some int
}

然后

---

您需要使用基本运算符和转换的重载创建自己的结构

---

您可以从大多数类继承，但不能从基类型继承，因为它们是密封的

请看这篇文章：

---

阅读有关继承的知识也是一个好主意。如果您想使用面向对象的语言，如C，您将需要它：

我使用扩展和重写使类的行为如下

/* A class that behaves a lot like an int */
public class Dzeta
{
    private int __dzeta;
    public Dzeta() { }
    public Dzeta(int i)
    {
        this.__dzeta = i;
    }

    public static Dzeta operator +(Dzeta a, Dzeta b)
    {
        var c = new Dzeta(a.__dzeta + b.__dzeta);
        return c;
    }
    public static Dzeta operator -(Dzeta a, Dzeta b)
    {
        var c = new Dzeta(a.__dzeta - b.__dzeta);
        return c;
    }
    public static Dzeta operator +(Dzeta a, int b)
    {
        var c = new Dzeta(a.__dzeta + b);
        return c;
    }
    public static Dzeta operator -(Dzeta a, int b)
    {
        var c = new Dzeta(a.__dzeta - b);
        return c;
    }
    public override string ToString()
    {
        return __dzeta.ToString();
    }

}
/* Extend the int like behaviors of my DZeta class*/
public static class DZExtensions
{
    public static Dzeta Sum(this Dzeta self, params Dzeta[] all)
    {
        var z = new Dzeta();
        foreach (var dz in all)
            z += dz;
        return z;
    }
    public static Dzeta Sum(this Dzeta self, params int[] all)
    {
        var z = new Dzeta();
        foreach (var dz in all)
            z += dz;
        return z;
    }
}



/* This is how it can be used in the application*/
public class UsageOfDZeta
{
    public void DoSomeDZetaWork()
    {
        var zz = new Dzeta(5);
        System.Diagnostics.Debug.WriteLine(zz);     // prints 5
        zz += 15;
        System.Diagnostics.Debug.WriteLine(zz);     // prints 20
        zz.Sum(10, 5, 20, 5);
        System.Diagnostics.Debug.WriteLine(zz);     // prints 60
    }
}

---

结构。用谷歌搜索一下。还有，不要偷懒。键入例如“非F.e.”和非smth的内容。

/* A class that behaves a lot like an int */
public class Dzeta
{
    private int __dzeta;
    public Dzeta() { }
    public Dzeta(int i)
    {
        this.__dzeta = i;
    }

    public static Dzeta operator +(Dzeta a, Dzeta b)
    {
        var c = new Dzeta(a.__dzeta + b.__dzeta);
        return c;
    }
    public static Dzeta operator -(Dzeta a, Dzeta b)
    {
        var c = new Dzeta(a.__dzeta - b.__dzeta);
        return c;
    }
    public static Dzeta operator +(Dzeta a, int b)
    {
        var c = new Dzeta(a.__dzeta + b);
        return c;
    }
    public static Dzeta operator -(Dzeta a, int b)
    {
        var c = new Dzeta(a.__dzeta - b);
        return c;
    }
    public override string ToString()
    {
        return __dzeta.ToString();
    }

}
/* Extend the int like behaviors of my DZeta class*/
public static class DZExtensions
{
    public static Dzeta Sum(this Dzeta self, params Dzeta[] all)
    {
        var z = new Dzeta();
        foreach (var dz in all)
            z += dz;
        return z;
    }
    public static Dzeta Sum(this Dzeta self, params int[] all)
    {
        var z = new Dzeta();
        foreach (var dz in all)
            z += dz;
        return z;
    }
}



/* This is how it can be used in the application*/
public class UsageOfDZeta
{
    public void DoSomeDZetaWork()
    {
        var zz = new Dzeta(5);
        System.Diagnostics.Debug.WriteLine(zz);     // prints 5
        zz += 15;
        System.Diagnostics.Debug.WriteLine(zz);     // prints 20
        zz.Sum(10, 5, 20, 5);
        System.Diagnostics.Debug.WriteLine(zz);     // prints 60
    }
}