Megosztás a következőn keresztül:

CA1036: Hasonló típusok felülbírálási módszerei

  • Cikk
Tulajdonság Érték
Szabályazonosító CA1036
Cím Hasonló típusok felülbírálási módszerei
Kategória Design
A javítás kompatibilitástörő vagy nem törik Nem törés
Alapértelmezés szerint engedélyezve a .NET 8-ban Nem

Ok

Egy típus implementálja az System.IComparable interfészt, és nem bírálja felül System.Object.Equals vagy nem túlterheli a nyelvspecifikus operátort az egyenlőség, az egyenlőtlenség, a kisebb vagy nagyobb érték miatt. A szabály nem jelent szabálysértést, ha a típus csak a felület implementációját örökli.

Ez a szabály alapértelmezés szerint csak külsőleg látható típusokat tekint meg, de ez konfigurálható.

Szabály leírása

Az egyéni rendezési sorrendet meghatározó típusok implementálják a IComparable felületet. A CompareTo metódus egy egész számot ad vissza, amely a megfelelő rendezési sorrendet jelzi a típus két példányához. Ez a szabály a rendezési sorrendet beállítva típusokat azonosítja. A rendezési sorrend beállítása azt jelenti, hogy az egyenlőség, az egyenlőtlenség, a kisebb és a nagyobb, mint nem alkalmazható. Amikor implementációt IComparablead meg, általában felül kell bírálnia Equals azt is, hogy az visszaadja azokat az értékeket, amelyek összhangban vannak a következővel CompareTo. Ha felülbírál Equals , és olyan nyelven kódolt, amely támogatja az operátorok túlterhelését, akkor olyan operátorokat is meg kell adnia, amelyek összhangban vannak a következőkkel Equals: .

Szabálysértések kijavítása

A szabály megsértésének kijavításához felülbírálás Equals. Ha a programozási nyelv támogatja az operátorok túlterhelését, adja meg a következő operátorokat:

  • op_Equality
  • op_Inequality
  • op_LessThan
  • op_GreaterThan

A C#-ban az operátorok ábrázolására használt jogkivonatok a következők:

==
!=
<
>

Mikor kell letiltani a figyelmeztetéseket?

A CA1036 szabály figyelmeztetését nyugodtan letilthatja, ha a szabálysértést hiányzó operátorok okozzák, és a programozási nyelv nem támogatja az operátorok túlterhelését, ahogyan a Visual Basic esetében is. Ha úgy ítéli meg, hogy az operátorok implementálása nem értelmezhető az alkalmazáskörnyezetben, akkor nyugodtan el is tilthatja a szabály figyelmeztetését, ha nem op_Equality egyenlőségi operátorokat aktivál. A felülbíráláskor azonban mindig felül kell bírálnia a op_Equality és az == operátort Object.Equals.

Figyelmeztetés mellőzése

Ha csak egyetlen szabálysértést szeretne letiltani, adjon hozzá előfeldolgozási irányelveket a forrásfájlhoz a szabály letiltásához és újbóli engedélyezéséhez.

#pragma warning disable CA1036
// The code that's violating the rule is on this line.
#pragma warning restore CA1036

Ha le szeretné tiltani egy fájl, mappa vagy projekt szabályát, állítsa annak súlyosságát none a konfigurációs fájlban.

[*.{cs,vb}]
dotnet_diagnostic.CA1036.severity = none

További információ: Kódelemzési figyelmeztetések letiltása.

Kód konfigurálása elemzéshez

A következő beállítással konfigurálhatja, hogy a kódbázis mely részein futtassa ezt a szabályt.

Ezt a beállítást konfigurálhatja csak ehhez a szabályhoz, az összes szabályhoz, vagy az ebben a kategóriában (Tervezés) szereplő összes szabályhoz, amelyekre vonatkozik. További információ: Kódminőségi szabály konfigurációs beállításai.

Adott API-felületek belefoglalása

