如何将具有相同主体但不同签名的方法合并在一起？

Question

This is a refactoring question.

How to merge all these Check() methods into one single Generic Check() method since their method bodies are the same?

ppublic class ChangeDetector : IChangeDetector
{
    private readonly IEqualityHelper _equalityHelper;

    public ChangeDetector(IEqualityHelper equalityHelper)
    {
        _equalityHelper = equalityHelper;
    }

    public bool ChangeDetected { get; private set; }

    public void Check<T>(IList<T> existingList, IList<T> newList) where T : IdentifiedActiveRecordBase<T>, new ()
    {
        if (!this._equalityHelper.Equals(existingList, newList))
        {
            NotifyChange();
        }
    }

    public void CheckEntities<T>(IdentifiedActiveRecordBase<T> existingObj, IdentifiedActiveRecordBase<T> newObj) where T : IdentifiedActiveRecordBase<T>, new()
    {
        if (!this._equalityHelper.Equals(existingObj, newObj))
        {
            NotifyChange();
        }
    }

    public void Check(string existing, string newVal)
    {
        if (!this._equalityHelper.Equals(existing, newVal))
        {
            NotifyChange();
        }
    }

    public void Check<T>(T existing, T newVal) where T : struct 
    {
        if (!this._equalityHelper.Equals(existing, newVal))
        {
            NotifyChange();
        }
    }

    public void Check<T>(T? existing, T? newVal) where T : struct 
    {
        if (!this._equalityHelper.Equals(existing, newVal))
        {
            NotifyChange();
        }
    }

    private void NotifyChange()
    {
        ChangeDetected = true;
    }
}

My EqualityHelper class members have different body though which is fine:

public class EqualityHelper : IEqualityHelper
    {
        public bool Equals<T>(IList<T> existingList, IList<T> newList) where T : IdentifiedActiveRecordBase<T>, new()
        {
            if (existingList == null || existingList.Count == 0)
            {
                if (newList != null && newList.Count > 0)
                {
                    return false;
                }
            }
            else
            {
                if (newList == null
                    || existingList.Count != newList.Count
                    || newList.Any(newListItem => existingList.Any(existingListItem => existingListItem.Id == newListItem.Id)))
                {
                    return false;
                }
            }

            return true;
        }

        public bool Equals<T>(IdentifiedActiveRecordBase<T> existingObj, IdentifiedActiveRecordBase<T> newObj) where T : IdentifiedActiveRecordBase<T>, new()
        {
            if (existingObj == null)
            {
                if (newObj != null)
                {
                    return false;
                }
            }
            else
            {
                if (newObj == null || existingObj.Id != newObj.Id)
                {
                    return false;
                }
            }

            return true;
        }

        public bool Equals(string existing, string newVal)
        {
            return string.Equals(existing, newVal);
        }

        public bool Equals<T>(T existing, T newVal) where T : struct
        {
            return !existing.Equals(newVal);
        }

        public bool Equals<T>(T? existing, T? newVal) where T : struct
        {
            if ((existing.HasValue && !newVal.HasValue)
                || (!existing.HasValue && newVal.HasValue)
                || existing.Equals(newVal))
            {
                return false;
            }

            return true;
        }
    }

Answer 1

Just because the method bodies are looking similar doesn't mean the method signatures can be merged. Each of your five Handle methods calls five different Equals -methods, so unless you can merge the five Equals methods, you can't merge the Handle methods. You can't do that of course because the Equals method implementations are different. Remember that which of the Equals-method are to be called is decided compile-time, not runtime.

Edit: What you could do is change the signature of both Handle/Check and Equals to Check(object existing, object equals) and Equals(object existing, object equals) . Then in the Equals -method perform a runtime type-check which results in a switch-case to the five Equals-method you already have with the help of type casting. This would make the implementation slower and only arguably more maintainable. I'm not sure I would go down that route.

Answer 2

The method bodies aren't really the same, since they're all calling different Equals() methods. What you're intending to do would (if I understand the question correctly) finish up with one Handle<T>() method where T could be any type. Thinking about what you're trying to express in the code, it seems fair that if you have one Handle<T>() method, that ought to be able to call one Equals<T>() method. That way, you can implement your handling logic once (and potentially this becomes more complex later but you only need to write it once) and you delegate the tricky business of comparing objects to your equality comparer class.