MySqlPlus/MySqlPlus/MySqlSession.cs

using Microsoft.VisualBasic;
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace MontoyaTech.MySqlPlus
{
    /// <summary>
    /// The outline of a MySqlSession which contains a MySqlManagedConnection
    /// and a few other help functions.
    /// </summary>
    public class MySqlSession : IDisposable
    {
        /// <summary>
        /// Returns whether or not this MySqlSession has a valid connection.
        /// </summary>
        public bool IsConnected
        {
            get
            {
                return this.Connection != null && this.Connection.IsConnected;
            }
        }

        /// <summary>
        /// The underlying MySql Connection that this Session is using.
        /// </summary>
        public MySqlManagedConnection Connection = null;

        /// <summary>
        /// Creates a new default MySqlSession.
        /// </summary>
        public MySqlSession() { }

        /// <summary>
        /// Creates a new MySqlSession with a connection string.
        /// </summary>
        /// <param name="connectionString"></param>
        public MySqlSession(string connectionString)
        {
            this.Connection = new MySqlManagedConnection(connectionString);
        }

        /// <summary>
        /// Creates a new MySqlSession with a given connection.
        /// </summary>
        /// <param name="connection"></param>
        public MySqlSession(MySqlManagedConnection connection)
        {
            this.Connection = connection;
        }

        /// <summary>
        /// Inserts a new row in the db and returns it's id.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public ulong Insert<T>(T row)
        {
            using (var command = new MySqlCommand())
            {
                command.Insert(row);

                this.Connection.ExecuteNonQuery(command);

                if (row.GetMySqlId(out FieldInfo idField, out MySqlColumn idColumn))
                {
                    if (Type.GetTypeCode(idField.FieldType) == TypeCode.UInt64)
                        idField.SetValue(row, (ulong)command.LastInsertedId);
                    else
                        idField.SetValue(row, command.LastInsertedId);
                }

                return (ulong)command.LastInsertedId;
            }
        }

        /// <summary>
        /// Updates a row in the db.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row"></param>
        public void Update<T>(T row)
        {
            using (var command = new MySqlCommand())
            {
                command.Update(row);

                this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Gets a row in the db by it's id.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Get<T>(ulong id)
        {
            var instance = typeof(T).CreateInstance<T>();

            this.Get<T>(instance, id);

            return instance;
        }

        /// <summary>
        /// Gets a row in the db by it's id and populates an existing instance of the row.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row"></param>
        /// <param name="id"></param>
        public void Get<T>(T row, ulong id)
        {
            using (var command = new MySqlCommand())
            {
                command.Get<T>(id);

                using (var reader = this.Connection.ExecuteReader(command))
                    reader.Read(row);
            }
        }

        /// <summary>
        /// Gets all the rows of a given type in the db.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public List<T> GetAll<T>()
        {
            using (var command = new MySqlCommand())
            {
                command.GetAll<T>();

                using (var reader = this.Connection.ExecuteReader(command))
                    return reader.ReadAll<T>();
            }
        }

        /// <summary>
        /// Deletes a row in the db.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row"></param>
        public void Delete<T>(T row)
        {
            using (var command = new MySqlCommand())
            {
                command.Delete(row);

                this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Deletes a row in the db by it's id.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="id"></param>
        public void Delete<T>(ulong id)
        {
            using (var command = new MySqlCommand())
            {
                command.Delete<T>(id);

                this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Deletes all the rows of a given type in the db.
        /// </summary>
        /// <typeparam name="T">The type of row to delete.</typeparam>
        /// <returns>The number of rows affected</returns>
        public int DeleteAll<T>()
        {
            using (var command = new MySqlCommand())
            {
                command.DeleteAll<T>();

                return this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Creates a new table in the db of a given row type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void CreateTable<T>()
        {
            using (var command = new MySqlCommand())
            {
                command.CreateTable<T>();

                this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Returns whether or not a table exists in the db of a given row type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public bool TableExists<T>()
        {
            using (var command = new MySqlCommand())
            {
                command.TableExists<T>();

                using (var reader = this.Connection.ExecuteReader(command))
                    return reader.Read();
            }
        }

        /// <summary>
        /// Emptys a table in the db for a given row type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void EmptyTable<T>()
        {
            using (var command = new MySqlCommand())
            {
                command.EmptyTable<T>();

                this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Deletes a table in the db for a given row type.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public void DeleteTable<T>()
        {
            using (var command = new MySqlCommand())
            {
                command.DeleteTable<T>();

                this.Connection.ExecuteNonQuery(command);
            }
        }

        /// <summary>
        /// Implicitly converts a MySqlSession to a MySqlConnection.
        /// </summary>
        /// <param name="session"></param>
        public static implicit operator MySqlConnection(MySqlSession session)
        {
            return session.Connection.MySqlConnection;
        }

        /// <summary>
        /// Disposes this MySqlSession.
        /// </summary>
        public virtual void Dispose()
        {
            if (this.Connection != null)
                this.Connection.Disconnect();
        }

        /// <summary>
        /// Cleans up this MySqlSession before GC collection.
        /// </summary>
        ~MySqlSession()
        {
            if (this.Connection != null)
                this.Connection.Disconnect();
        }
    }
}