CRUD


Figure 1: Database

Sample Database

Let’s create a sample database named ‘SampleDB’ with SQL Management Studio. Using the ‘SampleDB’ now create a Table and name it ‘tblCustomer’.

Script

  1. CREATETABLE [dbo].[tblCustomer]
  2. (
  3. [CustID] [bigint] NOTNULL,
  4. [CustName] [nvarchar](50)NULL,
  5. [CustEmail] [nvarchar](50)NOTNULL,
  6. [CustAddress] [nvarchar](256)NULL,
  7. [CustContact] [nvarchar](50)NULL,
  8. CONSTRAINT [PK_tblCustomer] PRIMARYKEYCLUSTERED
  9. (
  10. [CustID] ASC,
  11. [CustEmail] ASC
  12. )WITH (PAD_INDEX=OFF,STATISTICS_NORECOMPUTE=OFF,IGNORE_DUP_KEY=OFF,ALLOW_ROW_LOCKS=ON,ALLOW_PAGE_LOCKS=ON)ON [PRIMARY]
  13. )ON [PRIMARY]
  15. GO
Stored Procedure

Now in the following step we will perform CRUD operations with stored procedure:
  1. First we will create a stored procedure (SP) to RETRIVE record from Customer table.
  2. Now we will create a stored procedure( SP) to INSERT record into Customer table.
  3. Now we will create another procedure (SP) to UPDATE existing data in our Customer table.
  4. The last step we will create a stored procedure to DELETE existing record from customer table.

Stored Procedure to RETRIVE Record

  1. ALTERPROCEDURE [dbo].[READ_CUSTOMER]
  2. -- Add the parameters for the stored procedure here
  3. @PageNo INT
  4. ,@RowCountPerPage INT
  5. ,@IsPaging INT
  6. AS
  7. BEGIN
  8. -- SET NOCOUNT ON added to prevent extra result sets from
  9. SETNOCOUNTON;
  10. -- Select statements for procedure here
  12. IF(@IsPaging = 0)
  13. BEGIN
  14. SELECTtop(@RowCountPerPage)*FROM [dbo].[tblCustomer]
  15. ORDERBY CustID DESC
  16. END
  18. IF(@IsPaging = 1)
  19. BEGIN
  20. DECLARE @SkipRow INT
  21. SET @SkipRow =(@PageNo - 1)* @RowCountPerPage
  23. SELECT*FROM [dbo].[tblCustomer]
  24. ORDERBY CustID DESC
  26. OFFSET @SkipRow ROWSFETCHNEXT @RowCountPerPage ROWS ONLY
  27. END
  28. END
Stored Procedure to INSERT Record
  1. ALTERPROCEDURE [dbo].[CREATE_CUSTOMER]
  2. -- Add the parameters for the stored procedure here
  3. (
  4. @CustName NVarchar(50)
  5. ,@CustEmail NVarchar(50)
  6. ,@CustAddress NVarchar(256)
  7. ,@CustContact NVarchar(50)
  8. )
  9. AS
  10. BEGIN
  11. ---- SET NOCOUNT ON added to prevent extra result sets from
  12. SETNOCOUNTON;
  14. ---- Try Catch--
  15. BEGINTRY
  16. BEGINTRANSACTION
  18. DECLARE @CustID Bigint
  19. SET @CustID =isnull(((SELECTmax(CustID)FROM [dbo].[tblCustomer])+1),'1')
  21. -- Insert statements for procedure here
  22. INSERTINTO [dbo].[tblCustomer]([CustID],[CustName],[CustEmail],[CustAddress],[CustContact])
  23. VALUES(@CustID,@CustName,@CustEmail,@CustAddress,@CustContact)
  24. SELECT 1
  25. COMMITTRANSACTION
  26. ENDTRY
  27. BEGINCATCH
  28. DECLARE @ErrorMessage NVARCHAR(4000),@ErrorSeverity INT,@ErrorState INT;
  29. SELECT @ErrorMessage =ERROR_MESSAGE(),@ErrorSeverity =ERROR_SEVERITY(),@ErrorState =ERROR_STATE();
  30. RAISERROR (@ErrorMessage,@ErrorSeverity,@ErrorState);
  31. ROLLBACKTRANSACTION
  32. ENDCATCH
  34. END
