IT Mania

Hook windows keyboard - Capture keypress without focus in C#

2012-03-06T10:57:00.000+05:30

Here is a class which hooks windows keyboard to capture all keypress events even if your C# application is not focused.

    /// 
    /// Capture any window key
    /// 
    public static class WinKeyCapture
    {
        private const int WH_KEYBOARD_LL = 13;
        private const int WM_KEYDOWN = 0x0100;
        private static LowLevelKeyboardProc _proc = HookCallback;

        public static void SetHook()
        {
            SetHook(_proc);
        }

        public static void UnHook()
        {
            UnhookWindowsHookEx(_hookID);
        }

        private static IntPtr SetHook(LowLevelKeyboardProc proc)
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {
                return SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0);
            }
        }
        private static IntPtr _hookID = IntPtr.Zero;

        private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);

        private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {
            if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
            {
                int vkCode = Marshal.ReadInt32(lParam);
                if (vkCode == 44)
                    ScreenCapture.Load();
            }
            return CallNextHookEx(_hookID, nCode, wParam, lParam);
        }

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook,
            LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool UnhookWindowsHookEx(IntPtr hhk);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
            IntPtr wParam, IntPtr lParam);

        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);
    }

8 things your webcam can do, that you dont know

2011-12-21T15:24:00.000+05:30

HOME SECURITY SYSTEM

THERE ARE PLENTY of free programs you can use to turn a webcam into a remote security system. Simply install Yawcam (Windows only) from www.yawcam. com or Vitamin D (Windows and MAC) from www. vitamindinc.com. Both are free and once installed, you can configure them to live stream video and monitor the feed remotely. The software can also be set to alert you or start recording when motion is detected in the frame of view — this is great because you obviously cannot monitor the feed from the camera all the time. For general surveillance, you can setup the software to take snapshots at set intervals and upload them to a remote FTP server. For Linux users, Motion (www.lavrsen.dk) does the same thing.

FUN & GAMING

A WEBCAM can literally put you into the action while playing a game. At www.newgrounds. com, you will find a collection of short, quick online games and Adobe Flash applets that use your webcam. Just head to the games section and webcam games subsection on the website. You will need to allow Flash Player to access your webcam when it prompts you — this has to be done for each game. There are plenty of games available on the site that you can play using your webcam and each of them has a different theme. Our favourites are the 3D Target Shooting (the game uses the webcam to detect your location and displays a 3D effect, relative to your position), Night of the Ninja (fend off angry ninjas by hitting them), Bunny Zap (zap bunnies before they hit the ground) and Dress Up Yourself (add spectacles, thought/speech bubbles, facial hair, accessories to your face).

LOGIN VIA FACE RECOGNITION

SOME COMPUTERS may have this feature built in, but if you have a PC running Windows and a webcam, you can enable login via face recognition easily. Head to www. luxand.com/blink or http://bananascreen.en.softonic.com and download the free software. In the initial configuration register your face with the software and set an auto-lock for Windows. Once active, the software will recognise your face and automatically log you in to Windows without the need for a password. Since the software recognises certain points on your face, it doesn’t matter if you have a different hairstyle or if you’re wearing spectacles one day. There is an easy way to break in though – if anyone just holds up a photo of yours to the webcam, the software may log in because it can’t recognise 2D or 3D shapes.

OPTICAL CHARACTER RECOGNITION

OCR OR Optical character recognition using a webcam is a bit tricky as the image quality of most webcams is average. However, your webcam can double up as an OCR reader in a pinch. You can take an image using the webcam and then use software like Microsoft Document imaging, Google Docs and Abbyy FineReader Online to convert images to text. You can also try Evernote (free from www.evernote. com). Evernote is recommended software for OCR since it reads the image from the webcam and converts it into searchable text in real-time. You can use it to save notes, book pages, reports and business cards. Accuracy of converted text varies between 70-90% depending on the image quality and software used for OCR conversion.

PHOTOS WITH FUNNY EFFECTS

IF YOU go to www.cameroid.com, you can use any webcam to take funny photos — either with various filters, distortion effects, scenes or frames. You don’t need to install anything or even sign up — just give the site permission to access your webcam through Adobe Flash when prompted. Once you take a photo, you can either save it to the Cameroid public gallery or download the JPG file to your computer. You can also try out similar effects at www.seenly.com. You can also get software to create realtime effects while you video chat with someone using Skype or Google Talk. Videoskin.net offers some freeware while www.webcammax.com and www.shiningmorning. com offer trial versions of their software with thousands of different effects.

BAR CODE READER

