using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Collections.ObjectModel;

using System.ComponentModel;

using System.Runtime.CompilerServices;

using System.Threading;

using System.Threading.Tasks;

public class Program

{

    public static void Main()

    {

        //linqquery();

        //MyWhere();

        //MyWhereNot();

        //CollectionForDictionary();

        //linkedListExample();

        //genericstack();

        //NotifyProperty();

        runTaskAtEnterval();

        //Console.WriteLine("Hello World");

    }

    public static void  linqquery()

    {

        int[] lstdata = Enumerable.Range(1,100).ToArray();

            //List<int> lstdata= new List<int>();

        //for(int i=1;i<=100;i++)

        //{

        //  lstdata.Add(i);

        //}

        var querydata= lstdata.Where(s=>s%3==0);

        foreach(int i in querydata)

        {

        Console.Write(i.ToString()+ " ");

        }

        Console.Write("\n\n");

    }

    public static void  MyWhere()

    {

            List<int> lstdata= new List<int>();

        for(int i=1;i<=100;i++)

        {

            lstdata.Add(i);

        }

        var querydata= lstdata.MyWhere(s=>s%3==0);

        foreach(int i in querydata)

        {

        Console.Write(i.ToString()+ " ");

        }

        Console.Write("\n\n");

    }

    public static void  MyWhereNot()

    {

            List<int> lstdata= new List<int>();

        for(int i=1;i<=100;i++)

        {

            lstdata.Add(i);

        }

        var querydata= lstdata.MyWhereNot(s=>s%2!=0);

        foreach(int i in querydata)

        {

        Console.Write(i.ToString()+ " ");

        }

        Console.Write("\n\n");

    }

    public static void  CollectionForDictionary()

    {

            Dictionary<int,string> lstdata= new Dictionary<int,String>();

        for(int i=1;i<=100;i++)

        {

            lstdata.Add(i,i.ToString());

        }

        var querydata= lstdata.MyWhere(s=>s.Key%3==0);

        foreach(KeyValuePair<int,string> i in querydata)

        {

        Console.Write(i.Key.ToString()+ " ");

        }

        Console.Write("\n\n");

    }

    public static void  linkedListExample()

    {

        CustomLinkedList<int> l1 = new CustomLinkedList<int>();

        l1.data=1;

        CustomLinkedList<int> l2 = new CustomLinkedList<int>();

        l2.data=2;

        CustomLinkedList<int> l3 = new CustomLinkedList<int>();

        l3.data=3;

        CustomLinkedList<int> l4 = new CustomLinkedList<int>();

        l4.data=4;

        l1.next=l2;

        l2.next=l3;

        l2.previous=l1;

        l3.next=l4;

        l3.previous=l2;

        l4.previous=l3;

        CustomLinkedList<int> basenode=l3;

        while(basenode!=null)

        {

            Console.Write(basenode.data.ToString()+ " ");

            basenode=basenode.next;

        }

        Console.Write("\n\n");

        basenode=l3;

        while(basenode!=null)

        {

            Console.Write(basenode.data.ToString()+ " ");

            basenode=basenode.previous;

        }

        Console.Write("\n\n");

    }

    public static void  genericstack()

    {

        CustomStack<int> stack=new CustomStack<int>(2);

        try{

        stack.Push(1);

        stack.Push(2);  

        Console.WriteLine(stack.Pop());

        }

        catch(Exception ex)

        {

        Console.WriteLine(ex.Message);

        }

    }

    public static void NotifyProperty()

    {

        Person person = new Person();

        person.PropertyChanged+=PropertyEventHandler;

        person.Name="sunil";

    }

    public static void PropertyEventHandler(Object source, PropertyChangedEventArgs args)

    {

        Console.WriteLine(args.PropertyName);

    }

    public static async void runTaskAtEnterval()

    {

        Console.WriteLine("runTaskAtEnterval start...");

        Thread.Sleep(1000);  // Check Exeute at right bottom of window

        //await Task.Delay(1000);

        ExecuteTask();

        Console.WriteLine("runTaskAtEnterval End...");

    }

    public static void ExecuteTask()

    {

        Console.WriteLine("ExecuteTask");

    }

}

​

public class Person : INotifyPropertyChanged 

{

    private string _name;

    private string _lastName;

    public string Name

    {

    get{

        return _name;

        }

    set{

            _name=value;

            NotifyPropertyChange();

        }

    }

    public string LastName

    {

    get{

        return _lastName;

        }

    set{

            _lastName=value;

            NotifyPropertyChange();

        }

    }

    public event PropertyChangedEventHandler PropertyChanged;

    protected void NotifyPropertyChange([CallerMemberName]string PropertyName="")

    {

        if(PropertyChanged!=null)

        PropertyChanged(this, new PropertyChangedEventArgs(PropertyName));

    }

}

​

​

public class CustomStack<T>

{

        private int _size;

        T[] datastack =null;

        public CustomStack():this(100)

        {

        }

        public CustomStack(int size)

        {

            _size=size;

             datastack = new T[_size];

        }

        int pointer=-1;

        public void Push(T data)

        {

            if(pointer==_size-1)

                throw new StackOverflowException("Over flow");

            datastack[++pointer]=data;

        }

        public T Pop()

        {

            if(pointer==-1)

                throw new InsufficientExecutionStackException("Under flow");

            return datastack[pointer--];

        }

}

​

public class CustomLinkedList<T>

{

    public CustomLinkedList<T> previous;

    public T data;

    public CustomLinkedList<T> next;

}

​

public static class Extension

{

    public static ICollection<T> MyWhere<T>(this ICollection<T> source, Predicate<T> predicate)

    {

        ICollection<T> collection= new Collection<T>();

        if(source!=null)

        {

            foreach(T data in source)

            if(!predicate(data))

               collection.Add(data);

        }

        return collection;

    }

    public static ICollection<T> MyWhereNot<T>(this ICollection<T> source, Predicate<T> predicate)

    {

        ICollection<T> collection= new Collection<T>();

        if(source!=null)

        {

            foreach(T data in source)

            if(!predicate(data))

               collection.Add(data);

        }

        return collection;

    }

}