Stored Procedure to UPDATE Record
  1. ALTERPROCEDURE [dbo].[UPDATE_CUSTOMER]
  2. -- Add the parameters for the stored procedure here
  3. @CustID BIGINT
  4. ,@CustName NVarchar(50)
  5. ,@CustEmail NVarchar(50)
  6. ,@CustAddress NVarchar(256)
  7. ,@CustContact NVarchar(50)
  8. AS
  9. BEGIN
  10. ---- SET NOCOUNT ON added to prevent extra result sets from
  11. SETNOCOUNTON;
  13. ---- Try Catch--
  14. BEGINTRY
  15. BEGINTRANSACTION
  17. -- Update statements for procedure here
  18. UPDATE [dbo].[tblCustomer]
  19. SET [CustName] = @CustName,
  20. [CustAddress] = @CustAddress,
  21. [CustContact] = @CustContact
  22. WHERE [CustID] = @CustID AND [CustEmail] = @CustEmail
  23. SELECT 1
  24. COMMITTRANSACTION
  25. ENDTRY
  26. BEGINCATCH
  27. DECLARE @ErrorMessage NVARCHAR(4000),@ErrorSeverity INT,@ErrorState INT;
  28. SELECT @ErrorMessage =ERROR_MESSAGE(),@ErrorSeverity =ERROR_SEVERITY(),@ErrorState =ERROR_STATE();
  29. RAISERROR (@ErrorMessage,@ErrorSeverity,@ErrorState);
  30. ROLLBACKTRANSACTION
  31. ENDCATCH
  33. END
Stored Procedure to DELETE Record
  1. ALTERPROCEDURE [dbo].[DELETE_CUSTOMER]
  2. -- Add the parameters for the stored procedure here
  3. @CustID BIGINT
  4. AS
  5. BEGIN
  6. ---- SET NOCOUNT ON added to prevent extra result sets from
  7. SETNOCOUNTON;
  9. ---- Try Catch--
  10. BEGINTRY
  11. BEGINTRANSACTION
  13. -- Delete statements for procedure here
  14. DELETE [dbo].[tblCustomer]
  15. WHERE [CustID] = @CustID
  16. SELECT 1
  17. COMMITTRANSACTION
  18. ENDTRY
  19. BEGINCATCH
  20. DECLARE @ErrorMessage NVARCHAR(4000),@ErrorSeverity INT,@ErrorState INT;
  21. SELECT @ErrorMessage =ERROR_MESSAGE(),@ErrorSeverity =ERROR_SEVERITY(),@ErrorState =ERROR_STATE();
  22. RAISERROR (@ErrorMessage,@ErrorSeverity,@ErrorState);
  23. ROLLBACKTRANSACTION
  24. ENDCATCH
  26. END
Stored Procedure to VIEW Single Record Details
  1. ALTERPROCEDURE [dbo].[VIEW_CUSTOMER]
  2. -- Add the parameters for the stored procedure here
  3. @CustID BIGINT
  4. AS
  5. BEGIN
  6. -- SET NOCOUNT ON added to prevent extra result sets from
  7. SETNOCOUNTON;
  8. -- Select statements for procedure here
  10. SELECT*FROM [dbo].[tblCustomer]
  11. WHERE [CustID] = @CustID
  12. END
Let’s Start

Open Visual Studio 2015, Click File, New, then Project. In this window give a name to the project and solution.



Figure 2: Open VS

Click OK and another window will appear with project template; choose Web API.



Figure 3: Click Another

Click OK and the visual studio will create and load a new ASP.NET application template.

In this app we are going to apply CRUD operation on a single table named Customer. To do first we need to create API Controller for the operations. To add a new Controller file we need to right click and an option menu will appear. After that click Add, then Controller.



Figure 4: Add

Let’s name it CustomerController. In the controller we will create action methods to perform CRUD operations:



Figure 5: Crud

