Thursday, July 28, 2011

Need Marketing Executive

Golden Opportunity for freshers.....

A company need a person who must have good communication skills and good links in engineering  colleges.
if any body has both qualities then he will get good package as well as good designation.it is golden opportunity.
freshers can also apply.first preference will be given to Freshers..

Eligibility: Graduate or Post Graduate
Work Place: New Delhi

For Further Details:Contact on gulshan.arora.1986@gmail.com

Wednesday, July 27, 2011

delegates and events ...


//check  which key is pressed nice program...check this out............... 


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace delegates_and_events
{
    // This example demonstrates:
    // the Console.CancelKeyPress event,
    // the ConsoleCancelEventHandler delegate,
    // the ConsoleCancelEventArgs.SpecialKey property, and
    // the ConsoleCancelEventArgs.Cancel property.

 

    class Sample
    {
        public static void Main()
        {
            ConsoleKeyInfo cki;

            // Clear the screen.
            Console.Clear();

            // Turn off the default system behavior when CTRL+C is pressed. When
            // Console.TreatControlCAsInput is false, CTRL+C is treated as an
            // interrupt instead of as input.
            Console.TreatControlCAsInput = false;

            // Establish an event handler to process key press events.
            Console.CancelKeyPress += new ConsoleCancelEventHandler(myHandler);
            while (true)
            {
                // Prompt the user.
                Console.Write("Press any key, or 'X' to quit, or ");
                Console.WriteLine("CTRL+C to interrupt the read operation:");

                // Start a console read operation. Do not display the input.
                cki = Console.ReadKey(true);

                // Announce the name of the key that was pressed .
                Console.WriteLine("  Key pressed: {0}\n", cki.Key);

                // Exit if the user pressed the 'X' key.
                if (cki.Key == ConsoleKey.X) break;
            }
        }

        /*
           When you press CTRL+C, the read operation is interrupted and the
           console cancel event handler, myHandler, is invoked. Upon entry
           to the event handler, the Cancel property is false, which means
           the current process will terminate when the event handler terminates.
           However, the event handler sets the Cancel property to true, which
           means the process will not terminate and the read operation will resume.
        */
        protected static void myHandler(object sender, ConsoleCancelEventArgs args)
        {
            // Announce that the event handler has been invoked.
            Console.WriteLine("\nThe read operation has been interrupted.");

            // Announce which key combination was pressed.
            Console.WriteLine("  Key pressed: {0}", args.SpecialKey);

            // Announce the initial value of the Cancel property.
            Console.WriteLine("  Cancel property: {0}", args.Cancel);

            // Set the Cancel property to true to prevent the process from terminating.
            Console.WriteLine("Setting the Cancel property to true...");
            args.Cancel = true;

            // Announce the new value of the Cancel property.
            Console.WriteLine("  Cancel property: {0}", args.Cancel);
            Console.WriteLine("The read operation will resume...\n");
        }
    }
    /*
    This code example produces results similar to the following text:

    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
      Key pressed: J

    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
      Key pressed: Enter

    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:

    The read operation has been interrupted.
      Key pressed: ControlC
      Cancel property: False
    Setting the Cancel property to true...
      Cancel property: True
    The read operation will resume...

      Key pressed: Q

    Press any key, or 'X' to quit, or CTRL+C to interrupt the read operation:
      Key pressed: X

    */
}

Event handling in c#


Instead, you will need to write your own timer object using multi-threading in C#. In this article I describe just how to write your own Timer for your Console Application.




First you need to build your own timer class object. To start, we can do something like this:
    class Timer
    {
        // Delegates
        public delegate void Tick();

        // Properties
        public int Interval;
        public Tick OnTimerTick;

        // Private Data
        Thread _timerThread;
        volatile bool _bStop;
    }

Next you want to implement an event loop for the timer. This code will run on the timer's thread, not the main thread. Here is how you'd write one:

    public void Run()
    {
        while (!_bStop)
        {
            // Sleep for the timer interval
            Thread.Sleep(Interval);
            // Then fire the tick event
            OnTimerTick();
        }   
    }

A Timer has a Start & Stop methods. These methods run on the main thread, and control the timer's operation. The above timer event loop however runs on a separate worker thread, which is created in the Start method implementation as follows:

    public Thread Start()
    {
        _bStop = false;
        _timerThread = newThread(newThreadStart(Run));
        _timerThread.IsBackground = true;
        _timerThread.Start();
        return _timerThread;
    }
Now to stop the Timer, we'll need to set the volatile boolean in the Timer data members to false. The Stop Method is invoked from the main thread. The value of the volatile member is then checked each time in the event loop of the worker thread (as seen above). Here is how to implement the Stop method for the timer:
    public void Stop()
    {
        // Request the loop to stop
        _bStop=true;
    }
Notice that the stop method would only put a request to stop the timer, but won't kill the thread. If the timer interval is short, that isn't much of a problem, but if the timer interval is long, say 5 minutes, it might take the whole 5 minutes before the timer checks the above volatile member and decides to stop the event loop. To fix this, there are 2 options, first is to simply kill the worker thread in the Stop implementation (remember the Stop method is invoked on the main thread), as follows:
    public void Stop()
    {
        // Request the loop to stop
        _bStop=true;
        _timerThread.Join(1000);
          _timerThread.Abort();
    }
A better way however is to sleep intermittently in the event loop and check the volatile member more frequently:
    public void Run()
    {
        while (true)
        {
            // Sleep for the timer interval
            SleepIntermittently(Interval);
            // Then fire the tick event
            OnTimerTick();
        }
    }
Now you can just implement the Stop method as before. Here is the implementation of the SleepIntermittently method:
    public void SleepIntermittently(int totalTime)
    {
        int sleptTime = 0;
        int intermittentSleepIncrement = 10;
        while (!_bStop && sleptTime < totalTime)
        {
            Thread.Sleep(intermittentSleepIncrement);
            sleptTime += intermittentSleepIncrement;
        }
    }
Finally here is a test application for our Console timer:
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace TimerConsoleApp
{
    class Program
    {
        public static void timerTick()
        {
            Console.WriteLine("[W] Timer Ticked!");
        }

        static void Main (string[] args)
        {
            Timer timer = newTimer();
            timer.Interval=500;
            timer.OnTimerTick += timerTick;
            Thread timerThread = timer.Start();

            for (int i = 0; i < 10; i++)
            {
                if (i > 5)
                {
                    Console.WriteLine("[M] Timer is Stopped! " +DateTime.Now.ToLongTimeString());
                }
                 else
                {
                    Console.WriteLine("[M] Timer is Active! " +DateTime.Now.ToLongTimeString());
                }

                if (i == 5)
                {
                    Console.WriteLine("[M] Stopping the timer...");
                    timer.Stop();
                }

                // Do lengthy main thread processing here
                ///
                Thread.Sleep(5000);
            }
        }
    }
}
And now the timer is ready for use.
Happy Programming!

AngularJS Basics - Part 1

                                                                  AngularJS What is AngularJS ·          Framework by googl...