Wie vergleiche ich Objekteigenschaften in C#?

Eine detaillierte Erklärung der C#-Objekteigenschaften

In Szenarien wie Unit-Tests oder Datenüberprüfung ist es sehr häufig erforderlich, Objekteigenschaftswerte zu vergleichen. C# bietet mehrere Methoden zum Erreichen dieser Funktionalität, jede mit ihren eigenen Vor- und Nachteilen.

Methode 1: Reflexion nutzen

Der Reflexionsmechanismus ermöglicht die dynamische Überprüfung der Eigenschaften von Objekten und den Vergleich ihrer Werte. Hier ist eine reflexionsbasierte Vergleichsmethode:

<code class="language-csharp">public bool PropertiesEqual(object comparisonObject)
{
    Type sourceType = this.GetType();
    Type destinationType = comparisonObject.GetType();

    if (sourceType == destinationType)
    {
        PropertyInfo[] sourceProperties = sourceType.GetProperties();
        foreach (PropertyInfo pi in sourceProperties)
        {
            if ((sourceType.GetProperty(pi.Name).GetValue(this, null) == null && destinationType.GetProperty(pi.Name).GetValue(comparisonObject, null) == null))
            {
                // 两个属性都为 null，无需比较
            }
            else if (!(sourceType.GetProperty(pi.Name).GetValue(this, null).ToString() == destinationType.GetProperty(pi.Name).GetValue(comparisonObject, null).ToString()))
            {
                // 只要一个属性值不同，则返回 false
                return false;
            }
        }
    }
    else
    {
        throw new ArgumentException("比较对象必须为同一类型。", "comparisonObject");
    }

    return true;
}</code>

Methode 2: Verwendung von Generika und LINQ

Generika und LINQ bieten eine einfachere Vergleichsmethode:

<code class="language-csharp">public static bool PublicInstancePropertiesEqual<T>(T self, T to, params string[] ignore) where T : class
{
    if (self != null && to != null)
    {
        Type type = typeof(T);
        List<string> ignoreList = new List<string>(ignore);
        var unequalProperties =
            from pi in type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
            where !ignoreList.Contains(pi.Name) && pi.GetUnderlyingType().IsSimpleType() && pi.GetIndexParameters().Length == 0
            let selfValue = type.GetProperty(pi.Name).GetValue(self, null)
            let toValue = type.GetProperty(pi.Name).GetValue(to, null)
            where selfValue != toValue && (selfValue == null || !selfValue.Equals(toValue))
            select selfValue;
        return !unequalProperties.Any();
    }
    return self == to;
}

public static class TypeExtensions
{
    public static bool IsSimpleType(this Type type)
    {
        return
            type.IsValueType ||
            type.IsPrimitive ||
            new[]
            {
                typeof(String),
                typeof(Decimal),
                typeof(DateTime),
                typeof(DateTimeOffset),
                typeof(TimeSpan),
                typeof(Guid)
            }.Contains(type) ||
            (Convert.GetTypeCode(type) != TypeCode.Object);
    }

    public static Type GetUnderlyingType(this MemberInfo member)
    {
        switch (member.MemberType)
        {
            case MemberTypes.Event:
                return ((EventInfo)member).EventHandlerType;
            case MemberTypes.Field:
                return ((FieldInfo)member).FieldType;
            case MemberTypes.Method:
                return ((MethodInfo)member).ReturnType;
            case MemberTypes.Property:
                return ((PropertyInfo)member).PropertyType;
            default:
                throw new ArgumentException("输入的 MemberInfo 必须是 EventInfo、FieldInfo、MethodInfo 或 PropertyInfo 类型");
        }
    }
}</code>

Notizen

• Leistung: Reflexion ist weniger leistungsfähig als der direkte Zugriff auf Eigenschaften.
• Typsicherheit: Generische Methoden gewährleisten Typsicherheit und reduzieren Fehler.
• Erweiterbarkeit: Erweiterungsmethoden erleichtern die Integration in anderen Code.
• Einschränkungen:Beide Methoden verarbeiten möglicherweise keine Eigenschaften, die komplexe Objekte oder Zirkelverweise enthalten.

Zusammenfassung

Die Auswahl der Methode hängt von den spezifischen Anforderungen ab. Für Szenarien mit hohen Leistungsanforderungen wird empfohlen, direkt auf Eigenschaften zuzugreifen. Für Szenarien, die Typsicherheit und Skalierbarkeit erfordern, ist die generische LINQ-Methode besser geeignet.

Das obige ist der detaillierte Inhalt vonWie vergleiche ich Objekteigenschaften in C#?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!