Monday, January 14, 2013

Socket Program in c-sharp

Client and server implementation using socket programming:

Socket -- an End-Point of To and From (Bidirectional) communication link between two programs (Server Program and Client Program ) running on the same network.
Details:Two programs are needed for communicating a socket application in C# using TCP/IP Communication protocol.
A Server Socket Program ( Server ) and a Client Socket Program ( Client ) .
Server Socket Program running on a computer has a socket bound to a Port Number on the same computer and listening to the client's incoming requests.
 Client Socket Program have to know the IP Address ( Hostname ) of the computer that the C# Server Socket Program resides.
Once the connection is established between Server and Client , they can communicate (read or write ) through their own sockets.
Start the server and then make a connection to server by invoking the client..
Both client and server are on the same machine.
Two types of communication protocol can beused for Socket Programming in C#: 
  1.  TCP/IP ( Transmission Control Protocol/Internet protocol ) Communication
  2.  UDP/IP ( User Datagram Protocol/Internet protocol ) Communication .
 Server Implementation:Below is the source code for server implementation

using System.Net.Sockets:
namespace Server
{
    class Program
    {
        static void Main(string[] args)
        {

            TcpListener serverSocket = new TcpListener(8888);
            int requestCount = 0;
            TcpClient clientSocket = default(TcpClient);
            serverSocket.Start();
            Console.WriteLine("...Server Started");
            clientSocket = serverSocket.AcceptTcpClient();
            Console.WriteLine(" ... Accept connection from client");
            requestCount = 0;

            while ((true))
            {
                try
                {
                    requestCount = requestCount + 1;
                    NetworkStream networkStream = clientSocket.GetStream();
                    byte[] bytesFrom = new byte[10025];
                    networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);
                    string dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
                    dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
                    Console.WriteLine(" ..... Data from client - " + dataFromClient);
                    string serverResponse = "Server response " + Convert.ToString(requestCount);
                    Byte[] sendBytes = Encoding.ASCII.GetBytes(serverResponse);
                    networkStream.Write(sendBytes, 0, sendBytes.Length);
                    networkStream.Flush();
                    Console.WriteLine(" ... " + serverResponse);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
            }

            clientSocket.Close();
            serverSocket.Stop();
            Console.WriteLine(" ....exit");
            Console.ReadLine();
        }
    }
}

Client Implementation:Drag textbox,label and button control and drop them on form.In the code behind paste the following code
using System.Net.Sockets;
namespace Client
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        System.Net.Sockets.TcpClient clientSocket = new System.Net.Sockets.TcpClient();
        private void Form1_Load(object sender, EventArgs e)
        {
            msg("Client Started");
            clientSocket.Connect("127.0.0.1", 8888);
            label1.Text = "Client Socket Program - Server Connected ...";
        }
       

        public void msg(string mesg)
        {
            textBox1.Text = textBox1.Text + Environment.NewLine + " --> " + mesg;
        }

        private void button1_Click_1(object sender, EventArgs e)
        {
            NetworkStream serverStream = clientSocket.GetStream();
            byte[] outStream = System.Text.Encoding.ASCII.GetBytes("Message from Client$");
            serverStream.Write(outStream, 0, outStream.Length);
            serverStream.Flush();

            byte[] inStream = new byte[10025];
            serverStream.Read(inStream, 0, (int)clientSocket.ReceiveBufferSize);
            string returndata = System.Text.Encoding.ASCII.GetString(inStream);
            msg("Data from Server : " + returndata);
        }
    }
}
Images:
1. Form Design:
2.  Client server snapshot (running mode)


Enjoy coding!!!!!

Friday, January 11, 2013

String Searching:Knuth-Morris-Pratt Algorithm

Knuth, Morris and Pratt discovered first linear time string-matching algorithm by following a tight analysis of the naive algorithm.

The Problem 

The problem that we are trying to deal with, is of course, exactly the same as the naive problem. Given some pattern p, does it exist in some string s.


Example

Let’s say we have the following string and pattern,
  • s = “abra abracad abracadabra”
  • p = “abracadabra”
Now if this were the naive approach, we would need quite a lot of comparisons – 154 to be exact! Before we start, it would be best to note that we’ll be using zero-based arrays for this. So since s is really an array of characters, then s[0] would be referencing to the character ‘a’, and p[2] would be the character ‘r’.
We also need two more variables, name i and j. Here i will be the indexes into p, and j will be the indexes into s. Now, let’s start off with the first match-up,
  • j = 012345678901234567890123
  • s = abra abracad abracadabra
  • p = abracadabra
  • i = 01234567890
