C#

DataTable dt; 

private void Permissions_Load(object sender, EventArgs e){
                           dt = new DataTable();
                           dt.Columns.Add("Feature", typeof(string));
                           dt.Columns.Add("None", typeof(bool));
                           dt.Columns.Add("ReadOnly", typeof(bool));
                           dt.Columns.Add("ReadWrite", typeof(bool));

                           datagridview1.Datasource=dt;
}

private void btnSave_Click(object sender, EventArgs e){

/*On the grid when i'll click on the any checkbox I want to pass parameter to this function SetPermission( , , );
parameter will be from the two enumeratons below


Here is link of Picture <u>http://img9.imageshack.us/i/35025568.jpg/</u>
I'll explain it   in detail as I can
When I click on any checkbox here,I want to pass parameter in set function, for example like this: if I'll click on row Stores, Column read only's expedient checkbox item i want to pass SetPermission(1,1, ...) because in enumeration stores id is 1 and read only's id is 1 too.

SetPermission(?,?,?);*/
}

 public void SetPermission(Permission feature, PermissionType permission, int userID) {
                           SqlCommand cmd = new SqlCommand("Insert into Permissions          (UserID,Feature,Permission)Values(@UserID,@Feature,@Permission)", con);

                           cmd.Parameters.Add(new SqlParameter("UserID", userID));

 }



         public enum Permission : int
         {
                  Country = 0,
                  Store = 1,
                  City = 2
         }

         public enum PermissionType : byte
         {
                  None = 0,
                  ReadOnly = 1,
                  ReadWrite = 2
         }

using System;
using System.Net;
using System.IO;
using System.Net.Security;
using System.Net.Sockets;
using System.Threading;
using System.Text;

namespace TEST
{
    // The RequestState class passes data across async calls.
    public class RequestState
    {
        public int BufferSize = 1024;
        public byte[] RequestData;
        public byte[] BufferRead;
        public WebRequest Request;
        public Stream ResponseStream;
        public WebResponse Response;
        public Socket aSocket;

        public RequestState()
        {
            BufferRead = new byte[BufferSize];
            RequestData = new byte[0];
            Request = null;
            aSocket = null;
            //Response = null;
            ResponseStream = null;
        }
    }
    ///////////////////////////////////////////////////////

    public delegate void DestroyDelegate_(ProxyClient client);
    public class ProxyClient : IDisposable
    {
        //public static ManualResetEvent allDone = new ManualResetEvent(false);
        const string myUri="http://DEV309.Dev.cadcorp.net:4326/KmlService/Kml.serv?REQUEST=GetCapabilities";
        //const string myUri = "http://localhost/hello.htm";

        public ProxyClient(Socket ClientSocket, DestroyDelegate_ Destroyer, IPEndPoint MapTo, CredentialCache credCache)
        {
            this.ClientSocket = ClientSocket;
            this.Destroyer = Destroyer;
            this.MapTo = MapTo;
            this.m_credCache = credCache;
            this.m_sendDone = new ManualResetEvent(true);
        }

        private IPEndPoint MapTo
        {
            get
            {
                return m_MapTo;
            }
            set
            {
                if (value == null)
                    throw new ArgumentNullException();
                m_MapTo = value;
            }
        }

        internal Socket ClientSocket
        {
            get
            {
                return m_ClientSocket;
            }
            set
            {
                if (m_ClientSocket != null)
                    m_ClientSocket.Close();
                m_ClientSocket = value;
            }
        }

        public void Dispose()
        {
            try
            {
                ClientSocket.Shutdown(SocketShutdown.Both);
            }
            catch { }
            //Close the sockets
            if (ClientSocket != null)
                ClientSocket.Close();
            //Clean up
            ClientSocket = null;
            if (Destroyer != null)
                Destroyer(this);
        }
 
