--- title: "how to create form application using .NET." description: "how to create form application using .NET." author: "Abhishek Srivasatava" published: 2016-11-27 updated: 2020-09-21 canonical: https://www.mindstick.com/interview/23108/how-to-create-form-application-using-dot-net category: "c#" tags: ["c#"] reading_time: 22 minutes --- # how to create form application using .NET. In interview, mostly question asked by the Technical HR will be relate to form applicaton apllication. To develop any software one should know how to create create store procedure. In this we have created one small application which may help you to understand the basic concept how to develop an application.\ ``` Login procCREATE PROCEDURE [dbo].[login_proc](@UserId varchar(50),@User_Password varchar(50))ASBeginSelect @UserId from Emp_Login where UserId=@UserId and User_Password=@User_PasswordEND ``` \ ``` Proc_std_DeleteCREATE PROCEDURE [dbo].[Proc_std_Delete](@Enrollment_number int) ASBEGINIF NOT EXISTS (SELECT Enrollment_number FROM Std_Details                where  Enrollment_number = @Enrollment_number)                     begin                                                                   print 'Data does not exist or Enrollemt Id is wrong';                                                end                         elsebegin                   delete from Std_DetailswhereEnrollment_number = @Enrollment_numberprint 'Deleted record successfully';                                                         end     end ``` \ ``` ALTER PROCEDURE [dbo].[Proc_std_Info](@Enrollment_number int ,@Student_name varchar(50),@Father_Name varchar(50),@Mother_Name varchar(50),@Sex varchar(50),@Permanent_Add varchar(50),@Permanent_State varchar(50),@Subject_Maths varchar(30),@Subject_Physics varchar(30),@Subject_Chemistry varchar(30),@Subject_English varchar(30),@Subject_Hindi varchar(30),@Subject_Social varchar(30),@class varchar(30)) ASBEGINIF NOT EXISTS (SELECT Enrollment_number FROM Std_Details               where  Enrollment_number = @Enrollment_number)                     BEGININSERT INTO Std_Details (Enrollment_number,[Student_name],[Father_Name],[Mother_Name],[Sex],[Permanent_Add],[Permanent_State])values (@Enrollment_number,@Student_name,@Father_Name,@Mother_Name,@Sex,@Permanent_Add,@Permanent_State)                                                                                        INSERT INTO Std_Opt_Sub (Enrollment_number,[Subject_Maths],[Subject_Physics],[Subject_Chemistry],[Subject_English],[Subject_Hindi],[Subject_Social],[Opt_Begin_Date],[Opt_End_Date],[class])values (@Enrollment_number,@Subject_Maths,@Subject_Physics,@Subject_Chemistry,@Subject_English,@Subject_Hindi,@Subject_Social,GETDATE(),'2299-12-31',@class)                                          END                     else                                                begin                                                                   print 'Data already exist';                                                end      end  ``` \ ``` ALTER PROCEDURE [dbo].[Proc_std_Update](@Enrollment_number int ,@Student_name varchar(50),@Father_Name varchar(50),@Mother_Name varchar(50),@Sex varchar(50),@Permanent_Add varchar(50),@Permanent_State varchar(50),@Subject_Maths varchar(30),@Subject_Physics varchar(30),@Subject_Chemistry varchar(30),@Subject_English varchar(30),@Subject_Hindi varchar(30),@Subject_Social varchar(30),@class varchar(30)) ASBEGINIF NOT EXISTS (SELECT Enrollment_number FROM Std_Details               where  Enrollment_number = @Enrollment_number)                     begin                                                                   print 'Data does not exist or Enrollemt Id is wrong';                                                end                         elsebegin                              Update Std_Detailsset  Student_name= @Student_name,Father_Name=@Father_Name,Mother_Name=@Mother_Name,Sex=@Sex,Permanent_Add=@Permanent_Add,Permanent_State=@Permanent_State whereEnrollment_number = @Enrollment_number                                                                   Update Std_Opt_Sub set                         Subject_Maths=@Subject_Maths ,Subject_Physics=@Subject_Physics ,Subject_Chemistry=@Subject_Chemistry ,Subject_English=@Subject_English ,Subject_Hindi=@Subject_Hindi,Subject_Social=@Subject_Social,Class=@classwhere                                                 Enrollment_number = @Enrollment_number end     end ``` \ ``` ALTER PROCEDURE [dbo].[Proc_user_insert](@UserId varchar (30),@User_Password VARCHAR (100),@Name varchar(30),@Password_Hint varchar(30)) ASBEGINIF NOT EXISTS (SELECT UserId FROM User_information               where  @UserId = UserId)                     begin                                                                   insert into User_information ([UserId],[User_Password],[Name],[Password_Hint])                                                                   values (@UserId, @User_Password,@Name,@Password_Hint)                                                                   print 'Data Inserted Successfully';                                                           end   elsebegin           print 'Data Already Exist';                                                  end    end  ``` \ ``` ALTER PROCEDURE [dbo].[Proc_user_insert1](@UserId varchar (30),@User_Password varchar (100),@Name varchar(30),@Password_Hint varchar(30)) ASBEGINIF NOT EXISTS (SELECT UserId FROM User_information               where  @UserId = UserId)                     begin                                                                   insert into User_information ([UserId],[User_Password],[Name],[Password_Hint])                                                                   values (@UserId,HASHBYTES('SHA2_512',@User_Password),@Name,@Password_Hint)                                                                   print 'Data Inserted Successfully';                                                           end   elsebegin           print 'Data Already Exist';                                                  end    end ``` \ ``` ALTER PROCEDURE [dbo].[User_Info](@UserId varchar(50),@Old_Password varchar(50),@New_Password varchar(50),@confirm_new_password varchar(50),@Password_Hint varchar(50)) ASBEGIN          IF NOT EXISTS (SELECT UserId FROM User_information                          where  UserId = @UserId)                     BEGIN                               PRINT 'No Such UserId Exist'                     END        ELSE        begin           declare @checkpass varchar(30);                             set     @checkpass= (SELECT User_Password FROM User_information where  UserId = @UserId)                                                          if (@Checkpass<> @Old_Password)                                                          begin                                                          print 'old password is wrong'                                                          end                                                                                                                    ELSE                                                                             IF (@New_Password <> @confirm_new_password)                                                                                      BEGIN                                                                                      PRINT 'Password doesn''t match'                                                                                      END                                                                             ELSE                                                                                      BEGIN                                                                                      UPDATE  User_information                                                                                       SET User_Password= @confirm_new_password , Password_Hint= @Password_Hint                                                                                       WHERE UserId = @UserId                                                                             END                   END   END ``` ``` Code for from1using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient; namespace FormsApplication1{    public partial class Form1 : Form    {        public Form1()        {            InitializeComponent();        }       public  int i=0, j=0, k=0;        private void button1_Click(object sender, EventArgs e)        {   SqlConnection con = new SqlConnection();            con.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con.Open();                       SqlCommand cmd = new SqlCommand("Select UserId from User_information where UserId=@UserId and User_Password=@User_Password", con);            //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);            // cmd.CommandType = CommandType.StoredProcedure;            DataTable dt = new DataTable();            cmd.Parameters.AddWithValue("@UserId", textBox1.Text);            cmd.Parameters.AddWithValue("@User_Password", textBox2.Text);            SqlDataReader read = cmd.ExecuteReader();            read.Read();            if (textBox1.Text.Trim() == string.Empty)            {                MessageBox.Show("Userid need to be fill","Warning message");                i++;            }            else            {                if (textBox2.Text.Trim() == string.Empty)                {                    MessageBox.Show("Password Required!!", "Warning message");                    j++;                }                else                {                    if (read.HasRows)                    {                        //here you may redirect to another page like Response.Redirect("Page2.aspx");                        Form2 objfill = new Form2();                        objfill.Show();                        this.Hide();                         con.Close();                    }                    else                    {                        MessageBox.Show("Your UserId, Password or both are wrong ", "Error Message");                        k++;                    }                }            }            if (i > 3 )            {                MessageBox.Show("Attempt for Userid Is greater than 3, please reopen","Error Message");                this.Close();            }            if ( j > 3)            {                MessageBox.Show("Attempt for Password Is greater than 3, please repen and set your password","Error Messaage");                this.Close();            }            if (k>3)            {                MessageBox.Show("Attempt for Password Is greater than 3, please repen and set your password","Error Message");                this.Close();            }        }        private void button2_Click(object sender, EventArgs e)        {            Form3 F3 = new Form3();            F3.Show();        }        private void Form1_Load(object sender, EventArgs e)        {        }        private void textBox2_TextChanged(object sender, EventArgs e)        {            textBox2.MaxLength = 8;            textBox2.PasswordChar = '*';        }        private void textBox1_TextChanged(object sender, EventArgs e)        {            textBox1.MaxLength = 16;         }    }} ``` ``` Code for from2using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient;using System.Data.SqlTypes;  namespace FormsApplication1{    public partial class Form2 : Form    {        public Form2()        {            InitializeComponent();        }        private void button4_Click(object sender, EventArgs e)        {            this.Close();             Form1 objform1 = new Form1();            objform1.Show();        }        private void button1_Click(object sender, EventArgs e)        {            /* inserting a new details*/            SqlConnection con2 = new SqlConnection();            con2.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con2.Open();            SqlCommand savecom = new SqlCommand("Proc_std_Info", con2);            savecom.Connection = con2;            savecom.CommandType = CommandType.StoredProcedure;            savecom.Parameters.AddWithValue("@Student_name", textBox2.Text);            savecom.Parameters.AddWithValue("@Father_Name", textBox3.Text);            savecom.Parameters.AddWithValue("@Mother_Name", textBox4.Text);            if (radioButton1.Checked == true || radioButton2.Checked == true)            {                if (radioButton1.Checked == true)                {                    savecom.Parameters.AddWithValue("@Sex", "Male");                }                else                {                    savecom.Parameters.AddWithValue("@Sex", "Female");                }            }            else            {                savecom.Parameters.AddWithValue("@Sex", " ");            }            savecom.Parameters.AddWithValue("@Permanent_Add", textBox5.Text);            savecom.Parameters.AddWithValue("@Permanent_State",comboBox1.Text);            int a;            if (int.TryParse(textBox1.Text.ToString(), out a) || (textBox1.Text.Trim() == string.Empty))            {                                  if (checkBox1.Checked == true)                {                     savecom.Parameters.AddWithValue("@Subject_Maths", "Selected ");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Maths", "Not Selected");                }                if (checkBox2.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Physics", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Physics", "Not Selected");                }                 if (checkBox3.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Chemistry", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Chemistry", "Not Selected");                }                  if (checkBox4.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_English", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_English", "Not Selected");                }                 if (checkBox5.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Hindi ", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Hindi", "Not Selected");                }                if (checkBox6.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Social", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Social", "Not Selected");                }                savecom.Parameters.AddWithValue("@Class", comboBox2.Text);                 if (textBox1.Text.Trim() == string.Empty)                {                    MessageBox.Show("Please enter the User Id","Warning message");                }                else                {                    savecom.Parameters.AddWithValue("@Enrollment_number", Convert.ToInt32(textBox1.Text));                    if (textBox2.Text.Trim() == string.Empty)                    {                        MessageBox.Show("Please enter Name");                    }                    else                    {                        if (radioButton1.Checked == false && radioButton2.Checked == false)                        {                            MessageBox.Show("Select male or female", "Warning message");                        }                        else                        {                            if (checkBox1.Checked == false && checkBox2.Checked == false && checkBox3.Checked == false && checkBox4.Checked == false && checkBox5.Checked == false && checkBox6.Checked == false)                            {                                 MessageBox.Show("Select At least one Subject", "Warning message");                             }                            else                            {                                                                SqlCommand cmd = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con2);                                //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                                // cmd.CommandType = CommandType.StoredProcedure;                                DataTable dt = new DataTable();                                cmd.Parameters.AddWithValue("@UserId", textBox1.Text);                                SqlDataReader read = cmd.ExecuteReader();                                read.Read();                                 if (read.HasRows)                                {                                    MessageBox.Show("Already Have data ","Informational Message");                                 }                                else                                {                                    read.Close();                                    savecom.ExecuteNonQuery();                                    SqlCommand cmd1 = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con2);                                    //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                                    // cmd.CommandType = CommandType.StoredProcedure;                                    DataTable dt1 = new DataTable();                                    cmd1.Parameters.AddWithValue("@UserId", textBox1.Text);                                    SqlDataReader read1 = cmd1.ExecuteReader();                                    read1.Read();                                    if (read1.HasRows)                                    {                                        MessageBox.Show("Inserted Successfully", "Congrats!!!");                                     }                                    else                                    {                                        MessageBox.Show("Enrollement Id Is not valid", "Error Message");                                    }                                }                            }                        }                    }                  }            }            else            {                MessageBox.Show("Please enter the correct format of enrollment id","Warning message");            }                         con2.Close();        }         private void button2_Click(object sender, EventArgs e)        {            /* inserting a new details*/            SqlConnection con3 = new SqlConnection();            con3.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con3.Open();            SqlCommand savecom = new SqlCommand("Proc_std_Update", con3);            savecom.Connection = con3;            savecom.CommandType = CommandType.StoredProcedure;                         savecom.Parameters.AddWithValue("@Student_name", textBox2.Text);            savecom.Parameters.AddWithValue("@Father_Name", textBox3.Text);            savecom.Parameters.AddWithValue("@Mother_Name", textBox4.Text);             if (radioButton1.Checked == true || radioButton2.Checked == true)            {                if (radioButton1.Checked == true)                {                    savecom.Parameters.AddWithValue("@Sex", "Male");                }                else                {                    savecom.Parameters.AddWithValue("@Sex", "Female");                }            }            else            {                savecom.Parameters.AddWithValue("@Sex", " ");             }                       savecom.Parameters.AddWithValue("@Permanent_Add", textBox5.Text);            savecom.Parameters.AddWithValue("@Permanent_State", comboBox1.Text);            int a;              if (int.TryParse(textBox1.Text.ToString(), out a) || (textBox1.Text.Trim() == string.Empty))            {                    if (checkBox1.Checked == true)                    {             savecom.Parameters.AddWithValue("@Subject_Maths", "Selected ");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Maths", "Not Selected");            }            if (checkBox2.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Physics", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Physics", "Not Selected");            }             if (checkBox3.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Chemistry", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Chemistry", "Not Selected");            }              if (checkBox4.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_English", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_English", "Not Selected");            }             if (checkBox5.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Hindi ", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Hindi", "Not Selected");            }            if (checkBox6.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Social", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Social", "Not Selected");            }            savecom.Parameters.AddWithValue("@Class", comboBox2.Text);             if (textBox1.Text.Trim() == string.Empty)            {                MessageBox.Show("Please enter the User Id", "Warning message");            }            else            {                savecom.Parameters.AddWithValue("@Enrollment_number", Convert.ToInt32(textBox1.Text));                if (textBox2.Text.Trim() == string.Empty)                {                    MessageBox.Show("Please enter Name", "Warning message");                }                else                {                    if (radioButton1.Checked == false && radioButton2.Checked == false)                    {                        MessageBox.Show("Select male or female", "Warning message");                    }                    else                    {                        if (checkBox1.Checked == false && checkBox2.Checked == false && checkBox3.Checked == false && checkBox4.Checked == false && checkBox5.Checked == false && checkBox6.Checked == false)                        {                             MessageBox.Show("Select At least one Subject", "Warning message");                         }                        else                        {                            savecom.ExecuteNonQuery();                             SqlCommand cmd = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con3);                            //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                            // cmd.CommandType = CommandType.StoredProcedure;                            DataTable dt = new DataTable();                            cmd.Parameters.AddWithValue("@UserId", textBox1.Text);                            SqlDataReader read = cmd.ExecuteReader();                            read.Read();                             if (read.HasRows)                            {                                MessageBox.Show("Updated Successfully", "Congrats!!!");                              }                            else                            {                                MessageBox.Show("Enrollement Id Is not valid", "Error Message");                             }                        }                    }                }             }                         }            else            {                 MessageBox.Show("Please enter the correct format of enrollment id", "Warning message");            }                      con3.Close();         }        private void button5_Click(object sender, EventArgs e)        {            Form4 f4 = new Form4();            f4.Show();            f4.fill();        }         private void button3_Click(object sender, EventArgs e)        {            SqlConnection con6 = new SqlConnection();            con6.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con6.Open();            SqlCommand DeleteCom = new SqlCommand("Proc_std_Delete", con6);            DeleteCom.Connection = con6;            DeleteCom.CommandType = CommandType.StoredProcedure;                        int a;            if (int.TryParse(textBox1.Text.ToString(), out a) || (textBox1.Text.Trim() == string.Empty))            {                 DeleteCom.Parameters.AddWithValue("@Enrollment_number", textBox1.Text);                   SqlCommand cmd = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con6);                //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                // cmd.CommandType = CommandType.StoredProcedure;                DataTable dt = new DataTable();                cmd.Parameters.AddWithValue("@UserId", textBox1.Text);                SqlDataReader read = cmd.ExecuteReader();                read.Read();                 if (read.HasRows)                {                    DialogResult result2 = MessageBox.Show("Are you sure do you want to delete", "Question", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);                    if (result2 == DialogResult.Yes)                    {                        read.Close();                        DeleteCom.ExecuteNonQuery();                        MessageBox.Show("Deleted Successfully");                         this.Close();                        Form1 objlogin = new Form1();                        objlogin.Show();                    }                    else                    {                        MessageBox.Show("No Account has been updated ", "Informational Message");                    }                 }                else                {                    MessageBox.Show("Enrollement Id Is not valid or Already Deleted","Informatinal Error");                }            }            else            {                MessageBox.Show("Enrollement Id Format is not correct");            }                                  con6.Close();        }         public void textBox1_TextChanged(object sender, EventArgs e)        {             textBox1.MaxLength = 8;                    }         public void textBox2_TextChanged(object sender, EventArgs e)        {            textBox2.MaxLength = 16;        }         public void textBox3_TextChanged(object sender, EventArgs e)        {            textBox3.MaxLength = 16;        }         public void textBox4_TextChanged(object sender, EventArgs e)        {            textBox4.MaxLength = 16;        }         public void textBox5_TextChanged(object sender, EventArgs e)        {            textBox5.MaxLength = 20;        }         public void comboBox1_SelectedIndexChanged(object sender, EventArgs e)        {                   }         public void Form2_Load(object sender, EventArgs e)        {              SqlConnection concombostate = new SqlConnection();            concombostate.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            concombostate.Open();                SqlCommand sc = new SqlCommand("select List_of_state from Indian_state", concombostate);                SqlDataReader reader;                reader = sc.ExecuteReader();                DataTable dt = new DataTable();                dt.Columns.Add("List_of_state", typeof(string));                dt.Load(reader);                comboBox1.DisplayMember = "List_of_state";                comboBox1.DataSource = dt;             //   concombostate.Close();                comboBox1.SelectedIndex = -1;        }        }    }   ``` Code for form3 ``` using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient;namespace FormsApplication1{    public partial class Form3 : Form    {        public Form3()        {            InitializeComponent();        }         private void button1_Click(object sender, EventArgs e)        {            SqlConnection con = new SqlConnection();            con.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con.Open();            SqlCommand cmdreset = new SqlCommand("User_Info", con);            cmdreset.Connection = con;            cmdreset.CommandType = CommandType.StoredProcedure;            cmdreset.Parameters.AddWithValue("@Old_Password", textBox1.Text);            cmdreset.Parameters.AddWithValue("@UserId", textBox5.Text);            cmdreset.Parameters.AddWithValue("@New_Password", textBox2.Text);            cmdreset.Parameters.AddWithValue("@confirm_new_password", textBox3.Text);            cmdreset.Parameters.AddWithValue("@Password_Hint", textBox4.Text);             if (textBox5.Text.Trim() == string.Empty)            {                MessageBox.Show("Userid required","Warning Message");             }            else            {                if (textBox1.Text.Trim() == string.Empty)                {                    MessageBox.Show("Old Password Required!!","Warning Message");                 }                else                {                    if (textBox2.Text.Trim() == string.Empty)                    {                        MessageBox.Show("New password required","Warning Message");                    }                    else                    {                        if (textBox3.Text.Trim() == string.Empty)                        {                            MessageBox.Show("Confirm Password Required","Warning Message");                        }                        else                        {                            cmdreset.ExecuteNonQuery();                            SqlCommand cmd = new SqlCommand("Select UserId from User_information where UserId=@UserId and User_Password=@User_Password", con);                            //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                            // cmd.CommandType = CommandType.StoredProcedure;                            DataTable dt = new DataTable();                            cmd.Parameters.AddWithValue("@UserId", textBox5.Text);                            cmd.Parameters.AddWithValue("@User_Password", textBox2.Text);                            SqlDataReader read = cmd.ExecuteReader();                            read.Read();                             if (read.HasRows)                            {                                //here you may redirect to another page like Response.Redirect("Page2.aspx");                                MessageBox.Show("Successfully changed the Password ","Contrats Message");                                read.Close();                                this.Close();                            }                            else                            {                                read.Close();                                 SqlCommand cmd1 = new SqlCommand("Select UserId from User_information where UserId=@UserId and User_Password=@User_Password", con);                                //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                                // cmd.CommandType = CommandType.StoredProcedure;                                DataTable dt1 = new DataTable();                                cmd1.Parameters.AddWithValue("@UserId", textBox5.Text);                                cmd1.Parameters.AddWithValue("@User_Password", textBox1.Text);                                SqlDataReader read1 = cmd1.ExecuteReader();                                read1.Read();                                 if (read1.HasRows)                                {                                    //here you may redirect to another page like Response.Redirect("Page2.aspx");                                    MessageBox.Show("Password mismatich ","Warning Message");                                    read1.Close();                                 }                                else                                {                                    MessageBox.Show("Old Password is wrong","Warning Message");                                }                            }                                                         con.Close();                                                   }                    }                }            }        }                      private void button2_Click  (object sender, EventArgs e)        {            this.Close();        }         private void textBox1_TextChanged(object sender, EventArgs e)        {            textBox1.PasswordChar = '*';            textBox1.MaxLength = 8;        }         private void textBox2_TextChanged(object sender, EventArgs e)        {            textBox2.PasswordChar = '*';            textBox2.MaxLength = 8;        }         private void textBox3_TextChanged(object sender, EventArgs e)        {            textBox3.PasswordChar = '*';            textBox3.MaxLength = 8;        }     }} ``` **Code for form4** ``` using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient;using System.Data.SqlTypes; namespace FormsApplication1{    public partial class Form4 : Form    {         public Form4()        {            InitializeComponent();        }         public void fill()        {            SqlConnection con3 = new SqlConnection();            con3.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            DataSet ds = new DataSet();             con3.Open();            SqlCommand cmd = new SqlCommand("select A.Enrollment_number,A.Student_name,A.Father_Name,A.Mother_Name,A.Sex,A.Permanent_Add,A.Permanent_State,B.Subject_Maths,B.Subject_Physics,B.Subject_Chemistry,B.Subject_English,B.Subject_Hindi,B.Subject_Social,B.class FROM Std_Details A,Std_Opt_Sub B where A.Enrollment_number = B.Enrollment_number", con3);            SqlDataAdapter da = new SqlDataAdapter();            da.SelectCommand = cmd;            da.Fill(ds);            dataGridView1.DataSource = ds.Tables[0];         }        public void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)        {            // string profilename = dataGridView1.Rows[0].Cells[1].Value.ToString();            //            int a;            //          int.TryParse(profilename, out a);            //    Form2 f2 = new Form2();            //   f2.textBox1.Text = profilename;         }         public void dataGridView1_CellDoubleClick(object sender, DataGridViewCellEventArgs e)        {           /* Form2 f2 = new Form2();            f2.textBox1.Text = dataGridView1.CurrentRow.Cells["Enrollment_number"].Value.ToString();            this.Close();*/         }    }} ``` ![how to create form application using .NET.](data:image/png;base64,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) \ ![how to create form application using .NET.](data:image/png;base64,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)\ \ \ ![how to create form application using .NET.](data:image/png;base64,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) ## Answers ### Answer by Abhishek Srivasatava In interview, mostly question asked by the Technical HR will be relate to form applicaton apllication. To develop any software one should know how to create create store procedure. In this we have created one small application which may help you to understand the basic concept how to develop an application.\ ``` Login procCREATE PROCEDURE [dbo].[login_proc](@UserId varchar(50),@User_Password varchar(50))ASBeginSelect @UserId from Emp_Login where UserId=@UserId and User_Password=@User_PasswordEND ``` \ ``` Proc_std_DeleteCREATE PROCEDURE [dbo].[Proc_std_Delete](@Enrollment_number int) ASBEGINIF NOT EXISTS (SELECT Enrollment_number FROM Std_Details                where  Enrollment_number = @Enrollment_number)                     begin                                                                   print 'Data does not exist or Enrollemt Id is wrong';                                                end                         elsebegin                   delete from Std_DetailswhereEnrollment_number = @Enrollment_numberprint 'Deleted record successfully';                                                         end     end ``` \ ``` ALTER PROCEDURE [dbo].[Proc_std_Info](@Enrollment_number int ,@Student_name varchar(50),@Father_Name varchar(50),@Mother_Name varchar(50),@Sex varchar(50),@Permanent_Add varchar(50),@Permanent_State varchar(50),@Subject_Maths varchar(30),@Subject_Physics varchar(30),@Subject_Chemistry varchar(30),@Subject_English varchar(30),@Subject_Hindi varchar(30),@Subject_Social varchar(30),@class varchar(30)) ASBEGINIF NOT EXISTS (SELECT Enrollment_number FROM Std_Details               where  Enrollment_number = @Enrollment_number)                     BEGININSERT INTO Std_Details (Enrollment_number,[Student_name],[Father_Name],[Mother_Name],[Sex],[Permanent_Add],[Permanent_State])values (@Enrollment_number,@Student_name,@Father_Name,@Mother_Name,@Sex,@Permanent_Add,@Permanent_State)                                                                                        INSERT INTO Std_Opt_Sub (Enrollment_number,[Subject_Maths],[Subject_Physics],[Subject_Chemistry],[Subject_English],[Subject_Hindi],[Subject_Social],[Opt_Begin_Date],[Opt_End_Date],[class])values (@Enrollment_number,@Subject_Maths,@Subject_Physics,@Subject_Chemistry,@Subject_English,@Subject_Hindi,@Subject_Social,GETDATE(),'2299-12-31',@class)                                          END                     else                                                begin                                                                   print 'Data already exist';                                                end      end  ``` \ ``` ALTER PROCEDURE [dbo].[Proc_std_Update](@Enrollment_number int ,@Student_name varchar(50),@Father_Name varchar(50),@Mother_Name varchar(50),@Sex varchar(50),@Permanent_Add varchar(50),@Permanent_State varchar(50),@Subject_Maths varchar(30),@Subject_Physics varchar(30),@Subject_Chemistry varchar(30),@Subject_English varchar(30),@Subject_Hindi varchar(30),@Subject_Social varchar(30),@class varchar(30)) ASBEGINIF NOT EXISTS (SELECT Enrollment_number FROM Std_Details               where  Enrollment_number = @Enrollment_number)                     begin                                                                   print 'Data does not exist or Enrollemt Id is wrong';                                                end                         elsebegin                              Update Std_Detailsset  Student_name= @Student_name,Father_Name=@Father_Name,Mother_Name=@Mother_Name,Sex=@Sex,Permanent_Add=@Permanent_Add,Permanent_State=@Permanent_State whereEnrollment_number = @Enrollment_number                                                                   Update Std_Opt_Sub set                         Subject_Maths=@Subject_Maths ,Subject_Physics=@Subject_Physics ,Subject_Chemistry=@Subject_Chemistry ,Subject_English=@Subject_English ,Subject_Hindi=@Subject_Hindi,Subject_Social=@Subject_Social,Class=@classwhere                                                 Enrollment_number = @Enrollment_number end     end ``` \ ``` ALTER PROCEDURE [dbo].[Proc_user_insert](@UserId varchar (30),@User_Password VARCHAR (100),@Name varchar(30),@Password_Hint varchar(30)) ASBEGINIF NOT EXISTS (SELECT UserId FROM User_information               where  @UserId = UserId)                     begin                                                                   insert into User_information ([UserId],[User_Password],[Name],[Password_Hint])                                                                   values (@UserId, @User_Password,@Name,@Password_Hint)                                                                   print 'Data Inserted Successfully';                                                           end   elsebegin           print 'Data Already Exist';                                                  end    end  ``` \ ``` ALTER PROCEDURE [dbo].[Proc_user_insert1](@UserId varchar (30),@User_Password varchar (100),@Name varchar(30),@Password_Hint varchar(30)) ASBEGINIF NOT EXISTS (SELECT UserId FROM User_information               where  @UserId = UserId)                     begin                                                                   insert into User_information ([UserId],[User_Password],[Name],[Password_Hint])                                                                   values (@UserId,HASHBYTES('SHA2_512',@User_Password),@Name,@Password_Hint)                                                                   print 'Data Inserted Successfully';                                                           end   elsebegin           print 'Data Already Exist';                                                  end    end ``` \ ``` ALTER PROCEDURE [dbo].[User_Info](@UserId varchar(50),@Old_Password varchar(50),@New_Password varchar(50),@confirm_new_password varchar(50),@Password_Hint varchar(50)) ASBEGIN          IF NOT EXISTS (SELECT UserId FROM User_information                          where  UserId = @UserId)                     BEGIN                               PRINT 'No Such UserId Exist'                     END        ELSE        begin           declare @checkpass varchar(30);                             set     @checkpass= (SELECT User_Password FROM User_information where  UserId = @UserId)                                                          if (@Checkpass<> @Old_Password)                                                          begin                                                          print 'old password is wrong'                                                          end                                                                                                                    ELSE                                                                             IF (@New_Password <> @confirm_new_password)                                                                                      BEGIN                                                                                      PRINT 'Password doesn''t match'                                                                                      END                                                                             ELSE                                                                                      BEGIN                                                                                      UPDATE  User_information                                                                                       SET User_Password= @confirm_new_password , Password_Hint= @Password_Hint                                                                                       WHERE UserId = @UserId                                                                             END                   END   END ``` ``` Code for from1using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient; namespace FormsApplication1{    public partial class Form1 : Form    {        public Form1()        {            InitializeComponent();        }       public  int i=0, j=0, k=0;        private void button1_Click(object sender, EventArgs e)        {   SqlConnection con = new SqlConnection();            con.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con.Open();                       SqlCommand cmd = new SqlCommand("Select UserId from User_information where UserId=@UserId and User_Password=@User_Password", con);            //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);            // cmd.CommandType = CommandType.StoredProcedure;            DataTable dt = new DataTable();            cmd.Parameters.AddWithValue("@UserId", textBox1.Text);            cmd.Parameters.AddWithValue("@User_Password", textBox2.Text);            SqlDataReader read = cmd.ExecuteReader();            read.Read();            if (textBox1.Text.Trim() == string.Empty)            {                MessageBox.Show("Userid need to be fill","Warning message");                i++;            }            else            {                if (textBox2.Text.Trim() == string.Empty)                {                    MessageBox.Show("Password Required!!", "Warning message");                    j++;                }                else                {                    if (read.HasRows)                    {                        //here you may redirect to another page like Response.Redirect("Page2.aspx");                        Form2 objfill = new Form2();                        objfill.Show();                        this.Hide();                         con.Close();                    }                    else                    {                        MessageBox.Show("Your UserId, Password or both are wrong ", "Error Message");                        k++;                    }                }            }            if (i > 3 )            {                MessageBox.Show("Attempt for Userid Is greater than 3, please reopen","Error Message");                this.Close();            }            if ( j > 3)            {                MessageBox.Show("Attempt for Password Is greater than 3, please repen and set your password","Error Messaage");                this.Close();            }            if (k>3)            {                MessageBox.Show("Attempt for Password Is greater than 3, please repen and set your password","Error Message");                this.Close();            }        }        private void button2_Click(object sender, EventArgs e)        {            Form3 F3 = new Form3();            F3.Show();        }        private void Form1_Load(object sender, EventArgs e)        {        }        private void textBox2_TextChanged(object sender, EventArgs e)        {            textBox2.MaxLength = 8;            textBox2.PasswordChar = '*';        }        private void textBox1_TextChanged(object sender, EventArgs e)        {            textBox1.MaxLength = 16;         }    }} ``` ``` Code for from2using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient;using System.Data.SqlTypes;  namespace FormsApplication1{    public partial class Form2 : Form    {        public Form2()        {            InitializeComponent();        }        private void button4_Click(object sender, EventArgs e)        {            this.Close();             Form1 objform1 = new Form1();            objform1.Show();        }        private void button1_Click(object sender, EventArgs e)        {            /* inserting a new details*/            SqlConnection con2 = new SqlConnection();            con2.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con2.Open();            SqlCommand savecom = new SqlCommand("Proc_std_Info", con2);            savecom.Connection = con2;            savecom.CommandType = CommandType.StoredProcedure;            savecom.Parameters.AddWithValue("@Student_name", textBox2.Text);            savecom.Parameters.AddWithValue("@Father_Name", textBox3.Text);            savecom.Parameters.AddWithValue("@Mother_Name", textBox4.Text);            if (radioButton1.Checked == true || radioButton2.Checked == true)            {                if (radioButton1.Checked == true)                {                    savecom.Parameters.AddWithValue("@Sex", "Male");                }                else                {                    savecom.Parameters.AddWithValue("@Sex", "Female");                }            }            else            {                savecom.Parameters.AddWithValue("@Sex", " ");            }            savecom.Parameters.AddWithValue("@Permanent_Add", textBox5.Text);            savecom.Parameters.AddWithValue("@Permanent_State",comboBox1.Text);            int a;            if (int.TryParse(textBox1.Text.ToString(), out a) || (textBox1.Text.Trim() == string.Empty))            {                                  if (checkBox1.Checked == true)                {                     savecom.Parameters.AddWithValue("@Subject_Maths", "Selected ");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Maths", "Not Selected");                }                if (checkBox2.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Physics", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Physics", "Not Selected");                }                 if (checkBox3.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Chemistry", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Chemistry", "Not Selected");                }                  if (checkBox4.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_English", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_English", "Not Selected");                }                 if (checkBox5.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Hindi ", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Hindi", "Not Selected");                }                if (checkBox6.Checked == true)                {                    savecom.Parameters.AddWithValue("@Subject_Social", "Selected");                }                else                {                    savecom.Parameters.AddWithValue("@Subject_Social", "Not Selected");                }                savecom.Parameters.AddWithValue("@Class", comboBox2.Text);                 if (textBox1.Text.Trim() == string.Empty)                {                    MessageBox.Show("Please enter the User Id","Warning message");                }                else                {                    savecom.Parameters.AddWithValue("@Enrollment_number", Convert.ToInt32(textBox1.Text));                    if (textBox2.Text.Trim() == string.Empty)                    {                        MessageBox.Show("Please enter Name");                    }                    else                    {                        if (radioButton1.Checked == false && radioButton2.Checked == false)                        {                            MessageBox.Show("Select male or female", "Warning message");                        }                        else                        {                            if (checkBox1.Checked == false && checkBox2.Checked == false && checkBox3.Checked == false && checkBox4.Checked == false && checkBox5.Checked == false && checkBox6.Checked == false)                            {                                 MessageBox.Show("Select At least one Subject", "Warning message");                             }                            else                            {                                                                SqlCommand cmd = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con2);                                //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                                // cmd.CommandType = CommandType.StoredProcedure;                                DataTable dt = new DataTable();                                cmd.Parameters.AddWithValue("@UserId", textBox1.Text);                                SqlDataReader read = cmd.ExecuteReader();                                read.Read();                                 if (read.HasRows)                                {                                    MessageBox.Show("Already Have data ","Informational Message");                                 }                                else                                {                                    read.Close();                                    savecom.ExecuteNonQuery();                                    SqlCommand cmd1 = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con2);                                    //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                                    // cmd.CommandType = CommandType.StoredProcedure;                                    DataTable dt1 = new DataTable();                                    cmd1.Parameters.AddWithValue("@UserId", textBox1.Text);                                    SqlDataReader read1 = cmd1.ExecuteReader();                                    read1.Read();                                    if (read1.HasRows)                                    {                                        MessageBox.Show("Inserted Successfully", "Congrats!!!");                                     }                                    else                                    {                                        MessageBox.Show("Enrollement Id Is not valid", "Error Message");                                    }                                }                            }                        }                    }                  }            }            else            {                MessageBox.Show("Please enter the correct format of enrollment id","Warning message");            }                         con2.Close();        }         private void button2_Click(object sender, EventArgs e)        {            /* inserting a new details*/            SqlConnection con3 = new SqlConnection();            con3.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con3.Open();            SqlCommand savecom = new SqlCommand("Proc_std_Update", con3);            savecom.Connection = con3;            savecom.CommandType = CommandType.StoredProcedure;                         savecom.Parameters.AddWithValue("@Student_name", textBox2.Text);            savecom.Parameters.AddWithValue("@Father_Name", textBox3.Text);            savecom.Parameters.AddWithValue("@Mother_Name", textBox4.Text);             if (radioButton1.Checked == true || radioButton2.Checked == true)            {                if (radioButton1.Checked == true)                {                    savecom.Parameters.AddWithValue("@Sex", "Male");                }                else                {                    savecom.Parameters.AddWithValue("@Sex", "Female");                }            }            else            {                savecom.Parameters.AddWithValue("@Sex", " ");             }                       savecom.Parameters.AddWithValue("@Permanent_Add", textBox5.Text);            savecom.Parameters.AddWithValue("@Permanent_State", comboBox1.Text);            int a;              if (int.TryParse(textBox1.Text.ToString(), out a) || (textBox1.Text.Trim() == string.Empty))            {                    if (checkBox1.Checked == true)                    {             savecom.Parameters.AddWithValue("@Subject_Maths", "Selected ");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Maths", "Not Selected");            }            if (checkBox2.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Physics", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Physics", "Not Selected");            }             if (checkBox3.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Chemistry", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Chemistry", "Not Selected");            }              if (checkBox4.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_English", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_English", "Not Selected");            }             if (checkBox5.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Hindi ", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Hindi", "Not Selected");            }            if (checkBox6.Checked == true)            {                savecom.Parameters.AddWithValue("@Subject_Social", "Selected");            }            else            {                savecom.Parameters.AddWithValue("@Subject_Social", "Not Selected");            }            savecom.Parameters.AddWithValue("@Class", comboBox2.Text);             if (textBox1.Text.Trim() == string.Empty)            {                MessageBox.Show("Please enter the User Id", "Warning message");            }            else            {                savecom.Parameters.AddWithValue("@Enrollment_number", Convert.ToInt32(textBox1.Text));                if (textBox2.Text.Trim() == string.Empty)                {                    MessageBox.Show("Please enter Name", "Warning message");                }                else                {                    if (radioButton1.Checked == false && radioButton2.Checked == false)                    {                        MessageBox.Show("Select male or female", "Warning message");                    }                    else                    {                        if (checkBox1.Checked == false && checkBox2.Checked == false && checkBox3.Checked == false && checkBox4.Checked == false && checkBox5.Checked == false && checkBox6.Checked == false)                        {                             MessageBox.Show("Select At least one Subject", "Warning message");                         }                        else                        {                            savecom.ExecuteNonQuery();                             SqlCommand cmd = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con3);                            //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                            // cmd.CommandType = CommandType.StoredProcedure;                            DataTable dt = new DataTable();                            cmd.Parameters.AddWithValue("@UserId", textBox1.Text);                            SqlDataReader read = cmd.ExecuteReader();                            read.Read();                             if (read.HasRows)                            {                                MessageBox.Show("Updated Successfully", "Congrats!!!");                              }                            else                            {                                MessageBox.Show("Enrollement Id Is not valid", "Error Message");                             }                        }                    }                }             }                         }            else            {                 MessageBox.Show("Please enter the correct format of enrollment id", "Warning message");            }                      con3.Close();         }        private void button5_Click(object sender, EventArgs e)        {            Form4 f4 = new Form4();            f4.Show();            f4.fill();        }         private void button3_Click(object sender, EventArgs e)        {            SqlConnection con6 = new SqlConnection();            con6.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con6.Open();            SqlCommand DeleteCom = new SqlCommand("Proc_std_Delete", con6);            DeleteCom.Connection = con6;            DeleteCom.CommandType = CommandType.StoredProcedure;                        int a;            if (int.TryParse(textBox1.Text.ToString(), out a) || (textBox1.Text.Trim() == string.Empty))            {                 DeleteCom.Parameters.AddWithValue("@Enrollment_number", textBox1.Text);                   SqlCommand cmd = new SqlCommand("Select Enrollment_number from Std_Details where Enrollment_number=@UserId", con6);                //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                // cmd.CommandType = CommandType.StoredProcedure;                DataTable dt = new DataTable();                cmd.Parameters.AddWithValue("@UserId", textBox1.Text);                SqlDataReader read = cmd.ExecuteReader();                read.Read();                 if (read.HasRows)                {                    DialogResult result2 = MessageBox.Show("Are you sure do you want to delete", "Question", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);                    if (result2 == DialogResult.Yes)                    {                        read.Close();                        DeleteCom.ExecuteNonQuery();                        MessageBox.Show("Deleted Successfully");                         this.Close();                        Form1 objlogin = new Form1();                        objlogin.Show();                    }                    else                    {                        MessageBox.Show("No Account has been updated ", "Informational Message");                    }                 }                else                {                    MessageBox.Show("Enrollement Id Is not valid or Already Deleted","Informatinal Error");                }            }            else            {                MessageBox.Show("Enrollement Id Format is not correct");            }                                  con6.Close();        }         public void textBox1_TextChanged(object sender, EventArgs e)        {             textBox1.MaxLength = 8;                    }         public void textBox2_TextChanged(object sender, EventArgs e)        {            textBox2.MaxLength = 16;        }         public void textBox3_TextChanged(object sender, EventArgs e)        {            textBox3.MaxLength = 16;        }         public void textBox4_TextChanged(object sender, EventArgs e)        {            textBox4.MaxLength = 16;        }         public void textBox5_TextChanged(object sender, EventArgs e)        {            textBox5.MaxLength = 20;        }         public void comboBox1_SelectedIndexChanged(object sender, EventArgs e)        {                   }         public void Form2_Load(object sender, EventArgs e)        {              SqlConnection concombostate = new SqlConnection();            concombostate.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            concombostate.Open();                SqlCommand sc = new SqlCommand("select List_of_state from Indian_state", concombostate);                SqlDataReader reader;                reader = sc.ExecuteReader();                DataTable dt = new DataTable();                dt.Columns.Add("List_of_state", typeof(string));                dt.Load(reader);                comboBox1.DisplayMember = "List_of_state";                comboBox1.DataSource = dt;             //   concombostate.Close();                comboBox1.SelectedIndex = -1;        }        }    }   ``` Code for form3 ``` using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient;namespace FormsApplication1{    public partial class Form3 : Form    {        public Form3()        {            InitializeComponent();        }         private void button1_Click(object sender, EventArgs e)        {            SqlConnection con = new SqlConnection();            con.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            con.Open();            SqlCommand cmdreset = new SqlCommand("User_Info", con);            cmdreset.Connection = con;            cmdreset.CommandType = CommandType.StoredProcedure;            cmdreset.Parameters.AddWithValue("@Old_Password", textBox1.Text);            cmdreset.Parameters.AddWithValue("@UserId", textBox5.Text);            cmdreset.Parameters.AddWithValue("@New_Password", textBox2.Text);            cmdreset.Parameters.AddWithValue("@confirm_new_password", textBox3.Text);            cmdreset.Parameters.AddWithValue("@Password_Hint", textBox4.Text);             if (textBox5.Text.Trim() == string.Empty)            {                MessageBox.Show("Userid required","Warning Message");             }            else            {                if (textBox1.Text.Trim() == string.Empty)                {                    MessageBox.Show("Old Password Required!!","Warning Message");                 }                else                {                    if (textBox2.Text.Trim() == string.Empty)                    {                        MessageBox.Show("New password required","Warning Message");                    }                    else                    {                        if (textBox3.Text.Trim() == string.Empty)                        {                            MessageBox.Show("Confirm Password Required","Warning Message");                        }                        else                        {                            cmdreset.ExecuteNonQuery();                            SqlCommand cmd = new SqlCommand("Select UserId from User_information where UserId=@UserId and User_Password=@User_Password", con);                            //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                            // cmd.CommandType = CommandType.StoredProcedure;                            DataTable dt = new DataTable();                            cmd.Parameters.AddWithValue("@UserId", textBox5.Text);                            cmd.Parameters.AddWithValue("@User_Password", textBox2.Text);                            SqlDataReader read = cmd.ExecuteReader();                            read.Read();                             if (read.HasRows)                            {                                //here you may redirect to another page like Response.Redirect("Page2.aspx");                                MessageBox.Show("Successfully changed the Password ","Contrats Message");                                read.Close();                                this.Close();                            }                            else                            {                                read.Close();                                 SqlCommand cmd1 = new SqlCommand("Select UserId from User_information where UserId=@UserId and User_Password=@User_Password", con);                                //   SqlCommand cmd = new SqlCommand("Login_Check_Sp", con);                                // cmd.CommandType = CommandType.StoredProcedure;                                DataTable dt1 = new DataTable();                                cmd1.Parameters.AddWithValue("@UserId", textBox5.Text);                                cmd1.Parameters.AddWithValue("@User_Password", textBox1.Text);                                SqlDataReader read1 = cmd1.ExecuteReader();                                read1.Read();                                 if (read1.HasRows)                                {                                    //here you may redirect to another page like Response.Redirect("Page2.aspx");                                    MessageBox.Show("Password mismatich ","Warning Message");                                    read1.Close();                                 }                                else                                {                                    MessageBox.Show("Old Password is wrong","Warning Message");                                }                            }                                                         con.Close();                                                   }                    }                }            }        }                      private void button2_Click  (object sender, EventArgs e)        {            this.Close();        }         private void textBox1_TextChanged(object sender, EventArgs e)        {            textBox1.PasswordChar = '*';            textBox1.MaxLength = 8;        }         private void textBox2_TextChanged(object sender, EventArgs e)        {            textBox2.PasswordChar = '*';            textBox2.MaxLength = 8;        }         private void textBox3_TextChanged(object sender, EventArgs e)        {            textBox3.PasswordChar = '*';            textBox3.MaxLength = 8;        }     }} ``` **Code for form4** ``` using System;using System.Collections.Generic;using System.ComponentModel;using System.Data;using System.Drawing;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Windows.Forms;using System.Data.SqlClient;using System.Data.SqlTypes; namespace FormsApplication1{    public partial class Form4 : Form    {         public Form4()        {            InitializeComponent();        }         public void fill()        {            SqlConnection con3 = new SqlConnection();            con3.ConnectionString = (@"Data Source=msclient-012\sqlexpress;Initial Catalog=testing_st;User ID=sa;Password=mindstick");            DataSet ds = new DataSet();             con3.Open();            SqlCommand cmd = new SqlCommand("select A.Enrollment_number,A.Student_name,A.Father_Name,A.Mother_Name,A.Sex,A.Permanent_Add,A.Permanent_State,B.Subject_Maths,B.Subject_Physics,B.Subject_Chemistry,B.Subject_English,B.Subject_Hindi,B.Subject_Social,B.class FROM Std_Details A,Std_Opt_Sub B where A.Enrollment_number = B.Enrollment_number", con3);            SqlDataAdapter da = new SqlDataAdapter();            da.SelectCommand = cmd;            da.Fill(ds);            dataGridView1.DataSource = ds.Tables[0];         }        public void dataGridView1_CellContentClick(object sender, DataGridViewCellEventArgs e)        {            // string profilename = dataGridView1.Rows[0].Cells[1].Value.ToString();            //            int a;            //          int.TryParse(profilename, out a);            //    Form2 f2 = new Form2();            //   f2.textBox1.Text = profilename;         }         public void dataGridView1_CellDoubleClick(object sender, DataGridViewCellEventArgs e)        {           /* Form2 f2 = new Form2();            f2.textBox1.Text = dataGridView1.CurrentRow.Cells["Enrollment_number"].Value.ToString();            this.Close();*/         }    }} ``` ![how to create form application using .NET.](data:image/png;base64,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) \ ![how to create form application using .NET.](data:image/png;base64,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)\ \ \ ![how to create form application using .NET.](data:image/png;base64,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) --- Original Source: https://www.mindstick.com/interview/23108/how-to-create-form-application-using-dot-net Copyright © MindStick Software Pvt. Ltd. This Markdown version is provided for developers, AI systems, and offline reading.