READING BAR codes and QR codes is easy with a smartphone and a free app. But you can do the same thing on a PC with a webcam (doesn't matter if the webcam is built in or external, although external is probably better for this purpose). Download and install bcWebCam (get it free from www.bcwebcam. de) and it will automatically connect to your webcam to show the feed. Now just place the barcode or QR code in front of the webcam, the software will take a few seconds to recognise the embedded content and show you the text/link it contains. Mac users who need similar functionality can use Evobarcode (15day trial & US$30 post that) from www.evological.com or QuickMark (US$ 3.99) from the Mac App store.

TIME LAPSE VIDEOS

TIME LAPSE is a photography technique wherein multiple photographs, taken at the same location over a period of time are stitched together to form a video. The resulting effect is of time passing by very quickly, hence the name. Free software called Tilaphos (http://sourceforge.net/ projects/tilaphos) or Webcam TimerShot (available on http:// download.cnet.com) can do this for you without hassling you with too many technical details. An external webcam is recommended for time lapse videos because it is easier to keep it still. Also, it is much easier to place it at a location from where a wider frame can be captured — larger coverage would result in capturing of more movements, which in turn will make the video look good. It’s important that the laptop (or webcam) is kept perfectly still and that it receives constant power. After that, it’s just a matter of setting the time interval and recording the time lapse.

MAKE YOUR OWN FONT

YOU CAN use your webcam to create a font from your own handwriting. This font can be used to send emails or create documents with a personal touch. Head over to www.pilothandwriting.com, download and print the template provided. Now fill out the boxes in the printed form with the corresponding alphabets — using your handwriting. Once done, use your webcam to take an image of the form and upload it to the website. After upload, the site will show you the template and you can edit it to make the alphabets look better. Next, the website will generate a font based on your handwriting and then you can download the font to your computer and use it with any software of your choice.

Sabeer Bhatia launches free SMS app Jaxtr

2011-11-23T12:26:00.001+05:30

Sabeer Bhatia, the founder of Hotmail.com, on Tuesday launched JaxtrSMS, a mobile application that lets users send unlimited free text messages to any other phone anywhere in the world.

He claimed JaxtrSMS is the world's first mobile-based application for sending SMS that is completely open as the recipients do not need to have the app installed.

It is already available as a free download for all major mobile operating systems - iOS, Android, Blackberry and J2ME. In fact, users in 197 countries have already downloaded the app within a few weeks since the soft launch, said Bhatia, who is CEO & co-founded Jaxtr with Yogesh Patel in US.

JaxtrSMS is unique in that a mobile user can send a text SMS to any mobile phone in the world without requiring the receiver to have the JaxtrSMS application installed on her phone. This "open" facet of JaxtrSMS distinguishes it from other free mobile messaging applications such as Whatsapp where messages can only be sent within a closed network to people who also have the same app installed. JaxtrSMS retains the number of the user and no new number is required while signing up for the JaxtrSMS service.

"15 years ago, we gave you Hotmail.com, the world's first webmail service that freed up e-mail from the confines of the desktop and aided the creation of a global communications network which was completely open and free for users. Today, we present JaxtrSMS which does to SMS what Hotmail did for e-mail.
Now, mobile users can leverage our free and open application to send messages to their contacts anywhere across the world without having to pay anything," said Bhatia.

"JaxtrSMS was completely developed in India. I am proud to showcase this as an example of Indian innovation and ingenuity," said Yogesh Patel, president & co-founder.

jQuery Blink Plugin

2011-08-16T16:46:00.000+05:30

I have created a plugin where you can apply blink effect on any dom object.

It can be div,span or anything.

Check out http://plugins.jquery.com/project/jqblink for more details

SQLHelper by Microsoft

2011-07-19T11:50:00.004+05:30

using System;
using System.Data;
using System.Xml;
using System.Data.SqlClient;
using System.Collections;


namespace Microsoft.ApplicationBlocks.Data
{
    public sealed class SqlHelper
    {
        #region private utility methods & constructors

        private SqlHelper() { }

        private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
        {
            foreach (SqlParameter p in commandParameters)
            {
                if ((p.Direction == ParameterDirection.InputOutput) && (p.Value == null))
                {
                    p.Value = DBNull.Value;
                }

                command.Parameters.Add(p);
            }
        }

        private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues)
        {
            if ((commandParameters == null) || (parameterValues == null))
            {
                return;
            }

            if (commandParameters.Length != parameterValues.Length)
            {
                throw new ArgumentException("Parameter count does not match Parameter Value count.");
            }

            for (int i = 0, j = commandParameters.Length; i < j; i++)
            {
                commandParameters[i].Value = parameterValues[i];
            }
        }

        private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters)
        {
            if (connection.State != ConnectionState.Open)
            {
                connection.Open();
            }

            command.Connection = connection;

            command.CommandText = commandText;

            if (transaction != null)
            {
                command.Transaction = transaction;
            }

            command.CommandType = commandType;

            if (commandParameters != null)
            {
                AttachParameters(command, commandParameters);
            }

            return;
        }


        #endregion private utility methods & constructors

        #region ExecuteNonQuery

        public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            using (SqlConnection cn = new SqlConnection(connectionString))
            {
                cn.Open();
                return ExecuteNonQuery(cn, commandType, commandText, commandParameters);
            }
        }

        public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);
        }

        public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters);

            int retval = cmd.ExecuteNonQuery();

            cmd.Parameters.Clear();
            return retval;
        }

        public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
            }
        }

        public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
        }

        public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

            int retval = cmd.ExecuteNonQuery();

            cmd.Parameters.Clear();
            return retval;
        }

        public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
            }
        }


        #endregion ExecuteNonQuery

        #region ExecuteDataSet

        public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            using (SqlConnection cn = new SqlConnection(connectionString))
            {
                cn.Open();
                return ExecuteDataset(cn, commandType, commandText, commandParameters);
            }
        }

        public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
        }

        public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters);

            SqlDataAdapter da = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();

            da.Fill(ds);

            cmd.Parameters.Clear();

            return ds;
        }

        public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
            }
        }

        public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);
        }

        public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

            SqlDataAdapter da = new SqlDataAdapter(cmd);
            DataSet ds = new DataSet();

            da.Fill(ds);

            cmd.Parameters.Clear();

            return ds;
        }

        public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteDataSet

        #region ExecuteReader

        private enum SqlConnectionOwnership
        {
            Internal,
            External
        }

        private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters);

            SqlDataReader dr;

            if (connectionOwnership == SqlConnectionOwnership.External)
            {
                dr = cmd.ExecuteReader();
            }
            else
            {
                dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }

            cmd.Parameters.Clear();

            return dr;
        }

        public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlConnection cn = new SqlConnection(connectionString);
            cn.Open();

            try
            {
                return ExecuteReader(cn, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal);
            }
            catch
            {
                cn.Close();
                throw;
            }
        }

        public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null);
        }

        public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
        }

        public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteReader(connection, CommandType.StoredProcedure, spName);
            }
        }

        public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null);
        }

        public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
        }

        public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteReader

        #region ExecuteScalar

        public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
        {
            return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null);
        }

        public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            using (SqlConnection cn = new SqlConnection(connectionString))
            {
                cn.Open();
                return ExecuteScalar(cn, commandType, commandText, commandParameters);
            }
        }

        public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
            }
        }

        public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null);
        }

        public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters);

            object retval = cmd.ExecuteScalar();

            cmd.Parameters.Clear();
            return retval;

        }

        public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
            }
        }

        public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null);
        }

        public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

            object retval = cmd.ExecuteScalar();

            cmd.Parameters.Clear();
            return retval;
        }

        public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
            }
        }

        #endregion ExecuteScalar

        #region ExecuteXmlReader

        public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText)
        {
            return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null);
        }

        public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters);

            XmlReader retval = cmd.ExecuteXmlReader();

            cmd.Parameters.Clear();
            return retval;
        }

        public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
            }
        }

        public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText)
        {
            return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null);
        }

        public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
        {
            SqlCommand cmd = new SqlCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);

            XmlReader retval = cmd.ExecuteXmlReader();

            cmd.Parameters.Clear();
            return retval;
        }

        public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues)
        {
            if ((parameterValues != null) && (parameterValues.Length > 0))
            {
                SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName);

                AssignParameterValues(commandParameters, parameterValues);

                return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
            }
            else
            {
                return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
            }
        }


        #endregion ExecuteXmlReader
    }

    public sealed class SqlHelperParameterCache
    {
        #region private methods, variables, and constructors

        private SqlHelperParameterCache() { }

        private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());

        private static SqlParameter[] DiscoverSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
        {
            using (SqlConnection cn = new SqlConnection(connectionString))
            using (SqlCommand cmd = new SqlCommand(spName, cn))
            {
                cn.Open();
                cmd.CommandType = CommandType.StoredProcedure;

                SqlCommandBuilder.DeriveParameters(cmd);

                if (!includeReturnValueParameter)
                {
                    cmd.Parameters.RemoveAt(0);
                }

                SqlParameter[] discoveredParameters = new SqlParameter[cmd.Parameters.Count]; ;

                cmd.Parameters.CopyTo(discoveredParameters, 0);

                return discoveredParameters;
            }
        }

        private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters)
        {
            SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length];

            for (int i = 0, j = originalParameters.Length; i < j; i++)
            {
                clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone();
            }

            return clonedParameters;
        }

        #endregion private methods, variables, and constructors

        #region caching functions

        public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters)
        {
            string hashKey = connectionString + ":" + commandText;

            paramCache[hashKey] = commandParameters;
        }

        public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText)
        {
            string hashKey = connectionString + ":" + commandText;

            SqlParameter[] cachedParameters = (SqlParameter[])paramCache[hashKey];

            if (cachedParameters == null)
            {
                return null;
            }
            else
            {
                return CloneParameters(cachedParameters);
            }
        }

        #endregion caching functions

        #region Parameter Discovery Functions

        public static SqlParameter[] GetSpParameterSet(string connectionString, string spName)
        {
            return GetSpParameterSet(connectionString, spName, false);
        }

        public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
        {
            string hashKey = connectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : "");

            SqlParameter[] cachedParameters;

            cachedParameters = (SqlParameter[])paramCache[hashKey];

            if (cachedParameters == null)
            {
                cachedParameters = (SqlParameter[])(paramCache[hashKey] = DiscoverSpParameterSet(connectionString, spName, includeReturnValueParameter));
            }

            return CloneParameters(cachedParameters);
        }

        #endregion Parameter Discovery Functions

    }
}