Here we can see that p[0] and s[0] are equal, but then we reach s[4] and p[4]. Here we have a space character and the character ‘c’. Clearly they don’t match up. So what we need to do now is slide the pattern along. But this is the part that isn’t like the naive approach. Instead of sliding the pattern across by one, we slide the pattern across by a special value. You see, behind the scenes there is in fact a table T. We’ll get to this later, but for now all you need to know is that we slide the pattern across to j=3 and reset i=0.
We get the value of j=3 from j = j+i-T[i] = 0+4–1 = 3. In this equation, j=0 because if you remember, j will be the starting point. i=4 because this is the point of failure – the position in p where we found our mismatch. And T[i]=1 because, well we’ll come to this later, for now take my word for it.
With these new values, we can now slide the pattern along:
  • j = 012345678901234567890123
  • s = abra abracad abracadabra
  • p =    abracadabra
  • i =    01234567890
Now we see that we find a mismatch at s[4] and p[1]. This is we slide the pattern along to j=4. If you wish to know why, it’s because j=3 and i=1 (which should be obvious) and T[i]=0, sticking them into that equation gives
j = j+i-T[i] = 3+1–0 = 4
Instead of drawing out all of the possible combinations, let’s jump ahead to:
  • j = 012345678901234567890123
  • s = abra abracad abracadabra
  • p =      abracadabra
  • i =      01234567890
Now this should be better to show off why this algorithm is better than the naive approach. Here we compare the characters again, and fail at s[12] and p[7]. But because of the way the algorithm works, we slide the pattern across by a huge amount,
  • j = 012345678901234567890123
  • s = abra abracad abracadabra
  • p =              abracadabra
  • i =              01234567890
I have actually skipped one step here, where we compare s[12] and p[0]. But as you can see the next step succeeds, and we find a match at j=13!
What’s more amazing is that we have only made 28 comparisons! A lot better than the naive approaches 154

So what’s this T table then!?

Well we had to get to this part sooner or later, so we may as well explain this now. Besides the obvious as to why KMP differs from the naive approach, there is another reason. You see, the KMP algorithm has a pre-processing stage, that is, that it does (or rather creates) something from the given pattern before the algorithm even starts searching for the pattern.
This pre-processing stage is the T table, and this is what it looked like for the above pattern:
i 0 1 2 3 4 5 6 7 8 9 10
p[i] a b r a c a d a b r a
T[i] -1 0 0 0 1 0 1 0 1 2 3
Now this may look rather complex, but it really isn’t that hard to understand. First things first, the values of T[0] and T[1] are always fixed, they never change. Therefore, T[0]=-1 and T[1]=0 all of the time. This means that the main program begins from i=2. There is also another variable that we need to use, and we shall call this variable sub, with initial value of sub=0.
And here is some pseudo-code to populate the T table.
Remember. i=2 and sub=0.

//whilst i doesn’t exceed the length of p
001    WHILE (i < length_of_p) DO:
//we have a continued substring in p from the start of p
002        IF (p[i-1] == p[sub]) THEN:
003            sub=sub+1
004            T[i] = sub
005            i=i+1
//if the substring stops, fall back to the start
006        ELSE IF (sub > 0) THEN:
007            sub = T[sub]
//we weren’t in a substring, so use default value
008        ELSE
009            T[i] = 0
010            i=i+1
011        ENDIF
012    ENDWHILE

I am not going to walk through the whole process. So let’s start at i=7 and sub=0.
Starting at line 002 we test to see if p[6] is equal to p[0]. Since ‘d’ is not equal to ‘a’ then we move onto the next statement. Here sub is not greater than 0, so we move onto the final statement. With this we make T[7]=0 and increment i to i=8.
Now, starting back at the first IF statement, we test to see if p[7] equals p[0], and by surprise it does since ‘a’ = ‘a’. This means that we increment sub to sub=1, we make T[8]=1 and increment i again to i=9.
Moving on again, we test p[8] to p[1] this time, since sub=1. This time we succeed again since ‘b’ = ‘b’. Therefore we increment sub and i to sub=2 and i=10. And obviously we set T[9]=2.
I’ll leave T[10] up to you, as well as the ones I missed, but it should be obvious by now how this works.
If you’re pondering why we need a –1 at the beginning, it’s so that if we fail on the very first character, we simply move along to the next character in the main string. As if this were just 0, we would not slide the pattern along.

The Main Algorithm

Now that we understand how the T table is created, the main algorithm for the KMP is very simple.
First of all, we have to remember that we have s which is the string to search through, and p which is the pattern to find. Then of course we have i which is the current index into p, and j which is the current index into s.
And here is the pseudo-code for the KMP,
       //while we don’t exceed the length of string s
