C# - Server Mysql Klassen (ResultSet + Database Engine)

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • C# - Server Mysql Klassen (ResultSet + Database Engine)

      Ich denke ich fange mal so an.
      Jeder sollte ODBC kennen. Aber jeder sollte eigentlich wissen das bei CrossPlatform dies ein großes hindernis darstellt. Viel besser als ODBC ist dabei die Mysql.Data. Diese eignet sich Perfekt für CrossPlatform und dazu ist sie wesentlich schneller als ODBC!!!

      In meinen Arbeiten mit Server Cores hatte ich oft mit ODBC das vergnügen gehabt. Da es die Leute nutzten die die Projekte leiteten. Nun fing ich bei meinen Projekten direkt an die Mysql.Data dll zu nutzen. Da diese wesentlich bessere Performance erbringt.

      Das Problem bei Mysql.Data ist für Server ein gravierendes. Man erstellt normalerweise eine Mysql Klasse auf die Zugegriffen wird. Nun erlaubt Mysql.Data nur einen Datareader der gleichzeitig geöffnet ist.

      Um dieses Problem zu beheben habe ich meine eigene Klasse geschrieben die so perfekt funktioniert.

      C# Klassen

      Database.cs (Database Engine)
      "Database"

      Quellcode

      1. using System;
      2. using MySql.Data.MySqlClient;
      3. using System.Data.Common;
      4. namespace YourNameSpace
      5. {
      6. public class Database
      7. {
      8. #region Variablen
      9. private static MySqlConnection Connection;
      10. public static string cstring = "";
      11. #endregion
      12. #region Einstiegspunkt
      13. /// <summary>
      14. /// Stellt eine verbindung zum MySql server her.
      15. /// </summary>
      16. /// <param name="server">Serveraddresse</param>
      17. /// <param name="database">Database</param>
      18. /// <param name="user">Username</param>
      19. /// <param name="password">Password</param>
      20. public static void Connect(string user, string password, string database, string server)
      21. {
      22. cstring = "SERVER=" + server + ";" +
      23. "DATABASE=" + database + ";" +
      24. "UID=" + user + ";" +
      25. "PASSWORD=" + password + ";";
      26. Connection = new MySqlConnection(cstring);
      27. TestConnection();
      28. CloseConnection(Connection);
      29. }
      30. #endregion
      31. /// <summary>
      32. /// Open Connection
      33. /// </summary>
      34. /// <returns>On success returns true.</returns>
      35. private static bool TestConnection()
      36. {
      37. try
      38. {
      39. if (Connection.State == System.Data.ConnectionState.Closed)
      40. {
      41. Connection.Open();
      42. Console.WriteLine("Connection to MySqlServer established.");
      43. return true;
      44. }
      45. else
      46. {
      47. Console.WriteLine("MySqlServer already connected!");
      48. return false;
      49. }
      50. }
      51. catch (MySqlException ex)
      52. {
      53. Console.WriteLine(ex.Message);
      54. return false;
      55. }
      56. }
      57. public static MySqlConnection CreateConnection()
      58. {
      59. return new MySqlConnection(cstring);
      60. }
      61. public static bool OpenConnection(MySqlConnection connect)
      62. {
      63. try
      64. {
      65. if (connect.State == System.Data.ConnectionState.Closed)
      66. {
      67. connect.Open();
      68. //Log.Write(Log.MessageType.info, "Connection to MySqlServer established.");
      69. return true;
      70. }
      71. else
      72. {
      73. //Log.Write(Log.MessageType.error, "MySqlServer already connected!");
      74. return false;
      75. }
      76. }
      77. catch (MySqlException ex)
      78. {
      79. Console.WriteLine(ex.Message);
      80. return false;
      81. }
      82. }
      83. /// <summary>
      84. /// Close Connection
      85. /// </summary>
      86. /// <returns>On success returns true.</returns>
      87. public static bool CloseConnection(MySqlConnection connect)
      88. {
      89. try
      90. {
      91. connect.Close();
      92. return true;
      93. }
      94. catch (MySqlException ex)
      95. {
      96. Console.WriteLine(ex.Message);
      97. return false;
      98. }
      99. }
      100. /// <summary>
      101. /// Executes a query with no results. Mostly used with INSERT INTO, UPDATE and DELETE queries.
      102. /// </summary>
      103. /// <param name="Query">The query string to execute.</param>
      104. public static void Execute(string Query, params object[] Arguments)
      105. {
      106. try
      107. {
      108. //open connection
      109. OpenConnection(Connection);
      110. //create command and assign the query and connection from the constructor
      111. MySqlCommand exec = new MySqlCommand(string.Format(Query, Arguments), Connection);
      112. //Execute command
      113. exec.ExecuteNonQuery();
      114. //dispose object
      115. exec.Dispose();
      116. exec = null;
      117. //close connection
      118. CloseConnection(Connection);
      119. }
      120. catch (Exception e)
      121. {
      122. Console.Write("Could not execute nonquery!\r\nQuery: {0}\r\nError:{1}", Query, e.Message);
      123. }
      124. }
      125. #region Engine
      126. public static object QReadObject(MySqlDataReader QResource, string cname)
      127. {
      128. try
      129. {
      130. return QResource.GetValue(QResource.GetOrdinal(cname));
      131. }
      132. catch (Exception e)
      133. {
      134. Console.WriteLine("Unable to get field {0}: {1}", cname, e.Message);
      135. return 0;
      136. }
      137. }
      138. public static MySqlDataReader QResource(string Query, MySqlConnection connect, params object[] Arguments)
      139. {
      140. try
      141. {
      142. return new MySqlCommand(string.Format(Query, Arguments), connect).ExecuteReader();
      143. }
      144. catch (Exception e)
      145. {
      146. Console.Write("Could not execute query!\r\nQuery: {0}\r\nError:{1}", Query, e.Message);
      147. return null;
      148. }
      149. }
      150. public static DateTime QReadDT(MySqlDataReader QResource, string cname)
      151. {
      152. try
      153. {
      154. return QResource.GetDateTime(QResource.GetOrdinal(cname));
      155. }
      156. catch (Exception e)
      157. {
      158. try
      159. {
      160. return (DateTime)QResource.GetValue(QResource.GetOrdinal(cname));
      161. }
      162. catch (Exception ee)
      163. {
      164. Console.Write("Field {0} is not DT-based field. Database.QReadDT failed.\r\nError 1: {1}\r\nError 2: {2}", cname, e.Message, ee.Message);
      165. return Convert.ToDateTime(0);
      166. }
      167. }
      168. }
      169. public static long QReadlong(MySqlDataReader QResource, string ColumnName)
      170. {
      171. try
      172. {
      173. return QResource.GetInt64(QResource.GetOrdinal(ColumnName));
      174. }
      175. catch (Exception e)
      176. {
      177. try
      178. {
      179. return Convert.ToInt64(QResource.GetValue(QResource.GetOrdinal(ColumnName)));
      180. }
      181. catch (Exception ee)
      182. {
      183. Console.Write("Field {0} is not long-based field. Database.QReadlong failed.\r\nError 1: {1}\r\nError 2: {2}", ColumnName, e.Message, ee.Message);
      184. return 0;
      185. }
      186. }
      187. }
      188. public static int QReadint(MySqlDataReader QResource, string ColumnName)
      189. {
      190. try
      191. {
      192. return QResource.GetInt32(QResource.GetOrdinal(ColumnName));
      193. }
      194. catch (Exception e)
      195. {
      196. try
      197. {
      198. return int.Parse(QResource.GetString(QResource.GetOrdinal(ColumnName)));
      199. }
      200. catch (Exception ee)
      201. {
      202. Console.Write("Field {0} is not integer-based field. Database.QReadint failed.\r\nError 1: {1}\r\nError 2: {2}", ColumnName, e.Message, ee.Message);
      203. return 0;
      204. }
      205. }
      206. }
      207. public static uint QReadint(MySqlDataReader QResource, string ColumnName, bool unsigned)
      208. {
      209. try
      210. {
      211. return Convert.ToUInt32(QResource.GetValue(QResource.GetOrdinal(ColumnName)));
      212. }
      213. catch (Exception e)
      214. {
      215. Console.Write("Field {0} is not uinteger-based field. Database.QReadint failed.\r\n{1}", ColumnName, e.Message);
      216. return 0;
      217. }
      218. }
      219. public static string QReadstring(MySqlDataReader QResource, string ColumnName)
      220. {
      221. try
      222. {
      223. return QResource.GetString(QResource.GetOrdinal(ColumnName));
      224. }
      225. catch (Exception e)
      226. {
      227. Console.Write("Field {0} is not string-based field. Database.QReadstring failed.\r\n{1}", ColumnName, e.Message);
      228. return null;
      229. }
      230. }
      231. public static float QReadfloat(MySqlDataReader QResource, string ColumnName)
      232. {
      233. try
      234. {
      235. return QResource.GetFloat(QResource.GetOrdinal(ColumnName));
      236. }
      237. catch (Exception e)
      238. {
      239. try
      240. {
      241. return Convert.ToSingle(QResource.GetValue(QResource.GetOrdinal(ColumnName)));
      242. }
      243. catch (Exception ee)
      244. {
      245. Console.Write("Field {0} is not float-based field. Database.QReadfloat failed.\r\nError 1: {1}\r\nError 2: {2}", ColumnName, e.Message, ee.Message);
      246. return 0;
      247. }
      248. }
      249. }
      250. #endregion
      251. public static string Escape(string Source)
      252. {
      253. return Source.Replace("'", "\\'");
      254. }
      255. }
      256. public class Execute
      257. {
      258. private static MySqlConnection con;
      259. public Execute(string Query, params object[] Arguments)
      260. {
      261. try
      262. {
      263. con = new MySqlConnection(Database.cstring);
      264. Database.OpenConnection(con);
      265. //open connection
      266. //create command and assign the query and connection from the constructor
      267. MySqlCommand exec = new MySqlCommand(string.Format(Query, Arguments), con);
      268. //Execute command
      269. exec.ExecuteNonQuery();
      270. //dispose object
      271. exec.Dispose();
      272. exec = null;
      273. //close connection
      274. Database.CloseConnection(con);
      275. }
      276. catch (Exception e)
      277. {
      278. Console.Write("Could not execute nonquery!\r\nQuery: {0}\r\nError:{1}", Query, e.Message);
      279. }
      280. }
      281. }
      282. }
      Alles anzeigen


      ResultSet.cs
      "ResultSet"

      Quellcode

      1. using System;
      2. using MySql.Data.MySqlClient;
      3. namespace YourNameSpace
      4. {
      5. class ResultSet
      6. {
      7. private static MySqlConnection con;
      8. /// <summary>
      9. /// Gets an object from the resultset.
      10. /// </summary>
      11. /// <param name="Column">The column name.</param>
      12. /// <returns></returns>
      13. public object this[string Column]
      14. {
      15. get
      16. {
      17. return Database.QReadObject(QResource, Column);
      18. }
      19. }
      20. private MySqlDataReader QResource;
      21. private bool Active = true;
      22. public ResultSet(string Query, params object[] Arguments)
      23. {
      24. con = new MySqlConnection(Database.cstring);
      25. Database.OpenConnection(con);
      26. QResource = Database.QResource(Query, con, Arguments);
      27. if (QResource == null)
      28. Active = false;
      29. }
      30. public bool Readbool(string col)
      31. {
      32. if (!Active)
      33. return false;
      34. return Readint(col) != 0;
      35. }
      36. public int Readint(string col)
      37. {
      38. if (!Active)
      39. return 0;
      40. return Database.QReadint(QResource, col);
      41. }
      42. public uint Readint(string col, bool unsigned)
      43. {
      44. if (!Active)
      45. return 0;
      46. return Database.QReadint(QResource, col, unsigned);
      47. }
      48. public string Readstring(string col)
      49. {
      50. if (!Active)
      51. return "";
      52. return Database.QReadstring(QResource, col);
      53. }
      54. public DateTime Readtime(string col)
      55. {
      56. if (!Active)
      57. return Convert.ToDateTime(0);
      58. return Database.QReadDT(QResource, col);
      59. }
      60. public long Readlong(string col)
      61. {
      62. if (!Active)
      63. return 0;
      64. return Database.QReadlong(QResource, col);
      65. }
      66. public ulong Readulong(string col)
      67. {
      68. if (!Active)
      69. return 0;
      70. return (ulong)Database.QReadlong(QResource, col);
      71. }
      72. public float Readfloat(string col)
      73. {
      74. if (!Active)
      75. return 0;
      76. return Database.QReadfloat(QResource, col);
      77. }
      78. public bool Advance()
      79. {
      80. if (!Active)
      81. {
      82. Database.CloseConnection(con);
      83. return false;
      84. }
      85. return QResource.Read();
      86. }
      87. public void Free()
      88. {
      89. if (Active)
      90. {
      91. QResource.Close();
      92. Database.CloseConnection(con);
      93. QResource = null;
      94. }
      95. Active = false;
      96. }
      97. }
      98. }
      Alles anzeigen



      AnwendungsBeispiel für Abruf aus der Datenbank per RS:

      Quellcode

      1. ResultSet set;
      2. set = new ResultSet("SELECT * FROM accounts WHERE accountname='{0}'", Database.Escape(strUsername));
      3. if (!set.Advance())
      4. {
      5. set.Free();
      6. SendLoginFailure(ERROR_INVALID_USERNAME);
      7. Destruct("Login failed (Wrong ID)");
      8. return;
      9. }
      10. set.Free();
      Anwendungsbeispiel zum Auführen einer Query:

      Quellcode

      1. //Executing non Query
      2. Execute ex = new Execute("UPDATE accounts SET lastlogin=NOW(),lastip='{0}'linestatus='0' WHERE userid='{1}'", c_socket.RemoteEndPoint.ToString(), dwMyUserID);


      Aufruf und Configurierung
      Das erste mal Aufrufen müsst ihr die Klasse ganz am Anfang. Danach benutzt ihr einfach ResultSet und Execute. Wichtig ist das ihr beim Programmstart vor allen kommenden ResultSets und Executes das bereits aufgerufen habt:

      Quellcode

      1. Database.Connect(
      2. "username",
      3. "password",
      4. "database",
      5. "hostadress");

      Dependencies
      dev.mysql.com/downloads/connector/net/

      Viel Spaß damit
      Hoffe wird einigen irgendwann helfen
    • Werbung zur Unterstützung des Forums ( Bitte AddBlocker deaktivieren )

    • du hast also keine ahnung von mono. Mono ist sehr effizient und wen Cross Platform nicht interesssiert. Der interessiert mich dann auch nit. N richtiger Progammierer braucht auch gar keine API's. Und es gibt keine Bugs nur falsche Formatierungen bzw. ein paar abarten die man extra für das Andere sys verändern muss. Das ist aber bei jeder anderen Sprache auch so. Außerdem hat mono api's nur so nebenbei.

      aber btt:
      die effizienz kannste ja später austesten. Das ganze ist für Server ausgerichtet und ich kann nur sagen es arbeitet wesentlich schneller als ODBC. Beispiel

      Server Lade Sequenz. 25.000 Datensätze aus Mysql. Mit odbc selber server: 2 Sekunden. Mit Mysql.Data weniger als 1. Stimmt alles so nich ganz sind schätzwerte iss ja klar mache dafür jetz nich extra nen benchmark. Aber jeder der die beiden Systeme einfach mal nebeneinander stellt und die Zeiten vergleicht wird es ebenfalls bemerken. Und alles was Mysql.Data als unanehmlichkeiten hatte ist mit meiner DBEngine + dazu passendes ResultSet System eigentlich vergangenheit.
    • Ich weiß das die Mysql DLL schneller als ODBC ist, habe lange genug damit gearbeitet, und muss ehrlich sagen, ich würde kein ODBC nehmen

      Und ja mich interresiert Cross platforming, und deshalb verwende ich keine MS Sprachen mehr...
      Ich bin allerdings der meinung das es für jedes system gute und schlechte sprachen gibt, so ist z.b. C# für Mac OS eine schlechte sprache aber Objective C die beste sprache, während es bei Windows genau anders rum ist(Zwar gibts auch cocoa für Windows, aber das ist genauso effizient wie Mono unter Mac)
    • da hast du recht mono unter mac ist wie nen cheeseburger unterm Bett. Gehört da einfach nit hin.
      Aber Cross Platforming zu Linux. Und Linux ist mein Favorisiertes Betriebsystem dafür ist es sehr sehr gut. Und funktioniert auch sehr sehr gut. Teilweise sogar besser als das Original. Allerdings nicht immer^^

      Für Mac gibt es keine Platform übergreifende Sprache die wirklich gut ist und gut funktioniert ist leider so. Java selbst ist der größte Müll. Denn es frisst dermaßen viel Perfomance das ist schon unverschämt.
      Die beste möglichkeit für Variables Cross Platforming ist eine C Sprache zu nutzen und einfach den Code auf die Systeme anpassen. Viel arbeit aber effizienter als alles andere.
    • Das es unter linux gut läuft kann sein, das habe ich noch nicht getestet.

      Es gibt zwar viele Sprachen die unter allen systemen laufen, diese sind allerdings eher weniger bekannt(smalltalk, free pascal, fortran) oder einfach nur absolut beschissen(brainfuck) aber unter den "großen" sprachen gibt es wirklich nur Java, und das ist lahm, in sofern hast du schon recht
    • xD du hass dir grad nen Bein gestellt. Gut vll weißt dus nicht. Brainfuck fällt unter die Kategorie möglichst schwer zu verstehen. Es gibt einen Sport auch bei den Programmierern eine Programmiersprache zu entwickeln die man möglichst schwer versteht. Brainfuck gehört zu diesen.

      Es gibt sogar eine Programmiersprache da bestehen alle Aufrufe usw nur auskombinationen von groß O klein o und groß H klein h

      da heißt nen aufruf zb OhoOhho

      Brainfuck kannst du nur schwer als Hochsprache definieren. Es ist eine extrem Sprache so kann man das eher sagen =P