Invitation to be part of success story

2011-07-13T18:25:00.000+05:30

Dear Friends,

Hope you are doing well along with your family.

2010-11 has been an excellent year for us i.e. Prakash Software.

Apart from increased number of satisfied customers, we got “Best Innovation Company 2011 Award” from GESIA. View details

We are yet observing phenomenal growth on the road ahead and I am excited to invite you to be part of it.

I am glad to announce that as part of our growth process – we are going to hire yet more members at both our Ahmedabad & Baroda branches.

Have a look through below and follow any of contact steps to be part of our success story!

Current Openings:

1. CODE ‘201107-MOSS-SNR’: Microsoft SharePoint – Senior Developer / Tech Lead [2-5 years relevant experience] Vacancies – 1 [Ahmedabad] JOBCODE:

2. CODE ‘201107-MOSS-JNR’: Microsoft SharePoint – Junior Developer [1-2 years relevant experience] Vacancies – 2 [Baroda]

3. CODE ‘201107-BDE’: Business Development Executive [1-8 years of experience] Vacancies – 4 [Ahmedabad-2, Baroda-2]

4. CODE ‘201107-BA’: Business Analyst [1-5 years of experience] Vacancies – 1 [Ahmedabad]

Get rolling through one of below:

1. Send your latest CV to ‘cv@prakashinfotech.com ’; please ensure to write Job Code in subject for faster processing.