        /////////////////////////////// WebRequest //////////////////////////////////////////////////////
            private void ReadCallBack(IAsyncResult asyncResult)
            {
                try
                {
                    RequestState myRequestState = (RequestState)asyncResult.AsyncState;
                    Stream responseStream = myRequestState.ResponseStream;
                    int read = responseStream.EndRead(asyncResult);
                    if (read > 0)
                    {
                        //Resize Buffer
                        byte[] newBuffer = new byte[myRequestState.RequestData.Length + read];
                        Buffer.BlockCopy(myRequestState.RequestData, 0, newBuffer, 0, myRequestState.RequestData.Length);
                        Buffer.BlockCopy(myRequestState.BufferRead, 0, newBuffer, myRequestState.RequestData.Length, read);
                        myRequestState.RequestData = newBuffer;

                        IAsyncResult asynchronousResult =
                           responseStream.BeginRead(myRequestState.BufferRead, 0, myRequestState.BufferSize,
                             new AsyncCallback(ReadCallBack), myRequestState);

                    }
                    else
                    {
                        if (myRequestState.RequestData.Length > 0)
                        {
                            myRequestState.aSocket.BeginSend(myRequestState.RequestData, 0, myRequestState.RequestData.Length,SocketFlags.None, new AsyncCallback(Finish), myRequestState);
/*
                            int i = myRequestState.aSocket.Send(myRequestState.RequestData, 0, myRequestState.RequestData.Length, SocketFlags.None);
                            System.Diagnostics.Debug.Write("Sent {0} bytes."+ i+"\n");
                            Dispose();
                            myRequestState.ResponseStream.Close();
 */
                        }
                        //responseStream.Close();
                        //myRequestState.aSocket.Shutdown(SocketShutdown.Both);
                        //myRequestState.aSocket.Close();
                        //allDone.Set();
                    }
                }
                catch (SocketException ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex.ToString());
                    Dispose();
                }
            }

            private void Finish(IAsyncResult asyncResult)
            {
                try
                {
                    RequestState myRequestState = (RequestState)asyncResult.AsyncState;
                    Socket mySocket = myRequestState.aSocket;

                    int Ret = mySocket.EndSend(asyncResult);
                    if (Ret <= 0)
                    {
                        Dispose();
                        myRequestState.ResponseStream.Close();
                   }
                    //m_sendDone.Set();
                }
                catch (SocketException ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex.ToString());
                    Dispose();
                }
            }

            private void RespCallback(IAsyncResult asynchronousResult)
            {
                try
                {
                    RequestState myRequestState = (RequestState)asynchronousResult.AsyncState;

                    WebRequest myWebRequest1 = myRequestState.Request;
                    myRequestState.Response = myWebRequest1.EndGetResponse(asynchronousResult);

                    Stream responseStream = myRequestState.Response.GetResponseStream();
                    myRequestState.ResponseStream = responseStream;

                    IAsyncResult asynchronousResultRead =
                    responseStream.BeginRead(myRequestState.BufferRead, 0, myRequestState.BufferSize,
                    new AsyncCallback(ReadCallBack), myRequestState);
                }
                catch (SocketException ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex.ToString());
                    Dispose();
                }
            }

            public void StartHandshake()
            {
                try
                {
                    WebRequest request = (HttpWebRequest)WebRequest.Create(myUri);
                    request.Credentials = m_credCache;//CredentialCache.DefaultCredentials;
                    RequestState myRequestState = new RequestState();
                    myRequestState.Request = request;
                    myRequestState.aSocket = ClientSocket;

                    // Issue the async request.
                    IAsyncResult r = (IAsyncResult)request.BeginGetResponse(
                       new AsyncCallback(RespCallback), myRequestState);

                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine(ex.ToString());
                    Dispose();
                }
            }

            private CredentialCache m_credCache;
            private DestroyDelegate_ Destroyer;
            private Socket m_ClientSocket;
            private IPEndPoint m_MapTo;
            private ManualResetEvent m_sendDone;
    }