C#

public abstract class DBSynchronizer<T> : IDBSynchronizer
        where T : GCSC.Interface.IEditableObject
    {
        protected EditableObjectEventHandler onEditableObjectRaised;
        protected EditableList<T> referencedItem;
        protected bool hasNewItems, hasModifiedItems, hasRemovedItems;
        protected List<int> idsNew, idsOld;
        protected EditableList<T> tempSourceType;
        protected StringBuilder tempSB;
        protected MySQLSelect tempMySQLSelect;

        Timer Ticker;
        int track, defaultIterationBeforeSleep, cycle;
        bool isTickerStarted;
        int kickStarter;

        public DBSynchronizer(ref EditableList<T> itemCollection)
        {
            referencedItem = itemCollection;
            IsInitialized = referencedItem.Count < 1 ? false : true;
            IterationBeforeSleep = 5;
            MaxSleepTime = 60000;
            Interval = 1000;
        }

        protected virtual void CollectNewItems(string query)
        {
            tempMySQLSelect = new MySQLSelect(query);
            if (tempMySQLSelect.RowCount < 1)
            {
                hasNewItems = false;
                return;
            }
            hasNewItems = true;
            tempSourceType = new EditableList<T>(tempMySQLSelect.Reader());
            tempMySQLSelect.Clear();
            foreach (var ni in tempSourceType)
                referencedItem.Add(ni);
            tempSourceType = null;
        }

        public virtual void ForceCollectNewItem()
        {
            CollectNewItems(NewItemQuery);
        }

        protected abstract void CollectModifiedItems();
        protected abstract void CollectRemovedItems();
        public abstract void NotifyAllSubscriber();
        private void Ticker_Tick(object sender, EventArgs e)
        {
            if (referencedItem.Count > 0)
            {
                CollectRemovedItems();
                CollectModifiedItems();
            }
            CollectNewItems(NewItemQuery);
            //some long line of code for timing
        }

        protected virtual void Initialize()
        {
            if (isTickerStarted)
                return;
            defaultIterationBeforeSleep = IterationBeforeSleep;
            IsInitialized = true;
            isTickerStarted = true;
            Ticker = new Timer() { Interval = Interval, Enabled = true };
            Ticker.Tick += Ticker_Tick;
            Ticker.Start();
        }

        public virtual void ForceAwake()
        {
            if (!isTickerStarted)
                return;
            if (Ticker != null)
                if (Ticker.Interval == Interval)
                    return;
            Ticker.Dispose();
            Ticker = new Timer() { Interval = Interval, Enabled = true };
            Ticker.Tick += Ticker_Tick;
            Ticker.Start();
        }

        public virtual void Shutdown()
        {
            if (Ticker == null) return;
            Ticker.Dispose();
        }

        protected virtual int Timing()
        {
            if (MaxSleepTime < 1000) throw new ArgumentException("MaxSleepTime must not be less than or equal 1000", "MaxSleepTime");
            return new RandomNumber(1000, MaxSleepTime).GetRandomNumber();
        }

        public int IterationBeforeSleep { get; set; }
        public bool IsInitialized { get; protected set; }
        public bool IsSleep { get; protected set; }
        public int Interval { get; set; }
        public int ForceShutdownAt { get; set; }
        public int MaxSleepTime { get; set; }
        protected abstract string NewItemQuery { get; }
        public event EditableObjectEventHandler EditableObjectRaised
        {
            add
            {
                Initialize();
                onEditableObjectRaised += value;
            }
            remove { onEditableObjectRaised -= value; }
        }
    }

internal sealed class SynchronizePersonClass : DBSynchronizer<PersonsClass>
    {
        static readonly object _locker = new object();

        public SynchronizePersonClass(ref EditableList<PersonsClass> itemCollection)
            : base(ref itemCollection) { }

        protected override void CollectModifiedItems()
        {
            //Some Process working fine, long lines
        }

        protected override void CollectRemovedItems()
        {
            //Some Process working fine, long lines
        }

        protected override void Initialize()
        {
            lock (_locker)
            {
                if (!IsInitialized)
                    ProcessClass<PersonsClass>.PopulateCollection(ref ClassCollections.PersonClassColletction,
                        ReadOnlyStrings.TBL_PERSON + " WHERE `is_deleted` = 0 ORDER BY `registration_date` DESC");
                base.Initialize();
            }
        }

        public override void NotifyAllSubscriber()
        {
            if (onEditableObjectRaised == null) return;
            onEditableObjectRaised(this, new EditableObjectEventArgs(referencedItem));
            referencedItem.Finalized();
        }

        protected override string NewItemQuery
        {
            get
            {
                return ReadOnlyStrings.TBL_PERSON + " WHERE `is_deleted` = 0 AND `tbl_person_id` NOT IN(" +
                    getIDCollectionString() + ") ORDER BY `registration_date` DESC";
            }
        }

        private string getIDCollectionString()
        {
            if (referencedItem.Count < 1) return "0";
            tempSB = new StringBuilder(referencedItem.Count * 2);
            foreach (var ri in referencedItem)
                tempSB.Append(ri.PersonID + ", ");
            return tempSB.Remove(tempSB.Length - 2, 2).ToString();
        }
    }

internal class Synchronizers
    {
        public static SynchronizePersonClass PersonClassSynchronizer;
    }

            ProcessClass<PersonsClass>.PopulateCollection(ref ClassCollections.PersonClassColletction, query);
// in this line if the db is not empty it will populate an items else the binding has (0)zero items on it.

Synchronizers.PersonClassSynchronizer = new SynchronizePersonClass(ref ClassCollections.PersonClassColletction);
            Synchronizers.PersonClassSynchronizer.IterationBeforeSleep = 15;
            Synchronizers.PersonClassSynchronizer.MaxSleepTime = 10000;

static void modify(ref int x)
{
    x += 10;
}
static void main()
{
    int y = 5;
    modify(ref y);
    Console.WriteLine(y);  // prints 15
}

Member 10226001 wrote:

its urgent

Member 10226001 wrote:

its urgent and important