A kódbázis azon részeit konfigurálhatja, amelyeken futtathatja ezt a szabályt az akadálymentességük alapján. Ha például meg szeretné adni, hogy a szabály csak a nem nyilvános API-felületen fusson, adja hozzá a következő kulcs-érték párot a projekt egyik .editorconfig fájljához:

dotnet_code_quality.CAXXXX.api_surface = private, internal

Példák

Az alábbi kód egy helyesen implementálható típust IComparabletartalmaz. A kód megjegyzései azonosítják azokat a metódusokat, amelyek megfelelnek a különböző szabályoknak, amelyek kapcsolódnak a IComparable felülethezEquals.

// Valid ratings are between A and C.
// A is the highest rating; it is greater than any other valid rating.
// C is the lowest rating; it is less than any other valid rating.

public class RatingInformation : IComparable, IComparable<RatingInformation>
{
    public string Rating
    {
        get;
        private set;
    }

    public RatingInformation(string rating)
    {
        if (rating == null)
        {
            throw new ArgumentNullException("rating");
        }

        string v = rating.ToUpper(CultureInfo.InvariantCulture);
        if (v.Length != 1 || string.Compare(v, "C", StringComparison.Ordinal) > 0 || string.Compare(v, "A", StringComparison.Ordinal) < 0)
        {
            throw new ArgumentException("Invalid rating value was specified.", "rating");
        }

        Rating = v;
    }

    public int CompareTo(object? obj)
    {
        if (obj == null)
        {
            return 1;
        }

        if (obj is RatingInformation other)
        {
            return CompareTo(other);
        }

        throw new ArgumentException("A RatingInformation object is required for comparison.", "obj");
    }

    public int CompareTo(RatingInformation? other)
    {
        if (other is null)
        {
            return 1;
        }

        // Ratings compare opposite to normal string order, 
        // so reverse the value returned by String.CompareTo.
        return -string.Compare(this.Rating, other.Rating, StringComparison.OrdinalIgnoreCase);
    }

    public static int Compare(RatingInformation left, RatingInformation right)
    {
        if (object.ReferenceEquals(left, right))
        {
            return 0;
        }
        if (left is null)
        {
            return -1;
        }
        return left.CompareTo(right);
    }

    // Omitting Equals violates rule: OverrideMethodsOnComparableTypes.
    public override bool Equals(object? obj)
    {
        if (obj is RatingInformation other)
        {
            return this.CompareTo(other) == 0;
        }

        return false;
    }

    // Omitting getHashCode violates rule: OverrideGetHashCodeOnOverridingEquals.
    public override int GetHashCode()
    {
        char[] c = this.Rating.ToCharArray();
        return (int)c[0];
    }

    // Omitting any of the following operator overloads 
    // violates rule: OverrideMethodsOnComparableTypes.
    public static bool operator ==(RatingInformation left, RatingInformation right)
    {
        if (left is null)
        {
            return right is null;
        }
        return left.Equals(right);
    }
    public static bool operator !=(RatingInformation left, RatingInformation right)
    {
        return !(left == right);
    }
    public static bool operator <(RatingInformation left, RatingInformation right)
    {
        return (Compare(left, right) < 0);
    }
    public static bool operator >(RatingInformation left, RatingInformation right)
    {
        return (Compare(left, right) > 0);
    }
}

Az alábbi alkalmazáskód a korábban bemutatott implementáció viselkedését teszteli IComparable .

public class Test
{
    public static void Main1036(string[] args)
    {
        if (args.Length < 2)
        {
            Console.WriteLine("usage - TestRatings  string 1 string2");
            return;
        }
        RatingInformation r1 = new RatingInformation(args[0]);
        RatingInformation r2 = new RatingInformation(args[1]);
        string answer;

        if (r1.CompareTo(r2) > 0)
            answer = "greater than";
        else if (r1.CompareTo(r2) < 0)
            answer = "less than";
        else
            answer = "equal to";

        Console.WriteLine("{0} is {1} {2}", r1.Rating, answer, r2.Rating);
    }
}

Kapcsolódó információk