001    WHILE (j+i < length_of_s) DO:
//character matching for parallel characters
002        IF (p[i] == s[j+i]) THEN:
//reached the end of the pattern, match found.
003            IF (i == length_of_p –1) THEN:
004                RETURN j
005            ENDIF
006            i=i+1
//parallel characters don’t match, slide pattern along
007        ELSE
008            j=j+i-T[i]
009            IF (T[i] > –1)
010                i = T[i]
011            ELSE
012                i = 0
013            ENDIF
014        ENDIF
015    ENDWHILE
016
//we reached the end of the string, match not found
017    RETURN length_of_s
This may look horribly daunting at first, but it really is very simple. Line 002 is simple the character by character matching process, matching parallel characters from the pattern and the string. If we reach the end of the pattern, return the position is s where is it (line 004), otherwise, we still have a character by character match, so increment to the next character in the pattern for testing (line 006).
The real fun beginnings inside of the ELSE statement. Now line 008 should look very familiar. Yep, we came across it earlier. This line simply sets the new start position in string s where we start matching the pattern against it again, and of course, you now know what the T table looks like.
The next part, from lines 009 to 013 are a little more tricky to grasp. Basically, when we slide the pattern along, we don’t always need to re-test some of the characters from the pattern. This is because of the way the T table works, and it’s called backtracking. For example, if we have the following s and p:
  • j = 01234567890
  • s = abcdab abcd
  • p = abcdabd
  • i = 0123456
We can see that the initial start point will fail at s[6] and p[6]. Now because of where is failed, T[6] is actually equal to the value 2. Therefore, we slide the pattern along to j = j + i + T[i] = 0 + 6 – 2 = 4:
  • j = 01234567890
  • s = abcdab abcd
  • p =     abcdabd
  • i =     0123456
But wait a second, we don’t need to compare the first 2 characters of p again, because we know that they already match up due to the T table. Therefore, like is says at line 010, we start at index i = T[6] = 2. This saves us a lot of time from doing none needed comparisons!
This backtracking only works if the value at T[i] is greater than 0. Otherwise, we just start at index i=0 in the pattern.

The Complexity

So, after all of this, what is the complexity of the KMP algorithm? Well the best part is that both the pre-processing phase and the main phase run in linear time. That is, the construction of the T table takes O(m) time, where m is the length of the pattern p. Then, the main program itself takes O(n) time where n is the length of the string s. Therefore the  overall time complexity is O(m+n).

Source:computersciencesource.wordpress.com/2011/01/03/string-searching-the-knuth-morris-pratt-algorithm/
Resources [1] http://en.wikipedia.org/wiki/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm
[2] University of Manchester, Advanced Algorithms 1 lecture notes by David Rydeheard
[3] Knuth-Morris-Pratt: An Analysis by Mireille Regnier
[4] Badgerati Tutorials – Knuth-Morris-Pratt Algorithm 




 

Friday, November 23, 2012

How to install an assembly in the Global Assembly Cache (GAC) in .NET

 What is a Shared Assembly?
A shared assembly is one that is used by multiple applications on the machine. A shared assembly must have a name that is globally unique. The .NET Framework supports these naming requirements through a technique called strong names.
Shared assemblies must have a "strong name" consisting of the name of the assembly, the version, a 64 bit hash of a public key (called a ´token´) and the culture.

To create a strong name for an assembly (that is, to generate a public/private key pair), you'll have to use another utility called sn.exe.

In this article, we will create a Visual C# 2010 class Library component called myGAC. We will also create a key file named mykeys.key. We will sign our component with this key file and place it in
To create a Component we have to create a Class Library project by using Visual Studio .NET.
Step 1 : Open Visual Studio .NET
Create a new Class Library project named myGAC in Visual Studio .NET or in Visual c# 2010.

Here is the code for the component. It just includes one method which returns a string.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace myGac
{
    public class Class1
    {

        public string GetName()
        {
            return "Syed Nisar Bukahri";
        }

    }
}

Step 2 : Generating Cryptographic Key Pair using the tool SN.Exe
Now, we will use the SN tool to generate the cryptographic key pair.


sn -k "C:\[DirectoryToPlaceKey]\[KeyName].key"
Next, create a directory named mykeys in C:\ so that you can easily locate the key and access the key from the visual studio command prompt.
Type the following at the command prompt.