API Controller for CRUD operations
  1. namespace CRUD_APi.Controllers.apiController {
  2. [RoutePrefix("api/Customer")]
  3. publicclassCustomerController: ApiController {
  4. // GET: api/Customer?RowCount=5
  5. [HttpGet]
  6. publicIEnumerable < tblCustomer > GetCustomers(int pageSize) {
  7. try {
  8. int pageNumber = 0;
  9. int IsPaging = 0;
  10. CrudDataService objCrd = newCrudDataService();
  11. List < tblCustomer > modelCust = objCrd.GetCustomerList(pageNumber, pageSize, IsPaging);
  12. return modelCust;
  13. } catch {
  14. throw;
  15. }
  16. }
  18. // GET: api/Customer/InfinitScroll
  19. [HttpGet]
  20. publicIEnumerable < tblCustomer > GetCustomerScroll(int pageNumber, int pageSize) {
  21. try {
  22. int IsPaging = 1;
  23. CrudDataService objCrd = newCrudDataService();
  24. List < tblCustomer > modelCust = objCrd.GetCustomerList(pageNumber, pageSize, IsPaging);
  25. return modelCust;
  26. } catch (Exception ex) {
  27. throw ex;
  28. }
  29. }
  32. // GET: api/Customer/Create
  33. [HttpPost]
  34. [ResponseType(typeof(tblCustomer))]
  35. publicstring Create(tblCustomer objCust) {
  36. try {
  37. CrudDataService objCrd = newCrudDataService();
  38. Int32 message = 0;
  40. if ((objCust.CustName != null) && (objCust.CustEmail != null)) message = objCrd.InsertCustomer(objCust);
  41. else message = -1;
  42. return message.ToString();
  43. } catch {
  44. throw;
  45. }
  46. }
  48. // GET: api/Customer/Get
  49. [HttpGet]
  50. publictblCustomer GetCustomer(long ? id) {
  51. try {
  52. CrudDataService objCrd = newCrudDataService();
  53. tblCustomer modelCust = objCrd.GetCustomerDetails(id);
  54. return modelCust;
  55. } catch {
  56. throw;
  57. }
  58. }
  61. // GET: api/Customer/Edit
  62. [HttpPost]
  63. [ResponseType(typeof(tblCustomer))]
  64. publicstring Edit(tblCustomer objCust) {
  65. try {
  66. CrudDataService objCrd = newCrudDataService();
  67. Int32 message = 0;
  68. message = objCrd.UpdateCustomer(objCust);
  69. return message.ToString();
  71. } catch {
  72. throw;
  73. }
  74. }
  76. // GET: api/Customer/Delete
  77. [HttpDelete]
  78. publicstring Delete(long ? id) {
  79. try {
  80. CrudDataService objCrd = newCrudDataService();
  81. Int32 message = 0;
  82. message = objCrd.DeleteCustomer(id);
  83. return message.ToString();
  84. } catch {
  85. throw;
  86. }
  87. }
  88. }
  89. }
Data Service

As we know earlier that we will use ADO.NET and Stored Procedure and to connect the database we need to modify our config file to add Connection String for database connection.
  1. <connectionStrings>
  2. <addnameaddname="dbConn"connectionString="Data source=DESKTOP-4L9DM2J; Initial Catalog=SampleDB; User Id=sa; Password=sa@123"providerName="System.Data.SqlClient"/>
  3. </connectionStrings>
Now we need to create another class to use connection string and open our database connection, let’s name it dbConnector.
  1. // Database Connection
  2. publicclassdbConnector
  3. {
  4. privateSqlConnection SqlConn = null;
  6. publicSqlConnection GetConnection
  7. {
  8. get { return SqlConn; }
  9. set { SqlConn = value; }
  10. }
  12. public dbConnector()
  13. {
  14. string ConnectionString = ConfigurationManager.ConnectionStrings["dbConn"].ConnectionString;
  15. SqlConn = newSqlConnection(ConnectionString);
  16. }
  17. }