2. Call us at +91-9714882647

Datapager: Paging in RIA Application with MVVM

2011-04-16T14:13:00.004+05:30

PagedEntitySet

This will help creating List of Entities that can be paged.

public class PagedEntitySet : INotifyPropertyChanged, INotifyCollectionChanged, IPagedCollectionView, IEnumerable
	where T : Entity, new()
{

	#region Private Members

	private IPagedCollectionView _pagingView;

	private IEnumerable Enumerable { get { return this._entityList; } }

	private EntitySet _entityList;

	#endregion

	#region IEnumerable Members

	public IEnumerator GetEnumerator()
	{
		return this._entityList.GetEnumerator();
	}

	#endregion

	#region IEnumerable Members

	IEnumerator IEnumerable.GetEnumerator()
	{
		return this.GetEnumerator();
	}

	#endregion

	#region Constructor

	public PagedEntitySet(EntitySet entityList, IPagedCollectionView delegatePagingView)
	{
		_entityList = entityList;
		INotifyCollectionChanged collectionChanged = _entityList as INotifyCollectionChanged;
		if (collectionChanged != null)
			collectionChanged.CollectionChanged += (s, e) => CollectionChanged(this, e);
		_pagingView = delegatePagingView;
		_pagingView.PageChanging += PageChanging;
		_pagingView.PageChanged += PageChanged;
		INotifyPropertyChanged propertyChanged = _pagingView as INotifyPropertyChanged;
		if (propertyChanged != null)
			propertyChanged.PropertyChanged += (s, e) => PropertyChanged(this, e);
	}

	#endregion

	#region INotifyPropertyChanged Members

	public event PropertyChangedEventHandler PropertyChanged = delegate { };

	#endregion

	#region INotifyCollectionChanged Members

	public event NotifyCollectionChangedEventHandler CollectionChanged = delegate { };

	#endregion

	#region IPagedCollectionView Members

	public bool CanChangePage
	{
		get { return _pagingView.CanChangePage; }
	}

	public bool IsPageChanging
	{
		get { return _pagingView.IsPageChanging; }
	}

	public int ItemCount
	{
		get { return _pagingView.ItemCount; }
	}

	public bool MoveToFirstPage()
	{
		return _pagingView.MoveToFirstPage();
	}

	public bool MoveToLastPage()
	{
		return _pagingView.MoveToLastPage();
	}

	public bool MoveToNextPage()
	{
		return _pagingView.MoveToNextPage();
	}

	public bool MoveToPage(int pageIndex)
	{
		return _pagingView.MoveToPage(pageIndex);
	}

	public bool MoveToPreviousPage()
	{
		return _pagingView.MoveToPreviousPage();
	}

	public event EventHandler PageChanged = delegate { };

	public event EventHandler PageChanging = delegate { };

	public int PageIndex
	{
		get { return _pagingView.PageIndex; }
	}

	public int PageSize
	{
		get { return _pagingView.PageSize; }
		set { _pagingView.PageSize = value; }
	}

	public int TotalItemCount
	{
		get { return _pagingView.TotalItemCount; }
	}

	#endregion

}

PagedViewModelBase

This abstract class will help binding your view model to view page with paging functionality.

public abstract class PagedViewModelBase: IPagedCollectionView, INotifyPropertyChanged
{

	#region Member Properties

	private static PropertyChangedEventArgs IsPageChangingChangedEventArgs = new PropertyChangedEventArgs("IsPageChanging");

	private static PropertyChangedEventArgs ItemCountChangedEventArgs = new PropertyChangedEventArgs("ItemCount");

	private static PropertyChangedEventArgs PageIndexChangedEventArgs = new PropertyChangedEventArgs("PageIndex");

	private static PropertyChangedEventArgs PageSizeChangedEventArgs = new PropertyChangedEventArgs("PageSize");

	private static PropertyChangedEventArgs TotalItemCountChangedEventArgs = new PropertyChangedEventArgs("TotalItemCount");