sn -k "C:\mykeys\mykeys.key"
Step 3 : Sign the component with the key
A key is generated, but it is not yet associated with the project's assembly.
 To establish the association, open the AssemblyInfo.cs file in Visual Studio 2010 Solution Explorer.Add the following to the
list of assembly attributes that are included in this file by default when a project is created in Visual Studio .NET or in Visual Studio 2005:
[assembly: AssemblyKeyFile("C:\\mykeys\\mk.key")]

Note:Add this line just below the following line
[assembly: AssemblyTitle("ClassLibrary1")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ClassLibrary1")]
[assembly: AssemblyCopyright("Copyright ©  2012")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
...Add this line here.......
Now recompile/build the project and the assembly will be signed.
The next step is to install the assembly into the Global Assembly Cache.

Step 4 : Host the signed assembly in Global Assembly Cache
Using the Global Assembly Cache tool (Gacutil.exe)
You can use Gacutil.exe to add strong-named assemblies to the global assembly cache and to view the contents of the global assembly cache.
At the command prompt, type the following command:

gacutil ­I <assembly name>
In this command, assembly name is the name of the assembly to install in the global assembly cache.

The following example installs an assembly with the file name myGAC.dll into the global assembly cache.

gacutil -I "C:\[PathToBinDirectoryInVSProject]\myGAC.dll"

After hosting the assembly just go to WINNT\Assembly folder and you will find your assembly listed there.
Or if you are running windows 7 go to this location to locate the Assembly
C:\Windows\Microsoft.NET\assembly\GAC_MSIL
and here you will the folder in which is your signed assmbly
like myGac folder
In this will be another folder with name like
v4.0_1.0.0.0__e20b8219cca7baba
and in this folder will be your assemble stored with name as myGac.dll
Step 5 : Test the assembly
Once you've installed the assembly into the GAC, you can use it from other programs by creating a reference.

Now, we will create a sample client application which uses our shared assembly.

In our sample clientGACTest project, expand the project and then right-click on the References item. Select "Add Reference" from the popup menu, and the Add Reference dialog box is displayed.

To refer an assembly in the GAC, just click on the Browse button and browse to the directory (C:\Windows\Microsoft.NET\assembly\GAC_MSIL\v4.0_1.0.0.0__e20b8219cca7baba) that contains the assembly (myGAC.dll).
Locate the assembly, select it, and click OK.

Click on the myGAC reference in Solution Explorer and then examine the Properties pane. You'll see that the Copy Local property is set to False, Strong Name is true,Aliases is global and that the assembly version is 1.0.0.0
Just create a sample code as listed below :

You can now compile and run the clientGAC program.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using myGac;
namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            Class1 c = new Class1();
            string str = c.GetName();
            Console.WriteLine(str);
            Console.Read();
        }
    }
}

And it will display the name "Syed Nisar Bukhari"

This article describes how to generate a strong name for an assembly and to install a .dll file in the Global Assembly Cache.
The Global Assembly Cache (GAC) enables you to share assemblies across numerous applications.
 The GAC is automatically installed with the .NET runtime. Components are stored in C:\Windows\Microsoft.NET\assembly\GAC_MSIL\ or  C:\WINNT\Assembly.





Now time to practice!!!!


Thursday, November 22, 2012

How to Change the password for user sa of SQL Server

How to change the password of user sa of SQL Server

Make a login to SQL Server using windows authentication
Go to Security->Logins->right click on sa->properties->General tab and change the password
as
Password:
Confirm password:


Click on Ok   and you are done!!!!

Connect Sql Sever 2008 remotely

Open SQL Server Management studio

In the server name type the machine name  say HP-HP
 Set authentication to SQL Server authentication
Specify Login and password

Hope it helps....

Exception:Login failed for user 'IIS APPPOOL\ASP.NET v4.0

The fix to this exception is as:
Go to  IIS7->Application Pools -> Advanced Settings
Change the ApplicationPoolIdentity as
In Process Model section change the identity to Localsystem.This will make your application run under NT AUTHORITY\SYSTEM, which is an existing login for the database by default.

AdvancedSettings

Hope it helps.....

Sunday, October 14, 2012

SQL SERVER : Error 3154: The backup set holds a backup of a database other than the existing database


Error 3154: The backup set holds a backup of a database other than the existing database

Here is the fix to this error:


Steps:
1) Use WITH REPLACE while using the RESTORE command
2) Delete the older database which is conflicting and restore again using RESTORE command.
RESTORE DATABASE Inventory
FROM DISK = 'C:\BackupInventory.bak'WITH REPLACE
You are actually  trying to restore the database on another existing active database.

Enjoy..this is the efficient fix