To perform CRUD operations we will create a separate class called CrudDataService. In this class we have five methods that will interact with the database to perform CRUD operations.
  1. // Database Service
  3. namespace CRUD_DataService {
  4. // Database Service
  5. publicclassCrudDataService {
  6. publicList < tblCustomer > GetCustomerList(int PageNo, int RowCountPerPage, int IsPaging) {
  7. dbConnector objConn = newdbConnector();
  8. SqlConnection Conn = objConn.GetConnection;
  9. Conn.Open();
  11. try {
  12. List < tblCustomer > _listCustomer = newList < tblCustomer > ();
  14. if (Conn.State != System.Data.ConnectionState.Open) Conn.Open();
  16. SqlCommand objCommand = newSqlCommand("READ_CUSTOMER", Conn);
  17. objCommand.CommandType = CommandType.StoredProcedure;
  18. objCommand.Parameters.AddWithValue("@PageNo", PageNo);
  19. objCommand.Parameters.AddWithValue("@RowCountPerPage", RowCountPerPage);
  20. objCommand.Parameters.AddWithValue("@IsPaging", IsPaging);
  21. SqlDataReader _Reader = objCommand.ExecuteReader();
  23. while (_Reader.Read()) {
  24. tblCustomer objCust = newtblCustomer();
  25. objCust.CustID = Convert.ToInt32(_Reader["CustID"]);
  26. objCust.CustName = _Reader["CustName"].ToString();
  27. objCust.CustEmail = _Reader["CustEmail"].ToString();
  28. objCust.CustAddress = _Reader["CustAddress"].ToString();
  29. objCust.CustContact = _Reader["CustContact"].ToString();
  30. _listCustomer.Add(objCust);
  31. }
  33. return _listCustomer;
  34. } catch {
  35. throw;
  36. } finally {
  37. if (Conn != null) {
  38. if (Conn.State == ConnectionState.Open) {
  39. Conn.Close();
  40. Conn.Dispose();
  41. }
  42. }
  43. }
  44. }
  46. publictblCustomer GetCustomerDetails(long ? id) {
  48. dbConnector objConn = newdbConnector();
  49. SqlConnection Conn = objConn.GetConnection;
  50. Conn.Open();
  52. try {
  53. tblCustomer objCust = newtblCustomer();
  55. if (Conn.State != System.Data.ConnectionState.Open) Conn.Open();
  57. SqlCommand objCommand = newSqlCommand("VIEW_CUSTOMER", Conn);
  58. objCommand.CommandType = CommandType.StoredProcedure;
  59. objCommand.Parameters.AddWithValue("@CustID", id);
  60. SqlDataReader _Reader = objCommand.ExecuteReader();
  62. while (_Reader.Read()) {
  63. objCust.CustID = Convert.ToInt32(_Reader["CustID"]);
  64. objCust.CustName = _Reader["CustName"].ToString();
  65. objCust.CustEmail = _Reader["CustEmail"].ToString();
  66. objCust.CustAddress = _Reader["CustAddress"].ToString();
  67. objCust.CustContact = _Reader["CustContact"].ToString();
  68. }
  70. return objCust;
  71. } catch {
  72. throw;
  73. } finally {
  74. if (Conn != null) {
  75. if (Conn.State == ConnectionState.Open) {
  76. Conn.Close();
  77. Conn.Dispose();
  78. }
  79. }
  80. }
  81. }
  83. publicInt32 InsertCustomer(tblCustomer objCust) {
  84. dbConnector objConn = newdbConnector();
  85. SqlConnection Conn = objConn.GetConnection;
  86. Conn.Open();
  88. int result = 0;
  90. try {
  91. if (Conn.State != System.Data.ConnectionState.Open) Conn.Open();
  93. SqlCommand objCommand = newSqlCommand("CREATE_CUSTOMER", Conn);
  94. objCommand.CommandType = CommandType.StoredProcedure;
  95. objCommand.Parameters.AddWithValue("@CustName", objCust.CustName);
  96. objCommand.Parameters.AddWithValue("@CustEmail", objCust.CustEmail);
  97. objCommand.Parameters.AddWithValue("@CustAddress", objCust.CustAddress);
  98. objCommand.Parameters.AddWithValue("@CustContact", objCust.CustContact);
  100. result = Convert.ToInt32(objCommand.ExecuteScalar());
  102. if (result > 0) {
  103. return result;
  104. } else {
  105. return 0;
  106. }
  107. } catch {
  108. throw;
  109. } finally {
  110. if (Conn != null) {
  111. if (Conn.State == ConnectionState.Open) {
  112. Conn.Close();
  113. Conn.Dispose();
  114. }
  115. }
  116. }
  117. }
  119. publicInt32 UpdateCustomer(tblCustomer objCust) {
  120. dbConnector objConn = newdbConnector();
  121. SqlConnection Conn = objConn.GetConnection;
  122. Conn.Open();
  124. int result = 0;
  126. try {
  127. if (Conn.State != System.Data.ConnectionState.Open) Conn.Open();
  129. SqlCommand objCommand = newSqlCommand("UPDATE_CUSTOMER", Conn);
  130. objCommand.CommandType = CommandType.StoredProcedure;
  131. objCommand.Parameters.AddWithValue("@CustID", objCust.CustID);
  132. objCommand.Parameters.AddWithValue("@CustName", objCust.CustName);
  133. objCommand.Parameters.AddWithValue("@CustEmail", objCust.CustEmail);
  134. objCommand.Parameters.AddWithValue("@CustAddress", objCust.CustAddress);
  135. objCommand.Parameters.AddWithValue("@CustContact", objCust.CustContact);
  137. result = Convert.ToInt32(objCommand.ExecuteScalar());
  139. if (result > 0) {
  140. return result;
  141. } else {
  142. return 0;
  143. }
  144. } catch {
  145. throw;
  146. } finally {
  147. if (Conn != null) {
  148. if (Conn.State == ConnectionState.Open) {
  149. Conn.Close();
  150. Conn.Dispose();
  151. }
  152. }
  153. }
  154. }
  156. publicInt32 DeleteCustomer(long ? id) {
  157. dbConnector objConn = newdbConnector();
  158. SqlConnection Conn = objConn.GetConnection;
  159. Conn.Open();
  161. int result = 0;
  163. try {
  164. if (Conn.State != System.Data.ConnectionState.Open) Conn.Open();
  166. SqlCommand objCommand = newSqlCommand("DELETE_CUSTOMER", Conn);
  167. objCommand.CommandType = CommandType.StoredProcedure;
  168. objCommand.Parameters.AddWithValue("@CustID", id);
  169. result = Convert.ToInt32(objCommand.ExecuteScalar());
  171. if (result > 0) {
  172. return result;
  173. } else {
  174. return 0;
  175. }
  176. } catch {
  177. throw;
  178. } finally {
  179. if (Conn != null) {
  180. if (Conn.State == ConnectionState.Open) {
  181. Conn.Close();
  182. Conn.Dispose();
  183. }
  184. }
  185. }
  186. }
  187. }
  188. }