	private static PropertyChangedEventArgs IsLoadingChangedEventArgs = new PropertyChangedEventArgs("IsLoading");

	private bool _isLoading;

	public bool IsLoading
	{
		get { return _isLoading; }
		set
		{
			if (_isLoading != value)
			{
				_isLoading = value;
				RaisePropertyChanged(IsLoadingChangedEventArgs);
			}
		}
	}

	#endregion

	#region Member Functions

	public abstract void LoadData();

	#endregion

	#region INotifyPropertyChanged Members

	public event PropertyChangedEventHandler PropertyChanged;

	protected void RaisePropertyChanged(PropertyChangedEventArgs args)
	{
		if (PropertyChanged != null)
			PropertyChanged(this, args);
	}

	#endregion

	#region IPagedCollectionView Members

	public bool CanChangePage
	{
		get { return true; }
	}

	bool isPageChanging;

	public bool IsPageChanging
	{
		get { return isPageChanging; }
		private set
		{
			if (isPageChanging != value)
			{
				isPageChanging = value;
				RaisePropertyChanged(IsPageChangingChangedEventArgs);
			}

		}
	}

	int itemCount;

	public int ItemCount
	{
		get { return itemCount; }
		set
		{
			if (itemCount != value)
			{
				itemCount = value;
				RaisePropertyChanged(ItemCountChangedEventArgs);
			}
		}
	}

	public bool MoveToFirstPage()
	{
		return MoveToPage(0);
	}

	public bool MoveToLastPage()
	{
		return MoveToPage(TotalItemCount / PageSize);
	}

	public bool MoveToNextPage()
	{
		return MoveToPage(PageIndex + 1);
	}

	public bool MoveToPage(int index)
	{
		if (index == PageIndex || index < 0 || index > TotalItemCount / PageSize)
		{
			return false;
		}
		PageChangingEventArgs args = new PageChangingEventArgs(index);
		try
		{
			IsPageChanging = true;
			PageChanging(this, args);
			if (!args.Cancel)
			{
				pageIndex = index;
				LoadData();
				RaisePropertyChanged(PageIndexChangedEventArgs);
				PageChanged(this, EventArgs.Empty);
				return true;
			}
			return false;
		}
		finally
		{
			IsPageChanging = false;
		}
	}

	public bool MoveToPreviousPage()
	{
		return MoveToPage(PageIndex - 1);
	}

	public event EventHandler<EventArgs> PageChanged = delegate { };

	public event EventHandler<PageChangingEventArgs> PageChanging = delegate { };

	int pageIndex;

	public int PageIndex
	{
		get { return pageIndex; }
		set
		{
			if (pageIndex < 0 || pageIndex > totalItemCount / PageSize)
			{
				throw new ArgumentOutOfRangeException("PageIndex must be greater than or equal to 0 and less than the page count");
			}
			MoveToPage(value);
		}
	}

	int pageSize = 10; //default page size to 10

	public int PageSize
	{
		get { return pageSize; }
		set
		{
			if (pageSize != value)
			{
				pageSize = value;
				RaisePropertyChanged(PageSizeChangedEventArgs);
			}
		}
	}

	int totalItemCount;

	public int TotalItemCount
	{
		get { return totalItemCount; }
		set
		{
			if (totalItemCount != value)
			{
				totalItemCount = value;
				RaisePropertyChanged(TotalItemCountChangedEventArgs);
			}
		}
	}
	
	#endregion
}

This both Class will help you to easily bind your datagrid and datapager.
Just use PagedEntitySet type for binding data in your viewmodel for both datagrid and datapager.
Use constructor to initialize data in it.

This is the easiest way I find. If you have some more smart code please share it. Hope this will save a lot of your time. Happy Coding..

Implementing RelayCommand in easiest way

2011-04-12T19:21:00.003+05:30

public class RelayCommand<T> : ICommand
{
        Action<T> _TargetExecuteMethod;

        Func<T, bool> _TargetCanExecuteMethod;

        public RelayCommand(Action<T> executeMethod)
        {
            _TargetExecuteMethod = executeMethod;
        }

        public RelayCommand(Action<T> executeMethod, Func<T,bool> canExecuteMethod)
        {
            _TargetExecuteMethod = executeMethod;
            _TargetCanExecuteMethod = canExecuteMethod;
        }

        public void RaiseCanExecuteChanged()
        {
            CanExecuteChanged(this, EventArgs.Empty);
        }

        #region ICommand Members
        bool ICommand.CanExecute(object parameter)
        {
            if (_TargetCanExecuteMethod != null)
            {
                T tparm = (T)parameter;

                return _TargetCanExecuteMethod(tparm);
            }

            if (_TargetExecuteMethod != null)
            {
                return true;
            }

            return false;
        }

        // Beware - should use weak references if command instance lifetime is longer than lifetime of UI objects that get hooked up to command

        // Prism commands solve this in their implementation

        public event EventHandler CanExecuteChanged = delegate { };

        void ICommand.Execute(object parameter)
        {
            if (_TargetExecuteMethod != null)
            {
               _TargetExecuteMethod((T)parameter);
            }
        }
        #endregion

}

