Open window application near to notification area in c#

Open window application near to notification area in c#

    Use the below code on form load event.

  private void Form2_Load(object sender, EventArgs e)

        {

double left, right;

        TaskBarLocationProvider.CalculateWindowPositionByTaskbar(this.Width, this.Height, out left, out right);

            this.Left = Convert.ToInt16(left);

            this.Top = Convert.ToInt16(right);

        }

This is the class used to calculate the left and right coordinate for the windows application.

using System;

using System.ComponentModel;

using System.Drawing;

using System.Runtime.InteropServices;

using System.Windows.Forms;

namespace TaskManager

{

    public static class TaskBarLocationProvider

    {

        // P/Invoke goo:

        private const int ABM_GETTASKBARPOS = 5;

        [DllImport("shell32.dll")]

        private static extern IntPtr SHAppBarMessage(int msg, ref AppBarData data);

        /// <summary>

        /// Where is task bar located (at top of the screen, at bottom (default), or at the one of sides)

        /// </summary>

        private enum Dock

        {

            Left = 0,

            Top = 1,

            Right = 2,

            Bottom = 3

        }

        private struct Rect

        {

            public int Left, Top, Right, Bottom;

        }

        private struct AppBarData

        {

            public int cbSize;

            public IntPtr hWnd;

            public int uCallbackMessage;

            public Dock Dock;

            public Rect rc;

            public IntPtr lParam;

        }

        private static Rectangle GetTaskBarCoordinates(Rect rc)

        {

            return new Rectangle(rc.Left, rc.Top,

                rc.Right - rc.Left, rc.Bottom - rc.Top);

        }

        private static AppBarData GetTaskBarLocation()

        {

            var data = new AppBarData();

            data.cbSize = Marshal.SizeOf(data);

            IntPtr retval = SHAppBarMessage(ABM_GETTASKBARPOS, ref data);

            if (retval == IntPtr.Zero)

            {

                throw new Win32Exception("WinAPi Error: does'nt work api method SHAppBarMessage");

            }

            return data;

        }

        private static Screen FindScreenWithTaskBar(Rectangle taskBarCoordinates)

        {

            foreach (var screen in Screen.AllScreens)

            {

                if (screen.Bounds.Contains(taskBarCoordinates))

                {

                    return screen;

                }

            }

            return Screen.PrimaryScreen;

        }

        /// <summary>

        /// Calculate wpf window position for place it near to taskbar area

        /// </summary>

        /// <param name="windowWidth">target window height</param>

        /// <param name="windowHeight">target window width</param>

        /// <param name="left">Result left coordinate <see cref="System.Windows.Window.Left"/></param>

        /// <param name="top">Result top coordinate <see cref="System.Windows.Window.Top"/></param>

        public static void CalculateWindowPositionByTaskbar(double windowWidth, double windowHeight, out double left, out double top)

        {

            var taskBarLocation = GetTaskBarLocation();

            var taskBarRectangle = GetTaskBarCoordinates(taskBarLocation.rc);

            var screen = FindScreenWithTaskBar(taskBarRectangle);

            left = taskBarLocation.Dock == Dock.Left

                ? screen.Bounds.X + taskBarRectangle.Width

                : screen.Bounds.X + screen.WorkingArea.Width - windowWidth;

            top = taskBarLocation.Dock == Dock.Top

                ? screen.Bounds.Y + taskBarRectangle.Height

                : screen.Bounds.Y + screen.WorkingArea.Height - windowHeight;

        }

    }

}

How to get the system idle time in c# windows app?

To get idle use LASTINPUTINFO method. Here is the complete working sample code.

using System;

using System.Windows.Forms;

using System.Runtime.InteropServices;

namespace WinApp1

{

    public partial class Form3 : Form

    {

        LASTINPUTINFO lastInputInf = new LASTINPUTINFO();

        [DllImport("user32.dll")]

        public static extern bool GetLastInputInfo(ref LASTINPUTINFO plii);

        [StructLayout(LayoutKind.Sequential)]

        public struct LASTINPUTINFO

        {

            [MarshalAs(UnmanagedType.U4)]

            public int cbSize;

            [MarshalAs(UnmanagedType.U4)]

            public int dwTime;

        }

        public Form3()

        {

            InitializeComponent();

        }

        private void Form3_Load(object sender, EventArgs e)

        {

            Timer dt = new Timer();

            dt.Tick += Timer_Tick;

            dt.Interval = 1000;

            dt.Start();

        }

      

        public void Timer_Tick(object sender, EventArgs e)

        {

            DisplayIdleTime();

        }

        public int GetIdleTime()

        {

            int idletime = 0;

            idletime = 0;

            lastInputInf.cbSize = Marshal.SizeOf(lastInputInf);

            lastInputInf.dwTime = 0;

            if (GetLastInputInfo(ref lastInputInf))

            {

                idletime = Environment.TickCount - lastInputInf.dwTime;

            }

            if (idletime != 0)

            {

                return idletime / 1000;

            }

            else

            {

                return 0;

            }

        }