Publish the Site in IIS



Figure 6: IIS

Let’s assign a port to access, In this case the site base url is: http://localhost:8081/.



Figure 7: Localhost

Let’s Create Windows Form Application

Open Visual Studio 2015, Click File, New, then Project. In this window give a name to the project and solution. This time we will create a Windows Form Application.



Figure 8: VS2015

In our new application let’s create a new Form and name it CRUDForm.cs



Figure 9: Crud Form

Our new form will look like the following screen:



Figure 10: new

In CRUD form we have a data grid which will load all data from the database through API controller.

Form Submission Code
  1. namespace CRUD_WF
  2. {
  3. publicpartialclassCRUDForm : Form
  4. {
  5. privateint pageNumber = 1;
  6. privateint pageSize = 0;
  7. privatestring baseUrl = string.Empty;
  8. privatestring url = string.Empty;
  10. public CRUDForm()
  11. {
  12. InitializeComponent();
  13. baseUrl = txtUrl.Text.ToString().Trim();
  14. pageSize = 5;
  15. url = baseUrl + "api/Customer?pageSize=" + pageSize;
  16. }
  18. privatevoid CRUDForm_Load(object sender, EventArgs e)
  19. {
  20. GetCustomer_(url);
  21. }
  23. privateasyncvoid GetCustomer_(string url)
  24. {
  25. try
  26. {
  27. using (var objClient = newHttpClient())
  28. {
  29. using (var response = await objClient.GetAsync(url))
  30. {
  31. if (response.IsSuccessStatusCode)
  32. {
  33. var productJsonString = await response.Content.ReadAsStringAsync();
  34. dgList.DataSource = JsonConvert.DeserializeObject<tblCustomer[]>(productJsonString).ToList();
  35. }
  36. }
  37. }
  38. }
  39. catch
  40. {
  41. pageSize = 5; pageNumber = 1;
  42. MessageBox.Show("Invalid URL!!");
  43. }
  44. }
  46. privatevoid btnSubmit_Click(object sender, EventArgs e)
  47. {
  48. if (btnSubmit.Text != "Update")
  49. {
  50. CreateCustomer();
  51. }
  52. else
  53. {
  54. if (lblCustID.Text == "")
  55. {
  56. MessageBox.Show("Please Select a Customer to Edit");
  57. }
  58. else
  59. {
  60. EditCustomer();
  61. }
  62. }
  63. }
  65. privateasyncvoid CreateCustomer()
  66. {
  67. try
  68. {
  69. string InsertUrl = baseUrl + "api/Customer/Create";
  70. tblCustomer objCust = newtblCustomer();
  71. objCust.CustName = txtCustName.Text.ToString();
  72. objCust.CustEmail = txtCustEmail.Text.ToString();
  73. objCust.CustAddress = txtCustAddress.Text.ToString();
  74. objCust.CustContact = txtCustContact.Text.ToString();
  76. if ((objCust != null) && (objCust.CustEmail != ""))
  77. {
  78. using (var objClient = newHttpClient())
  79. {
  80. string contentType = "application/json";
  81. var serializedCustomer = JsonConvert.SerializeObject(objCust);
  82. var content = newStringContent(serializedCustomer, Encoding.UTF8, contentType);
  83. var result = await objClient.PostAsync(InsertUrl, content);
  84. GetCustomer_(url);
  85. Clear();
  86. }
  87. }
  88. else
  89. {
  90. MessageBox.Show("Email Id is Must!");
  91. }
  92. }
  93. catch
  94. {
  95. MessageBox.Show("Invalid Customer!!");
  96. }
  97. }
  99. privateasyncvoid EditCustomer()
  100. {
  101. try
  102. {
  103. string EditUrl = baseUrl + "api/Customer/Edit";
  104. tblCustomer objCust = newtblCustomer();
  106. objCust.CustID = Convert.ToInt32(lblCustID.Text);
  107. objCust.CustName = txtCustName.Text.ToString();
  108. objCust.CustEmail = txtCustEmail.Text.ToString();
  109. objCust.CustAddress = txtCustAddress.Text.ToString();
  110. objCust.CustContact = txtCustContact.Text.ToString();
  112. if ((objCust != null) && (objCust.CustEmail != ""))
  113. {
  114. using (var objClient = newHttpClient())
  115. {
  116. string contentType = "application/json";
  117. var serializedCustomer = JsonConvert.SerializeObject(objCust);
  118. var content = newStringContent(serializedCustomer, Encoding.UTF8, contentType);
  119. var result = await objClient.PostAsync(EditUrl, content);
  120. GetCustomer_(url);
  121. }
  122. }
  123. else
  124. {
  125. MessageBox.Show("Email Id is Must!");
  126. }
  127. }
  128. catch
  129. {
  130. MessageBox.Show("Invalid Customer!!");
  131. }
  132. }
  134. privatevoid btnDelete_Click(object sender, EventArgs e)
  135. {
  136. try
  137. {
  138. if (lblCustID.Text == "")
  139. {
  140. MessageBox.Show("Please Select a Customer to Delete");
  141. }
  142. else
  143. {
  144. DialogResult result = MessageBox.Show("You are about to delete " + txtCustName.Text + " permanently. Are you sure you want to delete this record?", "Delete", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
  145. if (result.Equals(DialogResult.OK))
  146. {
  147. long CustID = Convert.ToInt64(lblCustID.Text);
  148. DeleteCustomer(CustID);
  149. }
  150. }
  151. }
  152. catch
  153. {
  154. MessageBox.Show("Invalid Customer!!");
  155. }
  156. }
  158. privateasyncvoid DeleteCustomer(long? id)
  159. {
  160. try
  161. {
  162. string DeleteUrl = baseUrl + "api/Customer/Delete";
  163. using (var objClient = newHttpClient())
  164. {
  165. var result = await objClient.DeleteAsync(String.Format("{0}/{1}", DeleteUrl, id));
  166. }
  168. GetCustomer_(url);
  169. }
  170. catch
  171. {
  172. MessageBox.Show("Invalid Customer!!");
  173. }
  174. }
  176. privatevoid btnNew_Click(object sender, EventArgs e)
  177. {
  178. Clear();
  179. }
  181. privatevoid btnReset_Click(object sender, EventArgs e)
  182. {
  183. Clear();
  184. }
  186. privatevoid Clear()
  187. {
  188. lblCustID.Text = "";
  189. txtCustName.Text = "";
  190. txtCustEmail.Text = "";
  191. txtCustAddress.Text = "";
  192. txtCustContact.Text = "";
  193. btnSubmit.Text = "Submit";
  194. txtCustEmail.ReadOnly = false;
  195. }
  197. privatevoid txtUrl_TextChanged(object sender, EventArgs e)
  198. {
  199. try
  200. {
  201. baseUrl = txtUrl.Text.ToString().Trim();
  202. }
  203. catch
  204. {
  205. MessageBox.Show("Invalid Approach!!");
  206. }
  207. }
  209. privatevoid btnNext_Click(object sender, EventArgs e)
  210. {
  211. try
  212. {
  213. if (pageNumber == 0)
  214. pageNumber = 1;
  216. pageSize = 5; pageNumber++;
  218. string url = baseUrl + "api/Customer?pageNumber=" + pageNumber + "&pageSize=" + pageSize;
  219. GetCustomer_(url);
  220. btnReload.Text = "Page View: " + pageNumber.ToString() + "/Reload..";
  221. }
  222. catch
  223. {
  224. MessageBox.Show("Invalid Approach!!");
  225. }
  226. }
  228. privatevoid btnPrev_Click(object sender, EventArgs e)
  229. {
  230. try
  231. {
  232. pageSize = 5; pageNumber--;
  233. if (pageNumber == 0)
  234. pageNumber = pageNumber + 1;
  236. string url = baseUrl + "api/Customer?pageNumber=" + pageNumber + "&pageSize=" + pageSize;
  237. GetCustomer_(url);
  238. btnReload.Text = "Page View: " + pageNumber.ToString() + "/Reload..";
  239. }
  240. catch
  241. {
  242. MessageBox.Show("Invalid Approach!!");
  243. }
  244. }
  246. privatevoid btnReload_Click(object sender, EventArgs e)
  247. {
  248. pageSize = 5;
  249. pageNumber = 1;
  250. GetCustomer_(url);
  251. btnReload.Text = "Reload..";
  252. }
  254. privatevoid dgList_SelectionChanged(object sender, EventArgs e)
  255. {
  256. try
  257. {
  258. if (dgList.SelectedCells.Count > 0)
  259. {
  260. int selectedrowindex = dgList.SelectedCells[0].RowIndex;
  261. DataGridViewRow selectedRow = dgList.Rows[selectedrowindex];
  263. lblCustID.Text = Convert.ToString(selectedRow.Cells[0].Value);
  264. txtCustName.Text = Convert.ToString(selectedRow.Cells[1].Value);
  265. txtCustEmail.Text = Convert.ToString(selectedRow.Cells[2].Value);
  266. txtCustAddress.Text = Convert.ToString(selectedRow.Cells[3].Value);
  267. txtCustContact.Text = Convert.ToString(selectedRow.Cells[4].Value);
  268. btnSubmit.Text = "Update";
  269. txtCustEmail.ReadOnly = true;
  270. }
  271. }
  272. catch
  273. {
  274. MessageBox.Show("Invalid Customer!!");
  275. }
  277. }
  278. }
  279. }
Desktop Application

In this stage we need to input the HTTP URL to perform CRUD Operation through API controller.



Figure 11: Web App

Web Application



Figure 12: Output

OUTPUT

Finally displaying data in both Web & Desktop Application at the same time using Web API.
Hope this will help someone. Thanks!