Adobe Launches Flash to HTML Conversion Tool - Wallaby

2011-03-11T16:03:00.000+05:30

Earlier this week Adobe announced a new technology called Wallaby that will enable its users to convert Flash projects into HTML5. Unlike the Flash iPhone Packager, Wallaby will not be able to convert any ActionScript into interactive HTML5 content, instead the tool simply makes it possible to convert Graphical content in FLA files into HTML5 ready content that may be displayed on webkit browers and iOS devices such as the iPhone and the iPad. Wallaby conversion works only with FLA files written in AS3 format.

You can learn more about Wallaby and download it from Adobe Labs, but you should note that this is an early technology showcase, so do not expect it to be bug-free.

Why to use MVVM patterns with Silverlight and WPF development

2010-10-23T21:06:00.000+05:30

To begin with, there are numerous and varied ways in implementing methodologies like MVVM, most of which are used based on personal preference. To a novice trying to educate themselves, this leads to disparity in information. Complicating this factor is that many of the articles or videos that attempt to describe the MVVM pattern also include components of other architectural patterns. This adds unnecessary complexity to understanding the MVVM pattern because of the inconsistencies in the pattern being described.

A great artical by Kim Schmidt. Here is the link

Calendar & Date Picker Scripts for ASP.NET and more

2010-10-22T23:34:00.000+05:30

Calendars can be seen frequently in most web pages today especially in blogs and personal websites. As for corporate sites or e-commerce sites, it is utilize to layout announcements, up-coming events, contest and much more. What makes a calendar almost essential? It allows users to know what is new, what to be expect on specified date and track back older information all at one glance.

Here is the full post

Create games for Windows Phone 7 - Getting Started Platforms Full Download

2010-10-21T12:37:00.000+05:30

Phase 1 - Platform

Get introduced to Windows Phone 7, and phone game development with XNA Game Studio. This set of educational content is for all skill levels and phases of development, with a focus on introducing basic game techniques – such as input, graphics, and sound – to developers interested in making games on Windows Phone 7 using XNA Game Studio 4.0.

Download Part 1 (13 MB)
Download Part 2 (83 MB)

Phase 2 - Performance

Learn how to get the most out of Windows Phone 7 and XNA Game Studio with optimization tips and tricks.

Download Part 1 (8 MB)
Part 2 - Coming Soon

Sony Ericsson S006 phone with 16.2-megapixel CMOS sensor

2010-10-20T11:56:00.000+05:30

Sony Ericsson has certainly outdone itself with the S006 smartphone from KDDI, where it will boast a massive 16.2-megapixel CMOS sensor, catering to those who think that "more is better". Digital photography doesn't work that way though, but at least it gives you some bragging rights among your less informed mates. Other specifications of the S006 include the proprietary Exmor R image engine, the ability to achieve ISO 12800, a 1GHz Snapdragon processor, Wi-Fi connectivity, an integrated FM tuner, GPS navigation, Bluetooth connectivity and a 3.3-inch display with VGA resolution. No idea on pricing, but don't expect to see this hit the US anytime soon.

IIS/Exchange logs and WebDAV functions

2010-10-19T11:56:00.001+05:30

You can collect information about client requests by enabling logging for sites and services. IIS logs are stored in %SystemRoot%\system32\Logfiles\. If you examine the IIS/Exchange log file you will see the request for the sample application being handled by IIS - you can notice couple of jargons like GET, PUT, POST, MKCOL, LOCK, UNLOCK, PROPFIND, SEARCH, PROPATCH, SUSBCRIBE, UNSUBSCRIBE, POLL etc.

The three main HTTP functions used are GET, PUT and POST:

GET: Retrieves a document

PUT: Puts an item in a folder
POST: Submits an item to a folder

In addition to above, there are few more WebDAV functions that are used:

MKCOL: Makes a collection that is in essence the same as a Web Storage System folder. MKCOL allows you to make folders and set their properties.
LOCK: Locks documents to prevent writes.
UNLOCK: Allows writes and creates updates.
PROPFIND: Searches for properties individually or for a whole set of folders.
SEARCH: Provides filter, subquery and sort capabilities to a search.
PROPPATCH: Sets arbitrary properties on an item.
SUBSCRIBE: Adds a user to a list.
UNSUBSCRIBE: Removes a user from a list.
POLL: Checks to see if the notification is fired.

System Stored Procedure sys.sp_tables in SQL Server

2010-10-17T12:33:00.000+05:30

to know the list of the tables from the database:

SELECT *

FROM sys.tables

GO

The script above provides various information from create date to file stream, and many other important information. If you need all those information, that script is the one for you. However, if you do not need all those information, I suggest that you run the following script:

EXEC sys.sp_tables

GO

The script above will give all the tables in the table with schema name and qualifiers. Additionally, this will return all the system catalog views together with other views. This Stored Procedure returns all the tables first in the result set, followed by views.

Even though Stored Procedure returns more numbers of rows, it still performs better than the sys.table query.

Let us verify it with two different methods for database AdventureWorks:

1) SET STATISTICS IO ON

USE AdventureWorks

GO

SET STATISTICS IO ON

