C# 扩展<&引用；及&燃气轮机&引用；System.Type的运算符

可能重复：

我觉得编译器误解了我该如何重载这些运算符

我认为核心问题是我试图重载操作符作为类的扩展。类型类没有这些操作符，所以我觉得这样做很安全——但我的编译器完全不同意

    public static class TypeCheck
    {
        public static Boolean ToBool(this Type t1, Type t2)
        {
            //normal extension works
            return true;
        }

        public static Boolean operator > (this Type t1, Type t2)
        {
            //TODO once it compiles
            return fasle;
        }

        public static Boolean operator < (this Type t1, Type t2)
        {
            //TODO once it compiles
            return true;
        }

    }

公共静态类类型检查
{
公共静态布尔ToBool（此类型为t1，类型为t2）
{
//正常扩建工程
返回true；
}
公共静态布尔运算符>（此类型为t1，类型为t2）
{
//编译后的待办事项
返回方式；
}
公共静态布尔运算符<（此类型为t1，类型为t2）
{
//编译后的待办事项
返回true；
}
}

为了澄清这些比较的领域细节：

class A:B{}

，

class B{}

和

class C{}

A大于A，大于B，但小于其余部分。因为A.IsCastableTo（B）和A.IsCastableTo（A）

在C#中没有“扩展运算符”

---

至少有一个运算符参数必须是在其中声明运算符的类型。

您可以在自己的类中重载运算符，但不能通过扩展方法在其他类中重载运算符。

您不能将运算符行为定义为扩展方法。
您可以使用与DateTime使用

Add（）

和

Subtract（）

相同的方法来执行此操作，如果无法修改类型实现，则可以将其作为扩展方法来实现

---

您还可以从该类型继承（如果可能的话），并在那里定义运算符。

正如其他人所说，C#不支持扩展运算符。如果需要执行此操作，则可以实现自定义类型，例如：

public class MyType : Type
{
    private Type internalType;

    public MyType(Type t)
    {
        internalType = t;
    }

    public static Boolean operator >(MyType t1, Type t2)
    {
        //TODO once it compiles
        return false;
    }

    public static Boolean operator <(MyType t1, Type t2)
    {
        //TODO once it compiles
        return true;
    }

    public override Assembly Assembly
    {
        get { return internalType.Assembly; }
    }

    public override string AssemblyQualifiedName
    {
        get { return internalType.AssemblyQualifiedName; }
    }

    public override Type BaseType
    {
        get { return internalType.BaseType; }
    }

    public override string FullName
    {
        get { return internalType.FullName; }
    }

    public override Guid GUID
    {
        get { return internalType.GUID; }
    }

    protected override TypeAttributes GetAttributeFlagsImpl()
    {
        return internalType.Attributes;
    }

    protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
    {
        return internalType.GetConstructor(bindingAttr, binder, callConvention, types, modifiers);
    }

    public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
    {
        return internalType.GetConstructors(bindingAttr);
    }

    public override Type GetElementType()
    {
        return GetElementType();
    }

    public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
    {
        return internalType.GetEvent(name, bindingAttr);
    }

    public override EventInfo[] GetEvents(BindingFlags bindingAttr)
    {
        return internalType.GetEvents(bindingAttr);
    }

    public override FieldInfo GetField(string name, BindingFlags bindingAttr)
    {
        return internalType.GetField(name, bindingAttr);
    }

    public override FieldInfo[] GetFields(BindingFlags bindingAttr)
    {
        return internalType.GetFields(bindingAttr);
    }

    public override Type GetInterface(string name, bool ignoreCase)
    {
        return internalType.GetInterface(name, ignoreCase);
    }

    public override Type[] GetInterfaces()
    {
        return internalType.GetInterfaces();
    }

    public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
    {
        return internalType.GetMembers(bindingAttr);
    }

    protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
    {
        return internalType.GetMethod(name, bindingAttr, binder, callConvention, types, modifiers);
    }

    public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
    {
        return internalType.GetMethods(bindingAttr);
    }

    public override Type GetNestedType(string name, BindingFlags bindingAttr)
    {
        return internalType.GetNestedType(name, bindingAttr);
    }

    public override Type[] GetNestedTypes(BindingFlags bindingAttr)
    {
        return internalType.GetNestedTypes(bindingAttr);
    }

    public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
    {
        return internalType.GetProperties(bindingAttr);
    }

    protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
    {
        return internalType.GetProperty(name, bindingAttr, binder, returnType, types, modifiers);
    }

    protected override bool HasElementTypeImpl()
    {
        return internalType.HasElementType;
    }

    public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, System.Globalization.CultureInfo culture, string[] namedParameters)
    {
        return internalType.InvokeMember(name, invokeAttr, binder, target, args, modifiers, culture, namedParameters);
    }

    protected override bool IsArrayImpl()
    {
        return internalType.IsArray;
    }

    protected override bool IsByRefImpl()
    {
        return internalType.IsByRef;
    }

    protected override bool IsCOMObjectImpl()
    {
        return internalType.IsCOMObject;
    }

    protected override bool IsPointerImpl()
    {
        return internalType.IsPointer;
    }

    protected override bool IsPrimitiveImpl()
    {
        return internalType.IsPrimitive;
    }

    public override Module Module
    {
        get { return internalType.Module; }
    }

    public override string Namespace
    {
        get { return internalType.Namespace; }
    }

    public override Type UnderlyingSystemType
    {
        get { return internalType.UnderlyingSystemType; }
    }

    public override object[] GetCustomAttributes(Type attributeType, bool inherit)
    {
        return internalType.GetCustomAttributes(attributeType, inherit);
    }

    public override object[] GetCustomAttributes(bool inherit)
    {
        return internalType.GetCustomAttributes(inherit);
    }

    public override bool IsDefined(Type attributeType, bool inherit)
    {
        return internalType.IsDefined(attributeType, inherit);
    }

    public override string Name
    {
        get { return internalType.Name; }
    }
}

公共类MyType:Type
{
私有型；
公共MyType（t型）
{
内部类型=t；
}
公共静态布尔运算符>（MyType t1，Type t2）
{
//编译后的待办事项
返回false；
}
公共静态布尔运算符您可以在这里找到答案，我甚至不明白一种类型如何可以是>或<另一种类型。@cadrell0:您可以阅读类别B:A

则“B的任何其他比较的工作方式。17不比23更具体。2012年1月1日不比2012年3月1日更具体。“ASDF”不比“QWER”更具体。此外，当C被定义为

类C{}时，
C
会返回什么

。如果你告诉我应该返回false，那么我希望

C>B

或

C==B

返回true。我是cadrell0，这里的用例是什么？有些东西闻起来。。。