Generische Zwischenfunktion

Question

Ich bin es leid, x > min && x < max zu schreiben, also möchte ich eine einfache Funktion schreiben, bin mir aber nicht sicher, ob ich es richtig mache... eigentlich nicht, weil ich einen Fehler bekomme:

    bool inBetween(T x, T min, T max) where T:IComparable
    {
        return (x > min && x < max);
    }

Fehler:

Operator '>' kann nicht auf Operanden vom Typ 'T' und 'T' angewendet werden
Operator '<' kann nicht auf Operanden vom Typ 'T' und 'T' angewendet werden  

Vielleicht habe ich ein falsches Verständnis des where Teils bei der Funktionserklärung

Hinweis: Für diejenigen, die mir sagen möchten, dass ich mehr Code schreiben werde als zuvor... denkt an die Lesbarkeit =) jede Hilfe wird geschätzt

EDIT

gelöscht, weil es gelöst wurde =)

NOCH EIN BEARBEITEN

also nach einigem Kopfzerbrechen bin ich mit diesem (ähhh) Ding herausgekommen, folgend @Jay Idee von extremer Lesbarkeit:

public static class test
{
    public static comparision Between(this T a, T b) where T : IComparable
    {
        var ttt = new comparision();
        ttt.init(a);
        ttt.result = a.CompareTo(b) > 0;
        return ttt;
    }

    public static bool And(this comparision state, T c) where T : IComparable
    {
        return state.a.CompareTo(c) < 0 && state.result;
    }

    public class comparision
    {
        public IComparable a;
        public bool result;          
        public void init(T ia) where T : IComparable
        {
            a = ia;
        }

    }
}

jetzt können Sie alles mit extremer Lesbarkeit vergleichen =)

Was denkst du.. Ich bin kein Performance-Guru, also sind alle Verbesserungsvorschläge willkommen

Answer 1

IComparable bedeutet, dass das Objekt eine CompareTo-Methode implementiert. Verwenden

public static bool InBetween(this T x, T min, T max) where T:IComparable
{
    return x.CompareTo(min) > 0 && x.CompareTo(max) < 0;
}

Answer 2

Sie müssen die Methode .CompareTo Ihrer Variablen verwenden und auf < und > 0 überprüfen. (Deshalb haben Sie T auf IComparable eingeschränkt).

return (x.CompareTo(min) > 0 && x.CompareTo(max) < 0);

Answer 3

return x.CompareTo(min) > 0 && x.CompareTo(max) < 0;

Wenn Sie maximale Lesbarkeit anstreben, können Sie eine Erweiterungsmethode für IComparable verwenden und eine Syntax wie folgt erstellen:

return 5.IsBetween(10).and(20);

oder

return 5.IsBetween(10.and(20));

Hier ist eine Implementierung für das zweite Beispiel:

public interface IRange
{
    bool ContainsInclusive(T value);
    bool ContainsExclusive(T value);
}

public class ComparableRange : IRange where T : IComparable
{
    T min;
    T max;

    public ComparableRange(T min, T max)
    {
        this.min = min;
        this.max = max;
    }

    public bool ContainsInclusive(T value)
    {
        return value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0;
    }

    public bool ContainsExclusive(T value)
    {
        return value.CompareTo(min) > 0 && value.CompareTo(max) < 0;
    }
}

public static class ComparableExtensions
{
    public static IRange and(this T min, T max) where T : IComparable
    {
        return new ComparableRange(min, max);
    }

    public static bool IsBetween(this T value, IRange range) where T : IComparable
    {
        return range.ContainsExclusive(value);
    }
}

Answer 4

Verwenden Sie IComparable.CompareTo():

a.CompareTo(b) > 0 <=> a>b

a.CompareTo(b) = 0 <=> a=b

a.CompareTo(b) < 0 <=> a

public bool InBetween(T x, T min, T max) where T:IComparable
{
    return x.CompareTo(min) * x.CompareTo(max) < 0;
}

Answer 5

Sie können versuchen, eine Einschränkung hinzuzufügen, dass T ein IComparable ist, und dann CompareTo anstelle von < und > zu verwenden.

Aber das wird wahrscheinlich nicht zulassen, dass Sie alle Werttypen senden können, die Sie möchten. In diesem Fall erstellen Sie einfach die Überladungen, die Sie benötigen, ohne Generika.