SELECT *

FROM sys.tables

GO

EXEC sys.sp_tables

GO

(81 row(s) affected) (This is for sys.tables)
Table ‘syspalvalues’. Scan count 0, logical reads 162, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table ‘syssingleobjrefs’. Scan count 0, logical reads 324, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table ‘sysidxstats’. Scan count 81, logical reads 168, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table ‘syspalnames’. Scan count 0, logical reads 162, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table ‘sysschobjs’. Scan count 1, logical reads 16, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

(1 row(s) affected)

(456 row(s) affected) (This is for sys.sp_tables)
Table ‘sysobjrdb’. Scan count 1, logical reads 29, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.
Table ‘sysschobjs’. Scan count 1, logical reads 16, physical reads 0, read-ahead reads 0, lob logical reads 0, lob physical reads 0, lob read-ahead reads 0.

(1 row(s) affected)

2) Execution Plan

You can see that the execution plan for sys.table has much higher cost of query batch.

Well, if you only need to know the name of the tables, I suggest that you start using SP_TABLES; at least it takes less typing to do.

Source: sqlserverauthority

Free E-Books/Guides essential for .NET Programmers and Architects

2010-10-13T11:47:00.000+05:30

Foundations Of Programming

The Foundation Of Programming Series Free e-book By Karl Seguin is one of my favorites. It is simple, short and sweet. Especially for ‘casual’ programmers, this will give a better thought process – that’ll definitely enable them to code better and think better. This book covers the ALT.NET Philosophy, Domain Driven Development concepts, DI, TDD etc in a nice way. This book is close to my heart.

Download From Here

Microsoft Application Architecture Guide, 2nd Edition

Published by Microsoft, this is an essential read for any Microsoft.NET developer or Architect to understand the underlying architecture and design principles and patterns for developing successful solutions on the Microsoft platform and the .NET Framework. This guide neatly covers popular architecture patterns, best practices and common challenges you need to understand for developing .NET applications. Get a good grip on developing enterprise applications in .NET.

Download From Here

Rob Miles C# Yellow Book 2010

A nice action packed book that takes you through C# and .NET concepts. This book explains C# language and .NET library in general – with a clear focus on implementation thought process and best practices.

Download From Here

Threading in C#

A short, neatly written book from Joe Albahari about Threading in C#. This is a must read for any .NET programmer to understand more about threading in general, thread pooling, synchronization, Non blocking synchronization, etc. In this book, Joe even covers the Parallel Framework Extensions and Parallel programming in .NET

Download From Here

Improving .NET Application Performance and Scalability

This guide is again from Microsoft, and focuses on designing your applications with Performance and scalability in mind. It has sections relevant to architects, developers, testers, and administrators. Following the checklists and guidance in this book will ensure that there won’t be any unpleasant surprises in the end. Read this guide if you develop Enterprise applications in .NET

Download From Here

Applying Design Patterns

This is a quick introduction towards the thought process of applying design patterns. The objective of the book is to introduce design patterns in a simple way, so that developers can understand some common patterns and how to apply them. I wrote that some time back ;)

Download From Here

RefCardz from DZone

DZone has a number of awesome Ref Cardz (Quick reference sheets) on multiple technologies. You can go to DZone –> RefCardz to browse and download them (after getting a free DZone Id). Here are some of my recent favorites

Creating High Performing Applications for Windows Phone

2010-10-12T10:25:00.003+05:30

Performance is an important consideration when creating applications for a Windows Phone 7 device. A Windows Phone 7 device has a limited central processing unit (CPU) and graphics processing unit (GPU) compared to a desktop or laptop PC. To optimize performance of Silverlight applications on Windows Phone 7, several changes were made to the way that Silverlight processes graphics and other objects. Even though Silverlight has been optimized for Windows Phone 7, there are several things that you can do in your Silverlight applications to best leverage the CPU and GPU. This topic describes ways that you can improve the performance of your Silverlight applications and includes multiple code samples.

in reference to:

"Creating High Performing Applications for Windows Phone"
- Creating High Performing Applications for Windows Phone (view on Google Sidewiki)

Simple Tooltip with jQuery & CSS

2010-10-11T18:57:00.000+05:30

There are a lot of tooltip plugins out there, but not many of them explain what exactly goes on in the logic of a tooltip. But Soh Tanaka has created a nice tooltip and explained the logic also.

Click for Demo

Click here for full post

Nokia N8 + HDMI + Bluetooth Keyboard/Mouse = WIN

2010-10-10T18:48:00.001+05:30

In this video, Noah from phonedog goes hands-on with the Nokia N8 connected to a TV (via HDMI) and Apples bluetooth keyboard / mouse. Check out the video after the break!

Keyboard Bindings / Shortcuts in Visual Studio 2010

2010-10-09T18:48:00.000+05:30

All the Visual Studio 2010 Keyboard bindings are available here for you to download. These are very helpful resources for a person who spends most of his days in Visual Studio.

http://www.microsoft.com/downloads/en/details.aspx?displaylang=en&FamilyID=92ced922-d505-457a-8c9c-84036160639f

I personally like Ctrl+. which allows me to add the using statement without going to the top of the file. I use it quite frequently.

