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

```