I'm creating a long sync process for an app and I don't want to forget something. For each table I have to follow the same procedure but different parameters.

It's a long and boring work. For this reason I should have a constraint in the base class that it forces me to implement some functions.

First of all I defined my base class with all common function and the implementation of INotifyPropertyChanged

Base class with T and INotifyPropertyChanged

    public abstract class BaseSyncClass : INotifyPropertyChanged where T : SyncResultBase {
        private readonly ISyncData _syncData;

        public BaseSyncClass(ISyncData syncData) {
            _syncData = syncData;
        }

        public abstract string UpdateRecordFromTable(T sync);
        public abstract string UpdateRecordFromTableNoSyncId(List sync);

        public void UpdateFromServer(List result) {
            foreach (T sync in result) {
                UpdateRecordFromTable(sync);
            }
        }
    }

Then when I create a new class base on the above, I can have all method to implement

Example of implementation

    public class ListingConditionTableSync : BaseSyncClass {
        public ListingConditionTableSync(ISyncData syncData) : base(syncData) {
        }

        public override string UpdateRecordFromTable(SyncResultCondition sync) {
            throw new NotImplementedException();
        }

        public override string UpdateRecordFromTableNoSyncId(List sync) {
            throw new NotImplementedException();
        }
    }

What do you think? Is it an elegant and useful solution?