MVVM with WCF RIA Services

2010-10-08T12:58:00.000+05:30

MVVM without RIA:

· MVVM relies on the concept that View (XAML) will not contact your Model directly.

· View will contact Model via ViewModel classes.

· ViewModel talks with View using Data Binding and Commanding in XAML based applications.

· ViewModel talks with Model via web service communication in case of Silverlight when we don’t use RIA Service.

MVVM with RIA:

· RIA Service abstracts the web service layer from developer’s perspective and presents on client an identical set of classes that we have in model on server.

· This simply means that under normal MVVM scenario we just change the communication between ViewModel and Model to go via the auto generated model classes on client side instead of explicitly calling web services (though internally it is still WCF communication).

· In my opinion, this should not pose any problems to the MVVM pattern given that we keep the communication link same as above.

Cautions/DON’Ts:

· We should never attach the auto generated client model classes of RIA with View directly. This link of View to Model should happen via ViewModel only. In a nutshell, these auto-generated model classes should never be considered as ViewModel.

· We also have the availability of some RIA controls like DomainDataSource (in XAML). In case of MVVM we should NEVER use any such RIA controls in XAML since they break the very pillar of MVVM by contacting auto generated client side model of RIA directly (which is same as above point).

SharePoint 2010 Development Platform Stack - Diagram

2010-10-07T10:35:00.001+05:30

This diagram shows the platforms on which SharePoint Server and SharePoint Foundation are built.

The boxes with a blue fill represent independent platforms and each depends on the platforms below it.
The empty boxes inside the larger boxes are selected important subparts or features of the platform.
The thin downward arrows indicate selected dependency relations. Not every sub-platform or dependency relation is shown.
The thicker, green, sideways arrows indicate that one entity accesses the entity to which the arrow points. Again, only some selected access relationships are shown.

For more information, see Conceptual Overview of SharePoint Foundation and its child nodes.

Communication between Iframes

2010-10-06T10:45:00.000+05:30

In cases when we host different applications within Iframe on a web page, we often need them to communicate with each other or just be able to communicate with its host parent.

The basic to have this communication happen is by ensuring that the

document.domain

property of both communicating parties are same.

Consider this, say parent page is http://parent.example.com/mypage.aspx . This page host another application in an Iframe. To have parent and hosted application able to communicate with each other we need to have IFrame application be in either a subdomain of parent.example.com (like http://sub.parent.example.com/myapp.aspx) or in parallel to parent.example.com (like http://sub.example.com/myapp.aspx ).

Once we setup both applications as mentioned above; we can then set the document.domain property to parent.example.com (in case IFrame application is hosted in a subdomain like http://sub.parent.example.com/myapp.aspx) or we need to set the document.domain to example.com (in case the Iframe application is hosted in a parallel domain like http://sub.example.com/myapp.aspx )

We can do so by calling a script function at onload event handler of both parent page and on page which is to be hosted inside the iframe, or by simply doing something like this.









.. all other stuff

now, parent and iframe document can communicate without any hassle.
for example iframe document can now call any javascript method on its parent, passing any required data, like shown here

LinkList in Javascript

2010-10-05T10:27:00.001+05:30


    function LinkList() {

        var count = 0;

        var head = null;

        function Node() {

            var Data = null;

            var Next = null;

        }

        this.Count = function () {

            return count;

        }

        this.Add = function (data) {

            var nd = new Node();

            nd.Data = data;

            if (head) {

                nd.Next = head;

            }

            head = nd;

            count++;

        }

        this.Traverse = function () {

            var result = "";

            var current = head;

            while (current) {

                result = result + " --> " + current.Data;

                current = current.Next;

            }

            return result;

        }

    }

var mylist = new LinkList();



function AddToList() {

    var txtCtrl = document.getElementById('datatxt');

    var resCtrl = document.getElementById('result');

    if (txtCtrl && txtCtrl.value.length > 0) {

        mylist.Add(txtCtrl.value);

        if (resCtrl) {

            resCtrl.innerHTML = "" + txtCtrl.value + " added to list.";

        }

        txtCtrl.value = '';

    }

}

function PrintList() {

    var resCtrl = document.getElementById('result');

    if (resCtrl) {

        if (mylist.Count() > 0) {

            resCtrl.innerHTML = mylist.Traverse();

        }

        else {

            resCtrl.innerHTML = "List is empty.";

        }

    }

    var txtCtrl = document.getElementById('datatxt');

    if (txtCtrl) {

        txtCtrl.value = '';

    }

}

function GetCount() {

    var resCtrl = document.getElementById('result');

    if (resCtrl) {

        resCtrl.innerHTML = "List has " + mylist.Count() + " items.";

    }

    var txtCtrl = document.getElementById('datatxt');

    if (txtCtrl) {

        txtCtrl.value = '';

    }

Samsung I8700

2010-10-04T22:24:00.000+05:30

Samsung I8700 is rumored to be a Windows Phone 7 running device with 4" touch screen.

Basic specifications:
GSM 850/900/1800/1900
UMTS 900/1900/2100
WiFi, 3G
Windows Phone 7
GPS - Yes