C#에서 개체 속성을 비교하는 방법은 무엇입니까?

C# 객체 속성에 대한 자세한 설명

단위 테스트나 데이터 검증과 같은 시나리오에서는 객체 속성 값을 비교해야 하는 경우가 매우 일반적입니다. C#은 이 기능을 달성하기 위한 여러 가지 방법을 제공하며 각 방법에는 장단점이 있습니다.

방법 1: 리플렉션 사용

반사 메커니즘을 통해 객체의 속성을 동적으로 검사하고 해당 값을 비교할 수 있습니다. 반영 기반 비교 방법은 다음과 같습니다.

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;
}

방법 2: 제네릭 및 LINQ 사용

Generics와 LINQ는 더 간단한 비교 방법을 제공합니다.

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 类型");
        }
    }
}

메모

• 성능: 리플렉션은 속성에 직접 액세스하는 것보다 성능이 떨어집니다.
• 유형 안전성: 일반 메소드는 유형 안전성을 보장하고 오류를 줄입니다.
• 확장성: 확장 메서드는 다른 코드와의 통합을 용이하게 합니다.
• 제한 사항: 두 방법 모두 복잡한 개체나 순환 참조가 포함된 속성을 처리하지 못할 수 있습니다.

요약

방법 선택은 특정 요구 사항에 따라 다릅니다. 고성능 요구 사항이 있는 시나리오의 경우 형식 안전성과 확장성이 필요한 시나리오의 경우 속성에 직접 액세스하는 것이 좋습니다. 일반 LINQ 방법이 더 적합합니다.

위 내용은 C#에서 개체 속성을 비교하는 방법은 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!