Database über DataGrid updaten

  • C#
  • .NET 5–6

Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von Yanbel.

    Database über DataGrid updaten

    Hallo, ich habe ein DataGrid in dem mir daten aus meiner Datenbank angezeigt werden. Wenn ich eine Zeile auswähle werden die daten in entsprechenden textboxen angezeigt, dh. der vorname wird in tbVorname andgezeigt. Jetzt würde ich gerne, wenn ich die textboxen bearbeite, die daten mit einem aktualisieren button geupdated werden. Das ist mein Code:

    C#-Quellcode

    1. private void Aktualisieren_Click(object sender, RoutedEventArgs e)
    2. {
    3. var sqlConnection = getSqlConnection();
    4. try
    5. {
    6. string query = "update MitgliedmitInfos (Vorname, Nachname, Land, Wohnort, Straße, Hausnummer, Emailadresse, Telefonnummer) values (@Vorname, @Nachname, @Land, @Wohnort, @Straße, @Hausnummer, @Emailadresse, @Telefonnummer) where Id = @Id";
    7. SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
    8. sqlConnection.Open();
    9. sqlCommand.Parameters.AddWithValue("@Id", grdMitglieder.SelectedItem);
    10. sqlCommand.Parameters.AddWithValue("@Vorname", tbVorname.Text);
    11. sqlCommand.Parameters.AddWithValue("@Nachname", tbNachname.Text);
    12. sqlCommand.Parameters.AddWithValue("@Land", tbLand.Text);
    13. sqlCommand.Parameters.AddWithValue("@Wohnort", tbStadt.Text);
    14. sqlCommand.Parameters.AddWithValue("@Straße", tbStraße.Text);
    15. sqlCommand.Parameters.AddWithValue("@Hausnummer", tbHausnr.Text);
    16. sqlCommand.Parameters.AddWithValue("@Emailadresse", tbEmail.Text);
    17. sqlCommand.Parameters.AddWithValue("@Telefonnummer", tbTelefon.Text);
    18. sqlCommand.ExecuteScalar();
    19. }
    20. catch (Exception ex)
    21. {
    22. MessageBox.Show(ex.ToString());
    23. }
    24. finally
    25. {
    26. sqlConnection.Close();
    27. FillDataGrid();
    28. }
    29. }


    Kann mir jemand helfen?

    LG Kathi

    *Topic verschoben*

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    Hey Kathi, kannst du noch den Code posten, wie die Daten im Grid landen? Dann kann ich dir da sicher helfen.

    EDIT: Oder wir fangen mal direkt an. Aus deinem Code-Beispiel schließe ich, dass du noch relativ neu in der Softwareentwicklung bist. Daher leite ich dich mal Schritt für Schritt durch die Basics. Es gibt ein paar Grundregeln die die generelle Entwicklung betreffen.

    Btw.: Mit der Architektur die du fährst hast du dir keinen Gefallen getan. SQL-Befehle an die Datenbank zu senden macht man heute eigentlich nicht mehr, weil es extrem aufwenig und auch sehr fehleranfällig ist. Hier gibt es sauberere Lösungen (Beispiel Entity Framework, typisierte Datasets, etc.). Das nur so am Rande. Aber ich gehe mal davon aus, dass du dich bewusst dafür entschieden hast.

    1.) Jedes Mal, wenn du mehrmals den gleichen Code schreibst, dann solltest du den Code auslagern. Statt beispielsweise immer wieder aufs neue eine SQL-Connections aufzubauen, kannst du dir eine Klasse mit Methoden schreiben, die das für dich übernimmt. Ich gebe dir hier ein Beispiel mit 4 Klassen, um es gleich sauber zu trennen. Namespaces lasse ich weg, die muss du dann selber dazuschreiben.

    DatabaseAccess

    C#-Quellcode

    1. public class DatabaseAccess
    2. {
    4. public int Timeout { get; set; }
    5. public Nullable<int> Identity { get; set; }
    7. public DataTable GetResultSet(string query, List<Parameter> parameters, bool silent, Setting setting = null)
    8. {
    9. try
    10. {
    11. DataTable result = new DataTable();
    12. SqlCredential cred = null;
    14. string constring = string.Empty;
    15. if (setting == null)
    16. {
    17. constring = Context.DatabaseConfig.GetConnectionString();
    18. cred = Context.DatabaseConfig.DefaultSetting.credentials;
    19. }
    20. else
    21. {
    22. constring = setting.GetConnectionString();
    23. cred = setting.credentials;
    24. }
    26. using (SqlConnection connection = new SqlConnection(constring, cred))
    27. {
    28. if (!(query.ToUpper().Contains("CREATE ") || query.ToUpper().Contains("ENABLE ") || query.ToUpper().Contains("DISABLE ")))
    29. {
    30. string newquery = "SET ARITHABORT ON";
    31. Framework.Text.Add(ref newquery, "SET DATEFORMAT dmy");
    32. Framework.Text.Add(ref newquery, query);
    33. query = newquery;
    34. }
    35. SqlCommand command = connection.CreateCommand();
    36. command.CommandType = CommandType.Text;
    37. command.CommandTimeout = Timeout;
    38. Timeout = 120;
    39. command.CommandText = query;
    41. if (parameters != null && parameters.Count > 0)
    42. {
    43. foreach (Parameter parameter in parameters)
    44. {
    45. if (parameter.Value != null)
    46. {
    47. command.Parameters.Add(parameter.GetSqlParameter());
    48. }
    49. else
    50. {
    51. command.Parameters.AddWithValue(parameter.Name, DBNull.Value);
    52. }
    53. }
    54. }
    56. if (connection.State != ConnectionState.Open)
    57. {
    58. connection.Open();
    59. }
    61. using (SqlDataAdapter reader = new SqlDataAdapter(command))
    62. {
    63. result.BeginLoadData();
    64. reader.Fill(result);
    65. result.EndLoadData();
    66. }
    67. }
    68. return result;
    69. }
    70. catch (Exception ex)
    71. {
    72. //Log-Methoden einfügen
    73. return null;
    74. }
    75. }
    77. public object GetResult(string query, dynamic defaultvalue, List<Parameter> parameters, bool silent, Setting setting = null)
    78. {
    79. try
    80. {
    81. object result;
    82. SqlCredential cred = null;
    83. string constring = string.Empty;
    84. if (setting == null)
    85. {
    86. constring = Context.DatabaseConfig.GetConnectionString();
    87. cred = Context.DatabaseConfig.credentials;
    88. }
    89. else
    90. {
    91. constring = setting.GetConnectionString();
    92. cred = setting.credentials;
    93. }
    95. using (SqlConnection connection = new SqlConnection(constring, cred))
    96. {
    97. if (!(query.ToUpper().Contains("CREATE ") || query.ToUpper().Contains("ENABLE ") || query.ToUpper().Contains("DISABLE ")))
    98. {
    99. string newquery = "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED";
    100. Framework.Text.Add(ref newquery, "SET DATEFORMAT dmy");
    101. Framework.Text.Add(ref newquery, query);
    102. query = newquery;
    103. }
    104. SqlCommand command = connection.CreateCommand();
    105. command.CommandType = CommandType.Text;
    106. command.CommandTimeout = Timeout;
    107. Timeout = 120;
    108. command.CommandText = query;
    110. if (parameters != null && parameters.Count > 0)
    111. {
    112. foreach (Parameter parameter in parameters)
    113. {
    114. if (parameter.Value != null)
    115. {
    116. command.Parameters.Add(parameter.GetSqlParameter());
    117. }
    118. else
    119. {
    120. command.Parameters.AddWithValue(parameter.Name, DBNull.Value);
    121. }
    122. }
    123. }
    125. if (connection.State != ConnectionState.Open)
    126. {
    127. connection.Open();
    128. }
    130. SqlDataReader reader = command.ExecuteReader(CommandBehavior.SingleRow);
    133. if (reader == null || Convert.IsDBNull(reader) || !reader.HasRows)
    134. {
    135. result = defaultvalue;
    136. }
    137. else
    138. {
    139. reader.Read();
    140. if (reader.GetValue(0) == null || Convert.IsDBNull(reader.GetValue(0)))
    141. {
    142. result = defaultvalue;
    143. }
    144. else
    145. {
    146. result = reader.GetValue(0);
    147. }
    148. }
    150. connection.Close();
    151. connection.Dispose();
    152. }
    153. return result;
    154. }
    155. catch (Exception ex)
    156. {
    157. //Log-Methoden einfügen
    158. return null;
    159. }
    160. }
    162. public bool Execute(string statement, List<Parameter> parameters, bool silent, Setting setting = null)
    163. {
    164. try
    165. {
    166. SqlCredential cred = null;
    167. string constring = string.Empty;
    168. if (setting == null)
    169. {
    170. constring = Context.DatabaseConfig.GetConnectionString();
    171. cred = Context.DatabaseConfig.credentials;
    172. }
    173. else
    174. {
    175. constring = setting.GetConnectionString();
    176. cred = setting.credentials;
    177. }
    179. using (SqlConnection connection = new SqlConnection(constring, cred))
    180. {
    181. if (!(statement.ToUpper().Contains("CREATE ") || statement.ToUpper().Contains("ENABLE ") || statement.ToUpper().Contains("DISABLE ")))
    182. {
    183. string newquery = "SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED ";
    184. Framework.Text.Add(ref newquery, "SET DATEFORMAT dmy ");
    185. Framework.Text.Add(ref newquery, statement);
    186. statement = newquery;
    187. }
    188. SqlCommand command = connection.CreateCommand();
    189. command.CommandType = CommandType.Text;
    190. command.CommandTimeout = Timeout;
    191. Timeout = 120;
    192. command.CommandText = statement;
    194. if (parameters != null && parameters.Count > 0)
    195. {
    196. foreach (Parameter parameter in parameters)
    197. {
    198. if (parameter.Value != null)
    199. {
    200. command.Parameters.Add(parameter.GetSqlParameter());
    201. }
    202. else
    203. {
    204. command.Parameters.AddWithValue(parameter.Name, DBNull.Value);
    205. }
    206. }
    207. }
    209. if (connection.State != ConnectionState.Open)
    210. {
    211. connection.Open();
    212. }
    213. int affected = command.ExecuteNonQuery();
    214. command.CommandText = "SELECT @@Identity";
    215. object ExecuteScalarValue = command.ExecuteScalar();
    217. if (!Convert.IsDBNull(ExecuteScalarValue) && ExecuteScalarValue != null)
    218. {
    219. Identity = Convert.ToInt32(ExecuteScalarValue);
    220. }
    221. else
    222. {
    223. Identity = null;
    224. }
    225. }
    226. return true;
    227. }
    228. catch (SqlException ex)
    229. {
    230. //Log-Methoden einfügen
    231. }
    232. catch (Exception ex)
    233. {
    234. //Log-Methoden einfügen
    235. }
    236. }
    237. }



    Dann fügst du dir eine weitere Klasse hinzu die du zum Beispiel "Parameter" nennst
    Parameter

    C#-Quellcode

    1. public class Parameter
    2. {
    3. public string Name { get; set; }
    4. public object Value { get; set; }
    6. public SqlParameter GetSqlParameter()
    7. {
    8. SqlParameter Param = new SqlParameter();
    9. if (Name.StartsWith("@")) { Param.ParameterName = Name; }
    10. else { Param.ParameterName = "@" + Name; }
    12. if (Value == null)
    13. {
    14. Param.SqlDbType = System.Data.SqlDbType.Variant;
    15. Param.Value = DBNull.Value;
    16. return Param;
    17. }
    18. else
    19. {
    20. switch (Value.GetType().Name.ToLower())
    21. {
    22. case "string":
    23. Param.SqlDbType = System.Data.SqlDbType.VarChar;
    24. Param.Value = Value.ToString();
    25. break;
    26. case "char":
    27. Param.SqlDbType = System.Data.SqlDbType.VarChar;
    28. Param.Value = Value.ToString();
    29. break;
    30. case "int":
    31. Param.SqlDbType = System.Data.SqlDbType.Int;
    32. Param.Value = Convert.ToInt32(Value);
    33. break;
    34. case "int32":
    35. Param.SqlDbType = System.Data.SqlDbType.Int;
    36. Param.Value = Convert.ToInt32(Value);
    37. break;
    38. case "long":
    39. Param.SqlDbType = System.Data.SqlDbType.BigInt;
    40. Param.Value = Convert.ToInt64(Value);
    41. break;
    42. case "int64":
    43. Param.SqlDbType = System.Data.SqlDbType.BigInt;
    44. Param.Value = Convert.ToInt64(Value);
    45. break;
    46. case "short":
    47. Param.SqlDbType = System.Data.SqlDbType.SmallInt;
    48. Param.Value = Convert.ToInt16(Value);
    49. break;
    50. case "int16":
    51. Param.SqlDbType = System.Data.SqlDbType.SmallInt;
    52. Param.Value = Convert.ToInt16(Value);
    53. break;
    54. case "bool":
    55. Param.SqlDbType = System.Data.SqlDbType.Bit;
    56. Param.Value = Convert.ToBoolean(Value);
    57. break;
    58. case "datetime":
    59. Param.SqlDbType = System.Data.SqlDbType.DateTime;
    60. Param.Value = Convert.ToDateTime(Value);
    61. break;
    62. case "double":
    63. Param.SqlDbType = System.Data.SqlDbType.Decimal;
    64. Param.Value = Convert.ToDouble(Value);
    65. break;
    66. case "single":
    67. Param.SqlDbType = System.Data.SqlDbType.Decimal;
    68. Param.Value = Convert.ToDouble(Value);
    69. break;
    70. case "decimal":
    71. Param.SqlDbType = System.Data.SqlDbType.Decimal;
    72. Param.Value = Convert.ToDouble(Value);
    73. break;
    74. default:
    75. if (Value.GetType().Name.ToLower().StartsWith("nullable"))
    76. {
    77. switch (Value.GetType().UnderlyingSystemType.Name.ToLower())
    78. {
    79. case "string":
    80. Param.SqlDbType = System.Data.SqlDbType.VarChar;
    81. Param.Value = Value.ToString();
    82. break;
    83. case "char":
    84. Param.SqlDbType = System.Data.SqlDbType.VarChar;
    85. Param.Value = Value.ToString();
    86. break;
    87. case "int":
    88. Param.SqlDbType = System.Data.SqlDbType.Int;
    89. Param.Value = Convert.ToInt32(Value);
    90. break;
    91. case "int32":
    92. Param.SqlDbType = System.Data.SqlDbType.Int;
    93. Param.Value = Convert.ToInt32(Value);
    94. break;
    95. case "long":
    96. Param.SqlDbType = System.Data.SqlDbType.BigInt;
    97. Param.Value = Convert.ToInt64(Value);
    98. break;
    99. case "int64":
    100. Param.SqlDbType = System.Data.SqlDbType.BigInt;
    101. Param.Value = Convert.ToInt64(Value);
    102. break;
    103. case "short":
    104. Param.SqlDbType = System.Data.SqlDbType.SmallInt;
    105. Param.Value = Convert.ToInt16(Value);
    106. break;
    107. case "int16":
    108. Param.SqlDbType = System.Data.SqlDbType.SmallInt;
    109. Param.Value = Convert.ToInt16(Value);
    110. break;
    111. case "bool":
    112. Param.SqlDbType = System.Data.SqlDbType.Bit;
    113. Param.Value = Convert.ToBoolean(Value);
    114. break;
    115. case "datetime":
    116. Param.SqlDbType = System.Data.SqlDbType.DateTime;
    117. Param.Value = Convert.ToDateTime(Value);
    118. break;
    119. case "double":
    120. Param.SqlDbType = System.Data.SqlDbType.Decimal;
    121. Param.Value = Convert.ToDouble(Value);
    122. break;
    123. case "single":
    124. Param.SqlDbType = System.Data.SqlDbType.Decimal;
    125. Param.Value = Convert.ToDouble(Value);
    126. break;
    127. case "decimal":
    128. Param.SqlDbType = System.Data.SqlDbType.Decimal;
    129. Param.Value = Convert.ToDouble(Value);
    130. break;
    131. default:
    132. Param.SqlDbType = System.Data.SqlDbType.VarChar;
    133. Param.Value = Value.ToString();
    134. break;
    135. }
    136. }
    137. else
    138. {
    139. Param.SqlDbType = System.Data.SqlDbType.VarChar;
    140. Param.Value = Value.ToString();
    141. break;
    142. }
    143. break;
    144. }
    145. }
    146. return Param;
    147. }
    149. }



    Und dann noch eine die du Configuration nennst:
    Configuration

    C#-Quellcode

    1. public class Configuration
    2. {
    3. public string Designation { get; set; }
    4. public string Host { get; set; }
    5. public string Database { get; set; }
    7. private string _User;
    8. public string User
    9. {
    10. set
    11. {
    12. if (!string.IsNullOrWhiteSpace(value))
    13. {
    14. _User = value;
    15. if (_password != null)
    16. {
    17. credentials = new SqlCredential(_User, _password);
    18. }
    19. }
    20. else
    21. {
    22. credentials = null;
    23. }
    24. }
    25. }
    27. private System.Security.SecureString _password;
    28. public string password
    29. {
    30. set
    31. {
    32. if (!string.IsNullOrWhiteSpace(value))
    33. {
    34. _password = new System.Security.SecureString();
    35. foreach (char c in value)
    36. {
    37. _password.AppendChar(c);
    38. }
    39. _password.MakeReadOnly();
    40. if (!string.IsNullOrWhiteSpace(_User))
    41. {
    42. credentials = new SqlCredential(_User, _password);
    43. }
    44. }
    45. else
    46. {
    47. credentials = null;
    48. }
    49. }
    50. }
    52. public SqlCredential credentials { get; set; }
    54. public string GetConnectionString()
    55. {
    56. if (credentials != null)
    57. {
    58. SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(string.Concat("Data Source=", Host, ";Initial Catalog=", Database, ";"));
    59. builder.Remove("User ID");
    60. builder.Remove("Password");
    61. builder.IntegratedSecurity = false;
    62. return builder.ConnectionString;
    63. }
    64. else
    65. {
    66. SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(string.Concat("Data Source=", Host, ";Initial Catalog=", Database, ";"));
    67. builder.Remove("User ID");
    68. builder.Remove("Password");
    69. builder.IntegratedSecurity = true;
    70. return builder.ConnectionString;
    71. }
    72. }
    73. }



    und zum Schluss noch eine statischen Klasse:

    "Context"

    C#-Quellcode

    C#-Quellcode

    1. public static class Context
    2. {
    3. public static Configuration DatabaseConfig { get; set;}
    4. }



    Zum Start deiner Application musst du dann noch folgenden Code (natürlich mit deinen eigenen Datenbank-Infos) einfügen:

    C#-Quellcode

    1. Context.DatabaseConfig = new Shared.Database.Setting { Host = "127.0.0.1", Database = "TestDB", User = "TestUser", password = "123456789" };


    Damit der Framework-Part abgeschlossen. Optimalerweise baust du jetzt noch einen Data-Layer, aber das würde hier jetzt den Rahmen sprengen. Also nur die "Quick and Dirty"-Variante:
    Code für die Form

    C#-Quellcode

    1. private bool InsertOrUpdateMitglied()
    2. {
    3. List<Parameter> Parameters = new List<Parameter>()
    4. {
    5. new Parameter() { Name = "@Id", Value = grdMitglieder.SelectedItem },
    6. new Parameter() { Name = "@Vorname", Value = tbVorname.Text },
    7. new Parameter() { Name = "@Nachname", Value = tbNachname.Text },
    8. new Parameter() { Name = "@Land", Value = tbLand.Text },
    9. new Parameter() { Name = "@Wohnort", Value = tbStadt.Text },
    10. new Parameter() { Name = "@Straße", Value = tbStraße.Text },
    11. new Parameter() { Name = "@Hausnummer", Value = tbHausnr.Text },
    12. new Parameter() { Name = "@Emailadresse", Value = tbEmail.Text },
    13. new Parameter() { Name = "@Telefonnummer", Value = tbTelefon.Text }
    14. };
    16. string Query = string.Empty;
    17. Add(ref Query, "IF NOT EXISTS ");
    18. Add(ref Query, "(SELECT * FROM MitgliedmitInfos ");
    19. Add(ref Query, "WHERE ");
    20. Add(ref Query, "AND Id = @Id");
    21. Add(ref Query, ") ");
    22. Add(ref Query, "INSERT INTO MitgliedmitInfos ");
    23. Add(ref Query, "( ");
    24. Add(ref Query, "Vorname, ");
    25. Add(ref Query, "Nachname, ");
    26. Add(ref Query, "Land, ");
    27. Add(ref Query, "Straße, ");
    28. Add(ref Query, "Hausnummer, ");
    29. Add(ref Query, "Emailadresse, ");
    30. Add(ref Query, "Telefon");
    31. Add(ref Query, ") ");
    32. Add(ref Query, "VALUES ");
    33. Add(ref Query, "( ");
    34. Add(ref Query, "@Vorname, ");
    35. Add(ref Query, "@Nachname, ");
    36. Add(ref Query, "@Land, ");
    37. Add(ref Query, "@Straße, ");
    38. Add(ref Query, "@Hausnummer, ");
    39. Add(ref Query, "@Emailadresse, ");
    40. Add(ref Query, "@Telefon");
    41. Add(ref Query, ") ");
    42. Add(ref Query, "ELSE ");
    43. Add(ref Query, "UPDATE MitgliedmitInfos ");
    44. Add(ref Query, "SET ");
    45. Add(ref Query, "Vorname = @Vorname, ");
    46. Add(ref Query, "Nachname = @Nachname, ");
    47. Add(ref Query, "Land = @Land, ");
    48. Add(ref Query, "Straße = @Straße, ");
    49. Add(ref Query, "Hausnummer = @Hausnummer, ");
    50. Add(ref Query, "Emailadresse = @Emailadresse, ");
    51. Add(ref Query, "Telefon = @Telefon");
    52. Add(ref Query, "WHERE ");
    53. Add(ref Query, "AND Id = @Id");
    54. DatabaseAccess DBAccessor = new DatabaseAccess();
    55. return DBAccessor.Execute(Query, Parameters, false);
    56. }
    58. private void Add(ref string Text, string AddText)
    59. {
    60. if (string.IsNullOrWhiteSpace(Text))
    61. {
    62. Text = AddText;
    63. }
    64. else
    65. {
    66. Text = Text + Environment.NewLine + AddText;
    67. }
    68. }
    70. private void Aktualisieren_Click(object sender, RoutedEventArgs e)
    71. {
    72. InsertOrUpdateMitglied();
    73. }



    Der Vorteil an dieser Stelle ist, egal an welcher Stelle du jetzt ein Mitglied updaten willst, an welcher Stelle du dich zur Datenbank verbinden willst, es reichen diese zwei Zeilen um einen Befehl zu senden:

    C#-Quellcode

    1. (new DatabaseAccess()).Execute("SQLBefehl", Parameters, false);

    oder Daten abzurufen:

    C#-Quellcode

    1. DataTable ResultSet = (new DatabaseAccess()).GetResultSet("SQLBefehl", Parameters, false);


    Wenn ich weiß wie deine Daten ins DataGridView geladen werden, dann machen wir den Rest, falls du Interesse hast.

    Ein Computer wird das tun, was du programmierst - nicht das, was du willst.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Yanbel“ ()

    Hi Yanbel, vielen danke, ich arbeite mit einem DataGrid, nicht DataGridView, ich weiß nicht inwiefern das einen unterschied macht.

    Das ist mein Code um das DataGrid zu füllen

    C#-Quellcode

    1. private void FillDataGrid()
    2. {
    3. var sqlConnection = getSqlConnection();
    4. try
    5. {
    6. string CmdString = string.Empty;
    7. using (SqlConnection con = getSqlConnection())
    8. {
    9. CmdString = "SELECT * FROM MitgliedmitInfos";
    10. SqlCommand cmd = new SqlCommand(CmdString, con);
    11. SqlDataAdapter sda = new SqlDataAdapter(cmd);
    12. DataTable dt = new DataTable();
    13. sda.Fill(dt);
    14. grdMitglieder.ItemsSource = dt.DefaultView;
    15. }
    16. }
    17. catch (Exception e)
    18. {
    19. MessageBox.Show(e.ToString());
    20. }
    21. }


    Ich habe meine DataBase Connection so hergestellt:

    C#-Quellcode

    1. private SqlConnection getSqlConnection()
    2. {
    3. string ConString = ConfigurationManager.ConnectionStrings["ConString"].ConnectionString;
    4. SqlConnection sqlConnection = new SqlConnection(ConString);
    5. return sqlConnection;
    6. }


    Ich lade hier mal meinen gesamten code hoch:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Configuration;
    3. using System.Data;
    4. using System.Data.OleDb;
    5. using System.Data.SqlClient;
    6. using System.Windows;
    7. using System.Windows.Controls;
    9. namespace Projekt
    10. {
    11. public partial class Window2 : Window
    12. {
    13. public Window2()
    14. {
    15. InitializeComponent();
    16. FillDataGrid();
    17. }
    18. private void FillDataGrid()
    19. {
    20. var sqlConnection = getSqlConnection();
    21. try
    22. {
    23. string CmdString = string.Empty;
    24. using (SqlConnection con = getSqlConnection())
    25. {
    26. CmdString = "SELECT * FROM MitgliedmitInfos";
    27. SqlCommand cmd = new SqlCommand(CmdString, con);
    28. SqlDataAdapter sda = new SqlDataAdapter(cmd);
    29. DataTable dt = new DataTable();
    30. sda.Fill(dt);
    31. grdMitglieder.ItemsSource = dt.DefaultView;
    32. }
    33. }
    34. catch (Exception e)
    35. {
    36. MessageBox.Show(e.ToString());
    37. }
    38. }
    39. private SqlConnection getSqlConnection()
    40. {
    41. string ConString = ConfigurationManager.ConnectionStrings["ConString"].ConnectionString;
    42. SqlConnection sqlConnection = new SqlConnection(ConString);
    43. return sqlConnection;
    44. }
    45. private void Save()
    46. {
    47. var sqlConnection = getSqlConnection();
    48. try
    49. {
    50. string query = "insert into MitgliedmitInfos (Vorname, Nachname, Land, Wohnort, Straße, Hausnummer, Emailadresse, Telefonnummer) values (@Vorname, @Nachname, @Land, @Wohnort, @Straße, @Hausnummer, @Emailadresse, @Telefonnummer)";
    51. SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
    52. sqlConnection.Open();
    53. sqlCommand.Parameters.AddWithValue("@Vorname", tbVorname.Text);
    54. sqlCommand.Parameters.AddWithValue("@Nachname", tbNachname.Text);
    55. sqlCommand.Parameters.AddWithValue("@Land", tbLand.Text);
    56. sqlCommand.Parameters.AddWithValue("@Wohnort", tbStadt.Text);
    57. sqlCommand.Parameters.AddWithValue("@Straße", tbStraße.Text);
    58. sqlCommand.Parameters.AddWithValue("@Hausnummer", tbHausnr.Text);
    59. sqlCommand.Parameters.AddWithValue("@Emailadresse", tbEmail.Text);
    60. sqlCommand.Parameters.AddWithValue("@Telefonnummer", tbTelefon.Text);
    61. sqlCommand.ExecuteScalar();
    62. }
    63. catch (Exception ex)
    64. {
    65. MessageBox.Show(ex.ToString());
    66. }
    67. finally
    68. {
    69. sqlConnection.Close();
    70. FillDataGrid();
    71. }
    72. }
    74. private void ButtonSpeichern_Click(object sender, RoutedEventArgs e)
    75. {
    76. Save();
    77. }
    79. private void Löschen_Click(object sender, RoutedEventArgs e)
    80. {
    81. var selectedItem = (DataRowView)grdMitglieder.SelectedItem;
    82. var sId = selectedItem["Id"].ToString();
    83. var id = selectedItem.Row.Field<int>("Id");
    84. var sqlConnection = getSqlConnection();
    85. try
    86. {
    87. string query = "delete from MitgliedmitInfos where Id = @MitgliedId";
    88. SqlCommand sqlcommand = new SqlCommand(query, sqlConnection);
    89. sqlConnection.Open();
    90. sqlcommand.Parameters.AddWithValue("@MitgliedId", id);
    91. sqlcommand.ExecuteScalar();
    92. }
    93. catch (Exception)
    94. {
    95. MessageBox.Show("Fehler beim Löschen, bite geben Sie eine existierende Id an");
    96. }
    97. finally
    98. {
    99. sqlConnection.Close();
    100. FillDataGrid();
    101. }
    102. }
    104. private void Aktualisieren_Click(object sender, RoutedEventArgs e)
    105. {
    106. var sqlConnection = getSqlConnection();
    107. try
    108. {
    109. string query = "update MitgliedmitInfos (Vorname, Nachname, Land, Wohnort, Straße, Hausnummer, Emailadresse, Telefonnummer) values (@Vorname, @Nachname, @Land, @Wohnort, @Straße, @Hausnummer, @Emailadresse, @Telefonnummer) where Id = @Id";
    110. SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
    111. sqlConnection.Open();
    112. sqlCommand.Parameters.AddWithValue("@Id", grdMitglieder.SelectedItem);
    113. sqlCommand.Parameters.AddWithValue("@Vorname", tbVorname.Text);
    114. sqlCommand.Parameters.AddWithValue("@Nachname", tbNachname.Text);
    115. sqlCommand.Parameters.AddWithValue("@Land", tbLand.Text);
    116. sqlCommand.Parameters.AddWithValue("@Wohnort", tbStadt.Text);
    117. sqlCommand.Parameters.AddWithValue("@Straße", tbStraße.Text);
    118. sqlCommand.Parameters.AddWithValue("@Hausnummer", tbHausnr.Text);
    119. sqlCommand.Parameters.AddWithValue("@Emailadresse", tbEmail.Text);
    120. sqlCommand.Parameters.AddWithValue("@Telefonnummer", tbTelefon.Text);
    121. sqlCommand.ExecuteScalar();
    122. }
    123. catch (Exception ex)
    124. {
    125. MessageBox.Show(ex.ToString());
    126. }
    127. finally
    128. {
    129. sqlConnection.Close();
    130. FillDataGrid();
    131. }
    132. }
    134. private void GrdMitglieder_SelectionChanged(object sender, SelectionChangedEventArgs e)
    135. {
    136. var sqlConnection = getSqlConnection();
    137. try
    138. {
    139. var selectedItem = (DataRowView)grdMitglieder.SelectedItem;
    140. var sId = selectedItem["Id"].ToString();
    141. var id = selectedItem.Row.Field<int>("Id");
    142. string query = "select Vorname, Nachname, Land, Wohnort, Straße, Hausnummer, Emailadresse, Telefonnummer from MitgliedmitInfos where Id = @Id";
    143. SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
    144. SqlDataAdapter sqlDataAdapter = new SqlDataAdapter(sqlCommand);
    145. using (sqlDataAdapter)
    146. {
    147. sqlCommand.Parameters.AddWithValue("@Id", id);
    148. DataTable mitgliedTable = new DataTable();
    149. sqlDataAdapter.Fill(mitgliedTable);
    150. tbVorname.Text = mitgliedTable.Rows[0]["Vorname"].ToString();
    151. tbNachname.Text = mitgliedTable.Rows[0]["Nachname"].ToString();
    152. tbLand.Text = mitgliedTable.Rows[0]["Land"].ToString();
    153. tbStadt.Text = mitgliedTable.Rows[0]["Wohnort"].ToString();
    154. tbStraße.Text = mitgliedTable.Rows[0]["Straße"].ToString();
    155. tbHausnr.Text = mitgliedTable.Rows[0]["Hausnummer"].ToString();
    156. tbEmail.Text = mitgliedTable.Rows[0]["Emailadresse"].ToString();
    157. tbTelefon.Text = mitgliedTable.Rows[0]["Telefonnummer"].ToString();
    158. }
    159. }
    160. catch (Exception ex)
    161. {
    162. //MessageBox.Show(ex.ToString());
    163. }
    164. }
    165. }
    166. }

    XML-Quellcode

    1. <Window x:Class="Projekt.Window2"
    2. xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    3. xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    4. xmlns:Icon="http://metro.mahapps.com/winfx/xaml/iconpacks"
    5. Title="Window2" Height="720" Width="1080">
    6. <Grid>
    7. <DataGrid Name="grdMitglieder" HorizontalAlignment="Left" Height="539" Margin="10,13,0,0" VerticalAlignment="Top" Width="1057" SelectionChanged="GrdMitglieder_SelectionChanged"/>
    8. <TextBox Name="tbVorname" HorizontalAlignment="Left" Height="23" Margin="11,557,0,0" TextWrapping="Wrap" Text="Vorname" VerticalAlignment="Top" Width="120"/>
    9. <TextBox Name="tbNachname" HorizontalAlignment="Left" Height="23" Margin="136,557,0,0" TextWrapping="Wrap" Text="Nachname" VerticalAlignment="Top" Width="120"/>
    10. <TextBox Name="tbLand" HorizontalAlignment="Left" Height="23" Margin="11,585,0,0" TextWrapping="Wrap" Text="Land" VerticalAlignment="Top" Width="120"/>
    11. <TextBox Name="tbStadt" HorizontalAlignment="Left" Height="23" Margin="136,585,0,0" TextWrapping="Wrap" Text="Stadt" VerticalAlignment="Top" Width="120"/>
    12. <TextBox Name="tbStraße" HorizontalAlignment="Left" Height="23" Margin="261,571,0,0" TextWrapping="Wrap" Text="Straße" VerticalAlignment="Top" Width="120" RenderTransformOrigin="0.5,0.478"/>
    13. <TextBox Name="tbHausnr" HorizontalAlignment="Left" Height="23" Margin="261,599,0,0" TextWrapping="Wrap" Text="Hausnummer" VerticalAlignment="Top" Width="120"/>
    14. <TextBox Name="tbEmail" HorizontalAlignment="Left" Height="23" Margin="11,613,0,0" TextWrapping="Wrap" Text="Emailadresse" VerticalAlignment="Top" Width="120"/>
    15. <TextBox Name="tbTelefon" HorizontalAlignment="Left" Height="23" Margin="136,613,0,0" TextWrapping="Wrap" Text="Telefonnummer" VerticalAlignment="Top" Width="120"/>
    16. <Button Name="Speichern" Content="Speichern" HorizontalAlignment="Left" Margin="938,557,0,53" Width="129" Click="ButtonSpeichern_Click"/>
    17. <Button Name="Löschen" Content="Löschen" HorizontalAlignment="Left" Margin="804,557,0,0" VerticalAlignment="Top" Width="129" Height="79" Click="Löschen_Click"/>
    18. <Button Content="Aktualisieren" HorizontalAlignment="Left" Margin="666,557,0,0" VerticalAlignment="Top" Width="133" Height="79" Click="Aktualisieren_Click"/>
    19. </Grid>
    20. </Window>


    *Code-Tag korrigiert, Spoiler wg. überlangem Code eingefügt*

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Marcus Gräfe“ ()

    C#-Quellcode

    1. sqlCommand.Parameters.AddWithValue("@Id", grdMitglieder.SelectedItem);


    Das dürfte dein Problem sein. In der Löschen-Methode hast du das so geschrieben:

    C#-Quellcode

    1. var selectedItem = (DataRowView)grdMitglieder.SelectedItem;
    2. var sId = selectedItem["Id"].ToString();
    3. var id = selectedItem.Row.Field<int>("Id");
    4. ...
    5. sqlCommand.Parameters.AddWithValue("@Id", id);


    Kann das leider gerade nicht nachstellen oder testen. Ist nur eine Vermutung.

    EDIT: Ich habe dir mal ein Projekt gebastelt, wie ich die Datenstruktur innerhalb deiner Architektur aufsetzen würde. Das dürfte dir das Leben an der Stelle deutlich erleichtern.

    Du kannst dann jede Bearbeitung mit einer Zeile Programmcode machen:

    C#-Quellcode

    1. grdMitglieder.ItemsSource = Mitglied.Create().Get(new Data.Parameters.Mitglied()).ToDataTable().DefaultView();
    Dateien

    • Projekt.zip

      (127,73 kB, 77 mal heruntergeladen, zuletzt: )

    Ein Computer wird das tun, was du programmierst - nicht das, was du willst.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Yanbel“ ()

    Hab es gelöst, ich habe speichern und updaten auf einen button zusammen gefasst, das ist der code dafür:

    C#-Quellcode

    1. private void SpeichernUpdateMitglied()
    2. {
    3. try
    4. {
    5. var selectedItem = (DataRowView)grdMitglieder.SelectedItem;
    6. var sId = selectedItem["Id"].ToString();
    7. var id = selectedItem.Row.Field<int>("Id");
    8. var sqlConnection = getSqlConnection();
    9. try
    10. {
    11. string query = "update MitgliedmitInfos Set Vorname = @Vorname, Nachname = @Nachname, Land = @Land, Wohnort = @Wohnort, Straße = @Straße, Hausnummer = @Hausnummer, Emailadresse = @Emailadresse, Telefonnummer = @Telefonnummer, Age = @Age where Id = @Id";
    12. SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
    13. sqlConnection.Open();
    14. sqlCommand.Parameters.AddWithValue("@Id", id);
    15. sqlCommand.Parameters.AddWithValue("@Vorname", tbVorname.Text);
    16. sqlCommand.Parameters.AddWithValue("@Nachname", tbNachname.Text);
    17. sqlCommand.Parameters.AddWithValue("@Land", tbLand.Text);
    18. sqlCommand.Parameters.AddWithValue("@Wohnort", tbStadt.Text);
    19. sqlCommand.Parameters.AddWithValue("@Straße", tbStraße.Text);
    20. sqlCommand.Parameters.AddWithValue("@Hausnummer", tbHausnr.Text);
    21. sqlCommand.Parameters.AddWithValue("@Emailadresse", tbEmail.Text);
    22. sqlCommand.Parameters.AddWithValue("@Telefonnummer", tbTelefon.Text);
    23. sqlCommand.Parameters.AddWithValue("@Age", tbAlter.Text);
    24. sqlCommand.ExecuteScalar();
    25. }
    26. catch (Exception ex)
    27. {
    28. MessageBox.Show(ex.ToString());
    29. }
    30. finally
    31. {
    32. sqlConnection.Close();
    33. FillDataGrid();
    34. }
    35. }
    36. catch
    37. {
    38. var sqlConnection = getSqlConnection();
    39. try
    40. {
    41. string query = "insert into MitgliedmitInfos (Vorname, Nachname, Land, Wohnort, Straße, Hausnummer, Emailadresse, Telefonnummer, Age) values (@Vorname, @Nachname, @Land, @Wohnort, @Straße, @Hausnummer, @Emailadresse, @Telefonnummer, @Age)";
    42. SqlCommand sqlCommand = new SqlCommand(query, sqlConnection);
    43. sqlConnection.Open();
    44. sqlCommand.Parameters.AddWithValue("@Vorname", tbVorname.Text);
    45. sqlCommand.Parameters.AddWithValue("@Nachname", tbNachname.Text);
    46. sqlCommand.Parameters.AddWithValue("@Land", tbLand.Text);
    47. sqlCommand.Parameters.AddWithValue("@Wohnort", tbStadt.Text);
    48. sqlCommand.Parameters.AddWithValue("@Straße", tbStraße.Text);
    49. sqlCommand.Parameters.AddWithValue("@Hausnummer", tbHausnr.Text);
    50. sqlCommand.Parameters.AddWithValue("@Emailadresse", tbEmail.Text);
    51. sqlCommand.Parameters.AddWithValue("@Telefonnummer", tbTelefon.Text);
    52. sqlCommand.Parameters.AddWithValue("@Age", tbAlter.Text);
    53. sqlCommand.ExecuteScalar();
    54. }
    55. catch (Exception ex)
    56. {
    57. MessageBox.Show(ex.ToString());
    58. }
    59. finally
    60. {
    61. sqlConnection.Close();
    62. FillDataGrid();
    63. }
    64. }
    65. }


    Weiß nicht recht wo da mein Fehler lag, aber so funktioniert es

    Nicht schön. Knallt jedes mal auf einen Fehler, wenn ein neues Mitglied angelegt wird.

    Dann lös das lieber im SQL:

    C#-Quellcode

    1. Statement = "IF NOT EXISTS ");
    2. Statement += Environment.NewLine + "(SELECT * FROM MitgliedmitInfos ";
    3. Statement += Environment.NewLine + "WHERE 1 = 1 ";
    4. Statement += Environment.NewLine + "AND Id = @Id";
    5. Statement += Environment.NewLine + ") ";
    6. Statement += Environment.NewLine + "INSERT INTO MitgliedmitInfos ";
    7. Statement += Environment.NewLine + "( ");
    8. Statement += Environment.NewLine + "Vorname, ";
    9. Statement += Environment.NewLine + "Nachname, ";
    10. Statement += Environment.NewLine + "Land, ";
    11. Statement += Environment.NewLine + "Straße, ";
    12. Statement += Environment.NewLine + "Hausnummer, ";
    13. Statement += Environment.NewLine + "Emailadresse, ";
    14. Statement += Environment.NewLine + "Telefon";
    15. Statement += Environment.NewLine + ") ";
    16. Statement += Environment.NewLine + "VALUES ";
    17. Statement += Environment.NewLine + "( ";
    18. Statement += Environment.NewLine + "@Vorname, ";
    19. Statement += Environment.NewLine + "@Nachname, ";
    20. Statement += Environment.NewLine + "@Land, ";
    21. Statement += Environment.NewLine + "@Straße, ";
    22. Statement += Environment.NewLine + "@Hausnummer, ";
    23. Statement += Environment.NewLine + "@Emailadresse, ";
    24. Statement += Environment.NewLine + "@Telefon";
    25. Statement += Environment.NewLine + ") ";
    26. Statement += Environment.NewLine + "ELSE ";
    27. Statement += Environment.NewLine + "UPDATE MitgliedmitInfos ";
    28. Statement += Environment.NewLine + "SET ";
    29. Statement += Environment.NewLine + "Vorname = @Vorname, ";
    30. Statement += Environment.NewLine + "Nachname = @Nachname, ";
    31. Statement += Environment.NewLine + "Land = @Land, ";
    32. Statement += Environment.NewLine + "Straße = @Straße, ";
    33. Statement += Environment.NewLine + "Hausnummer = @Hausnummer, ";
    34. Statement += Environment.NewLine + "Emailadresse = @Emailadresse, ";
    35. Statement += Environment.NewLine + "Telefon = @Telefon";
    36. Statement += Environment.NewLine + "WHERE 1 = 1 ";
    37. Statement += Environment.NewLine + "AND Id = @Id";


    Ein Computer wird das tun, was du programmierst - nicht das, was du willst.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Yanbel“ ()