        private void DisplayIdleTime()

        {

     

                label1.Text = "Idle time = " + " " + GetIdleTime().ToString() + " " + "seconds";

        }

    }

}

What is type safety in C# .net

What is type safety in C# .net

When reading about advantages of using generics, you will come to know you can write type safe collections and these are the collections which avoids boxing and un boxing.

After reading such statements if you are getting questions on type safety, then you are in the right place to understand about type safety concept.

What is type safety in .net?

Type safety prevents assigning a type to another type when are not compatible.

public class Employee{}

public class Student{}

In the above example, Employee and Student are two incompatible types. We cannot assign object of employee class to Student class variable. If you try doing so, you will get a error during the compilation process.  

Cannot implicitly convert type 'Program.Employee' to 'Program.Student'.

As this type safety check happens at compile time it's called static type checking.

public class Employee {}
public class Engineer : Employee {}
public class Accountant : Employee {}

public static void Main(string[] args)
  {
   Accountant accountant = new Accountant();
   Engineer engineer = (Engineer)(accountant as Employee);
  }

In the above example, Engineer and Accountant class derives from the same Employee base class. When tried to type cast object of Accountant class to Engineer class variable, it throws System.InvalidCastException at runtime:

Unable to cast object of type 'Accountant' to type 'Engineer'.

Above type checking happens at runtime, hence it is called runtime type checking.

When does the type safety check happens and who ensures the type safety in .net?

As discussed type safety check happens both at Compile time and at run time. Compiler will do the compile time type safety check and CLR will do the runtime safety check.

How type safety checks makes developers life easy?

The advantages type safety are pretty straight forward.

At compile time, we get an error when a type instance is being assigned to an incompatible type; hence preventing an error at run time. So at compilation time itself, developers come to know such errors and code will be modified to correct the mistake. So developers get more confidence in their code.

Run time type safety ensures, we don't get strange memory exceptions and inconsistent behavior in the application.

Delegates in C#/Asp.Net and when and where to use delegates

Delegates

A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked.

Declaration

public delegate type_of_delegate delegate_name()

Example:

public delegate int mydelegate(int delvar1,int delvar2)

Note

· You can use delegates without parameters or with parameter list

· You should follow the same syntax as in the method 
(If you are referring to the method with two int parameters and int return type, the delegate which you are declaring should be in the same format. This is why it is referred to as type safe function pointer.)

Sample Program using Delegate

public delegate double Delegate_Prod(int a,int b);

class Class1

{

    static double fn_Prodvalues(int val1,int val2)

    {

        return val1*val2;

    }

    static void Main(string[] args)

    {

        //Creating the Delegate Instance

        Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues);

        Console.Write("Please Enter Values");

        int v1 = Int32.Parse(Console.ReadLine());

        int v2 = Int32.Parse(Console.ReadLine());

        //use a delegate for processing

        double res = delObj(v1,v2);

        Console.WriteLine ("Result :"+res);

        Console.ReadLine();

    }

}

Explanation

Here I have used a small program which demonstrates the use of delegate.

The delegate "Delegate_Prod" is declared with double return type and accepts only two integer parameters.

Inside the class, the method named fn_Prodvalues is defined with double return type and two integer parameters. (The delegate and method have the same signature and parameter type.)

Inside the Main method, the delegate instance is created and the function name is passed to the delegate instance as follows:

Delegate_Prod delObj = new Delegate_Prod(fn_Prodvalues);

After this, we are accepting the two values from the user and passing those values to the delegate as we do using method:

delObj(v1,v2);

Here delegate object encapsulates the method functionalities and returns the result as we specified in the method.

Multicast Delegate

What is Multicast Delegate?

It is a delegate which holds the reference of more than one method.

Multicast delegates must contain only methods that return void, else there is a run-time exception.

Simple Program using Multicast Delegate

delegate void Delegate_Multicast(int x, int y);

Class Class2

{

    static void Method1(int x, int y)

    {

        Console.WriteLine("You r in Method 1");

    }

    static void Method2(int x, int y)

    {

        Console.WriteLine("You r in Method 2");

    }

    public static void Main()

    {

        Delegate_Multicast func = new Delegate_Multicast(Method1);

        func += new Delegate_Multicast(Method2);

        func(1,2);             // Method1 and Method2 are called

        func -= new Delegate_Multicast(Method1);

        func(2,3);             // Only Method2 is called

    }

}

Explanation

In the above example, you can see that two methods are defined named method1 and method2 which take two integer parameters and return type as void.

In the main method, the Delegate object is created using the following statement:

Delegate_Multicast func = new Delegate_Multicast(Method1);

Then the Delegate is added using the += operator and removed using the -= operator.

when & why to use delegates

l An eventing design pattern is used.

l It is desirable to encapsulate a static method.

l The caller has no need to access other properties, methods, or interfaces on the object implementing the method.

l Easy composition is desired.

l A class may need more than one implementation of the method.

l We can use delegates whenever we need to pass methods as parameters to another functions so that they an be executed at runtime from there