C# 有没有办法扩展内置类型以继承接口？

我想给一些内置类型添加一个接口。我有一个接口，

IConcludable

，我用它作为

结论的约束。我不知道该怎么做，也不知道这是否可能

基本布局

public interface IConcludable { }

public struct Conclusion<T> where T : IConcludable
{
    public bool IsSuccessful;
    public T Result;

    // Constructors, members, etc.
}

public class ErrorReport : IConcludable { ... }

public class MathArg : IConcludable { ... }

public class ParseResult : IConcludable { ... }

研究

我研究了约束条件




似乎约束只会加在一起，因此包含我需要的每个内置类型的接口将需要定义大量与我的
结论
结构无关的方法



扩展方法




这些实际上改变了内置类型的行为。这不是我想要的，因为我的接口，
IConcludable
，没有任何方法

替换内置类型




不可能。不过，我不需要改变这些类型的行为。我只想给它添加一个空接口。


似乎没有任何关于向内置类型添加接口的内容。我不确定“继承”是不是指什么。这可能吗

编辑

public interface IConcludable { }

public struct Conclusion<T> where T : IConcludable
{
    public bool IsSuccessful;
    public T Result;

    // Constructors, members, etc.
}

public class ErrorReport : IConcludable { ... }

public class MathArg : IConcludable { ... }

public class ParseResult : IConcludable { ... }

结论结构的更好解释

在我的大多数方法中，我都将结论结构用作返回对象。这是因为我使用的是代理。请参见以下对象的实际代码：

public delegate Conclusion<T> Validator<T>(T subclass) where T : IVerifiable<T>;

public delegate Conclusion<BaseFunction> Executor(BaseFunction subclass);

public struct Conclusion<T> where T : IConcludable
{
    public bool IsSuccessful;
    public T ReturnObject;

    public Conclusion(T returnObject)
    {
        this.ReturnObject = returnObject;
        this.IsSuccessful = returnObject is Error ? false : true;
    }
}

public class BaseFunction : IVerifiable<BaseFunction>, IConcludable
{
    public List<BaseArgument> Args;
    public Executor Executing;
    public Validator<BaseFunction> Validating;
    public string UserInput;

    public Conclusion<BaseFunction> Validate(BaseFunction subclass)
    {
        if (this.Validating != null)
        {
            return Validating(subclass);
        }
        else
        {
            StringBuilder message = new StringBuilder();
            message.Append("A Validating delegate has not been assigned.");

            throw new InvalidOperationException(message.ToString());
        }
    }

    public Conclusion<BaseFunction> Execute(BaseFunction subclass)
    {
        if (this.Executing != null)
        {
            return this.Executing(subclass);
        }
        else
        {
            StringBuilder message = new StringBuilder();
            message.Append("An Executing delegate has not been assigned.");

            throw new InvalidOperationException(message.ToString());
        }
    }
}

public class Function<T> : BaseFunction
{
    public T Result;

    public Function()
    {
        base.Args = new List<BaseArgument>();
    }
}

public class BaseArgument : IVerifiable<BaseArgument>, IConcludable
{
    public string Role;
    public string UserInput;
    public int Position;
    public Validator<BaseArgument> Validating;

    public Conclusion<BaseArgument> Validate(BaseArgument subclass)
    {
        if (this.Validating != null)
        {
            return Validating(subclass);
        }
        else
            throw new InvalidOperationException();
    }
}

public class Argument<T> : BaseArgument
{
    public T Value;

    public Argument(int position)
    {
        base.Position = position;
    }
}

public static class ExecutionHandler
{
    public static Conclusion<BaseFunction> Sum(BaseFunction subclass)
    {
        subclass = (Function<double>)subclass;

        // Execution code.

        return new Conclusion<BaseFunction>(subclass);
    }

    public static Conclusion<BaseFunction> Concatenate(BaseFunction subclass)
    {
        subclass = (Function<double>)subclass;

        // Execution code.

        return new Conclusion<BaseFunction>(subclass);
    }
}

公共委托结论验证器（T子类），其中T:IVerifiable；
公共委托结论执行器（BaseFunction子类）；
公共结构结论，其中T:i可包含
{
公共事业成功；
公共目标；
公开结论（T对象）
{
this.ReturnObject=ReturnObject；
this.IsSuccessful=returnObject为错误？false:为真；
}
}
公共类基函数：可编辑，可包含
{
公共列表Args；
公开执行人执行；
公共验证器验证；
公共字符串用户输入；
公共结论验证（BaseFunction子类）
{
if（this.Validating！=null）
{
返回验证（子类）；
}
其他的
{
StringBuilder消息=新建StringBuilder（）；
message.Append（“尚未分配验证委托”）；
抛出新的InvalidOperationException（message.ToString（））；
}
}
公共结论执行（BaseFunction子类）
{
if（this.Executing！=null）
{
返回此.Executing（子类）；
}
其他的
{
StringBuilder消息=新建StringBuilder（）；
Append（“尚未分配正在执行的委托”）；
抛出新的InvalidOperationException（message.ToString（））；
}
}
}
公共类函数：BaseFunction
{
公众对结果的怀疑；
公共职能（）
{
base.Args=新列表（）；
}
}
公共类BaseArgument:可编辑，可包含
{
公共字符串角色；
公共字符串用户输入；
公共职位；
公共验证器验证；
公共结论验证（BaseArgument子类）
{
if（this.Validating！=null）
{
返回验证（子类）；
}
其他的
抛出新的InvalidOperationException（）；
}
}
公共类参数：BaseArgument
{
公共价值观；
公共参数（整型位置）
{
基本位置=位置；
}
}
公共静态类ExecutionHandler
{
公共静态结论和（基函数子类）
{
子类=（函数）子类；
//执行代码。
返回新结论（子类）；
}
公共静态结论连接（BaseFunction子类）
{
子类=（函数）子类；
//执行代码。
返回新结论（子类）；
}
}

如果我需要发布更多，我会的。但它确实有很多值得一看的地方。我使用的所有代理分配的方法的返回类型都有一个返回类型
Conclusion
，这样我就可以有一个返回对象以及一个错误（如果出现）。上面代码中的函数返回
结论
，但如果返回值是一个数字，则该返回值将转换为一个对象
加数
。如果它是另一种类型的函数的一部分，返回
字符串
或
bool
或其他类型，则会将其转换为不同类型的类。在数值计算结束时，返回值类似于
结论
或
结论
。因此，将
int
和
double
添加到
IConcludable
界面就是我要做的

更好地解释应用程序

我正在编写一个C#控制台应用程序。它接受用户的输入，并写出答案。输入与Excel公式类似：
Sum（5,15，平均值（2,3），5）
或
串联（“5+5=”，Text（Sum（5,5））
。输入字符串将被验证、解析并返回结果。
使用
其中T:IConcludable
泛型类型约束，不能将
int
作为泛型参数传递。而且也无法将接口附加到基元类型

你可以做一些变通来做到这一点。您可以将
结论
的主逻辑放入基本抽象类中并从中继承，将
结论
重组为
类
（因为
结构
不支持继承）并创建类

public class Conclusion<T> : BaseConclusion
where T : IConcludable

更新（添加更多解释）

按照要求，我想就我的最后一个答案再解释一下

要求


结论
需要同时支持值类型和参考类型
一般的
值类型：所有数字数据类型（int、short、long等）、boolean、char、date
引用类型：字符串和用户定义的类（在OP的示例中，public class Conclusion<T> : BaseConclusion
where T : IConcludable

public class PrimitiveConclusion<T> : BaseConclusion
where T : struct

public struct Wrapper<T> : IConcludable
{
    public T Value { get; set; }
}

void Main()
{
    PrimitiveConclusion<int> primitiveConclusion = new PrimitiveConclusion<int>(1);
    Conclusion<ParseResult> parseResultConclusion = new Conclusion<ParseResult>(new ParseResult {});

    Console.WriteLine($"{primitiveConclusion.Result.GetType()}");
    Console.WriteLine($"{parseResultConclusion.Result.GetType()}");
}

public class TestClass
{
    public Conclusion<ParseResult> ParseInput(string input)
    {
        return new Conclusion<ParseResult>(null);
    }
}

public interface IConcludable { }

public abstract class AbstractConclusion<T>
{
    public AbstractConclusion(T t)
    {
        IsSuccessful = t != null;
        Result = t;
    }
    public bool IsSuccessful;
    public T Result;
}

public class Conclusion<T> : AbstractConclusion<T> where T : IConcludable
{
    public Conclusion(T t) : base(t)
    {
    }
}


public class PrimitiveConclusion<T> : AbstractConclusion<T> where T : struct
{
    public PrimitiveConclusion(T t) : base(t)
    {
    }
}


public class ParseResult : IConcludable { }