转：C#制作ORM映射学习笔记三 ORM映射实现

最新推荐文章于 2020-09-17 08:02:19 发布
最新推荐文章于 2020-09-17 08:02:19 发布
阅读量176 收藏 1
点赞数 1
分类专栏： C# 文章标签： C# ORM映射

现在开始实现ORM的主体模块，首先需要在项目中新建一个类，命名为DbAccess，然后在项目的引用中添加两个dll，分别是MySql.Data.dll和System.Data.SQLite.dll，这两个dll都可以在对应的数据库官网上下载到，为了方便我这里也提供一个下载地址。添加好dll后需要在DbAccess中添加几个名空间，具体代码如下：

using System;  
using System.Collections;  
using System.Collections.Generic;  
using System.Linq;  
using System.Data;  
using System.Data.Common;  
using System.Data.SQLite;  
using System.Reflection;  
using MySql.Data;  
using MySql.Data.MySqlClient;

 下面开始实现ORM，首先需要实现对数据库的访问，具体代码如下：

private DbConnection dbConnection;  
  
private DbCommand dbCommand;  
  
private DbDataReader reader;  
  
//打开数据库连接  
public void OpenDB()  
{  
    try  
    {  
        switch (DbConfig.Type)  
        {  
            case DbType.Sqlite: dbConnection = new SQLiteConnection("data source = " + DbConfig.Host); break;  
            case DbType.Mysql: dbConnection = new MySqlConnection(DbConfig.Host); break;  
            default: break;  
        }  
        dbConnection.Open();  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
}  
  
//关闭数据库连接  
public void CloseSqlConnection()  
{  
    if (dbCommand != null)  
    {  
        dbCommand.Dispose();  
    }  
    dbCommand = null;  
    if (reader != null)  
    {  
        reader.Dispose();  
    }  
    reader = null;  
    if (dbConnection != null && dbConnection.State == ConnectionState.Open)  
    {  
        dbConnection.Close();  
        dbConnection.Dispose();  
    }  
    dbConnection = null;  
}  
  
//执行Sql命令  
public int ExecuteQuery(string sql)  
{  
    OpenDB();  
    dbCommand = dbConnection.CreateCommand();  
    dbCommand.CommandText = sql;  
    reader = dbCommand.ExecuteReader();  
    return reader.RecordsAffected;  
}

实现了对数据库的连接访问后就可以开始具体实现ORM了，首先实现两个查询方法：FirstOrDefault和Fetch，分别实现查询第一个满足条件的记录和查询所有满足条件的记录，代码如下： 

//查询符合条件的第一个记录  
public T FirstOrDefault<T>(Sql sql)  
{  
    try  
    {  
        ExecuteQuery(sql.GetSql());  
        T result = default(T);  
        if (reader.Read())  
        {  
            Type type = typeof(T);  
            if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type.IsEnum)  
            {  
                if (type.IsEnum)  
                {  
                    result = (T)Enum.ToObject(type, reader.GetValue(0));  
                }  
                else  
                {  
                    result = (T)Convert.ChangeType(reader.GetValue(0), type);  
                }  
            }  
            else  
            {  
                result = Activator.CreateInstance<T>();  
                PropertyInfo[] properties = type.GetProperties();  
                foreach (PropertyInfo property in properties)  
                {  
                    string columName = AttributeProcess.GetColumnName(property);  
                    if (property.PropertyType.IsEnum)  
                    {  
                        property.SetValue(result, Enum.ToObject(property.PropertyType, reader.GetValue(reader.GetOrdinal(columName))), null);  
                    }  
                    else  
                    {  
                        property.SetValue(result, Convert.ChangeType(reader.GetValue(reader.GetOrdinal(columName)), property.PropertyType), null);  
                    }  
                }  
            }  
        }  
        return result;  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
    finally  
    {  
        CloseSqlConnection();  
    }  
}  
  
//查询所有符合条件的记录  
public List<T> Fetch<T>(Sql sql)  
{  
    try  
    {  
        ExecuteQuery(sql.GetSql());  
        List<T> list = new List<T>();  
        Type type = typeof(T);  
        if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type.IsEnum)  
        {  
            while (reader.Read())  
            {  
                if (type.IsEnum)  
                {  
                    list.Add((T)Enum.ToObject(type, reader.GetValue(0)));  
                }  
                else  
                {  
                    list.Add((T)Convert.ChangeType(reader.GetValue(0), type));  
                }  
            }  
        }  
        else  
        {  
            while (reader.Read())  
            {  
                T result = Activator.CreateInstance<T>();  
                PropertyInfo[] properties = type.GetProperties();  
                foreach (PropertyInfo property in properties)  
                {  
                    string columName = AttributeProcess.GetColumnName(property);  
                    if (property.PropertyType.IsEnum)  
                    {  
                        property.SetValue(result, Enum.ToObject(property.PropertyType, reader.GetValue(reader.GetOrdinal(columName))), null);  
                    }  
                    else  
                    {  
                        property.SetValue(result, Convert.ChangeType(reader.GetValue(reader.GetOrdinal(columName)), property.PropertyType), null);  
                    }  
                }  
                list.Add(result);  
            }  
        }  
        return list;  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
    finally  
    {  
        CloseSqlConnection();  
    }  
}

 这里有两点需要注意，第一、一定要再finally中执行CloseSqlConnection，确保每次查询结束后都会关闭连接，哪怕是查询时出现异常。第二、对于只查询一列的情况要特殊处理。
下面来实现增删改三个方法，代码如下：

/// <summary>  
/// 更新指定的列  
/// </summary>  
/// <typeparam name="T"></typeparam>  
/// <param name="data"></param>  
/// <param name="columns"></param>  
/// <returns></returns>  
public bool Update<T>(T data, IEnumerable<string> columns)  
{  
    try  
    {  
        if (columns == null || columns.Count() == 0)  
        {  
            Update<T>(data);  
        }  
        Type type = data.GetType();  
        string table = AttributeProcess.GetTableName(type);  
        string sql = "Update " + table + " Set ";  
        string where = " Where ";  
        List<string> sets = new List<string>();  
        PropertyInfo[] properties = type.GetProperties();  
        foreach (PropertyInfo property in properties)  
        {  
            string column = AttributeProcess.GetColumnName(property);  
            if (!AttributeProcess.IsPrimary(type, property))  
            {  
                if (columns.Any(a => a == column))  
                {  
                    if (property.PropertyType == typeof(bool))  
                    {  
                        bool value = bool.Parse(property.GetValue(data, null).ToString());  
                        sets.Add(column + "=" + (value ? "1" : "0"));  
                    }  
                    else if (property.PropertyType.IsPrimitive)  
                    {  
                        sets.Add(column + "=" + property.GetValue(data, null));  
                    }  
                    else if (property.PropertyType.IsEnum)  
                    {  
                        int intValue = (int)property.GetValue(data, null);  
                        sets.Add(column + "=" + intValue);  
                    }  
                    else  
                    {  
                        if (Sql.InjectionDefend(property.GetValue(data, null).ToString()))  
                        {  
                            sets.Add(column + "=\'" + property.GetValue(data, null) + "\'");  
                        }  
                    }  
                }  
            }  
            else  
            {  
                if (property.PropertyType.IsPrimitive)  
                {  
                    where += column + "=" + property.GetValue(data, null);  
                }  
                else  
                {  
                    where += column + "=\'" + property.GetValue(data, null) + "\'";  
                }  
            }  
        }  
        sql += (string.Join(",", sets) + where);  
        ExecuteQuery(sql);  
        return true;  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
    finally  
    {  
        CloseSqlConnection();  
    }  
}  
  
//更新指定的记录  
public bool Update<T>(T data)  
{  
    try  
    {  
        Type type = data.GetType();  
        string table = AttributeProcess.GetTableName(type);  
        string sql = "Update " + table + " Set ";  
        List<string> sets = new List<string>();  
        string where = " Where ";  
        PropertyInfo[] properties = type.GetProperties();  
        foreach (PropertyInfo property in properties)  
        {  
            string column = AttributeProcess.GetColumnName(property);  
            if (!AttributeProcess.IsPrimary(type, property))  
            {  
                if (property.PropertyType == typeof(bool))  
                {  
                    bool value = bool.Parse(property.GetValue(data, null).ToString());  
                    sets.Add(column + "=" + (value ? "1" : "0"));  
                }  
                else if (property.PropertyType.IsPrimitive)  
                {  
                    sets.Add(column + "=" + property.GetValue(data, null));  
                }  
                else if (property.PropertyType.IsEnum)  
                {  
                    int intValue = (int)property.GetValue(data, null);  
                    sets.Add(column + "=" + intValue);  
                }  
                else  
                {  
                    if (Sql.InjectionDefend(property.GetValue(data, null).ToString()))  
                    {  
                        sets.Add(column + "=\'" + property.GetValue(data, null) + "\'");  
                    }  
                }  
            }  
            else  
            {  
                if (property.PropertyType.IsPrimitive)  
                {  
                    where += column + "=" + property.GetValue(data, null);  
                }  
                else  
                {  
                    where += column + "=\'" + property.GetValue(data, null) + "\'";  
                }  
            }  
        }  
        sql += (string.Join(",", sets) + where);  
        ExecuteQuery(sql);  
        return true;  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
    finally  
    {  
        CloseSqlConnection();  
    }  
}  
  
//插入新数据  
public bool Insert<T>(T data)  
{  
    try  
    {  
        Type type = data.GetType();  
        string table = AttributeProcess.GetTableName(type);  
        List<string> columns = new List<string>();  
        List<string> values = new List<string>();  
        PropertyInfo[] properties = type.GetProperties();  
        foreach (PropertyInfo property in properties)  
        {  
            if (!(AttributeProcess.IsPrimary(type, property) && AttributeProcess.IsIncrement(type)))  
            {  
                if (property.GetValue(data, null) != null)  
                {  
                    columns.Add(AttributeProcess.GetColumnName(property));  
                    if (property.PropertyType == typeof(bool))  
                    {  
                        bool value = bool.Parse(property.GetValue(data, null).ToString());  
                        values.Add((value ? "1" : "0"));  
                    }  
                    else if (property.PropertyType.IsPrimitive)  
                    {  
                        values.Add(property.GetValue(data, null).ToString());  
                    }  
                    else if (property.PropertyType.IsEnum)  
                    {  
                        int intValue = (int)property.GetValue(data, null);  
                        values.Add(intValue.ToString());  
                    }  
                    else  
                    {  
                        if (Sql.InjectionDefend(property.GetValue(data, null).ToString()))  
                        {  
                            values.Add("\'" + property.GetValue(data, null) + "\'");  
                        }  
                    }  
                }  
            }  
        }  
        string sql = "INSERT INTO " + table + "(" + string.Join(",", columns) + ")" + "VALUES" + "(" + string.Join(",", values) + ")";  
        ExecuteQuery(sql);  
        return true;  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
    finally  
    {  
        CloseSqlConnection();  
    }  
}  
  
//删除数据  
public bool Delete<T>(object id)  
{  
    try  
    {  
        Type type = typeof(T);  
        string table = AttributeProcess.GetTableName(type);  
        string sql = "DELETE FROM " + table + " WHERE ";  
        PropertyInfo[] properties = type.GetProperties();  
        foreach (PropertyInfo property in properties)  
        {  
            if (AttributeProcess.IsPrimary(type, property))  
            {  
                sql += (AttributeProcess.GetColumnName(property) + "=");  
                if (property.PropertyType.IsPrimitive)  
                {  
                    sql += (id.ToString() + ";");  
                }  
                else  
                {  
                    sql += ("\'" + id.ToString() + "\';");  
                }  
            }  
        }  
        ExecuteQuery(sql);  
        return true;  
    }  
    catch (Exception e)  
    {  
        throw e;  
    }  
    finally  
    {  
        CloseSqlConnection();  
    }  
}

上面我实现了两个update，因为如果只实现一个对一行数据的所有列的update的话，那么在实现一些如更是状态等只更新某几列数据的功能时数据更新会变慢。此外还有两点需要注意，第一、每个方法最后都要关闭数据库访问连接；第二update和insert中设置数据值的地方如果数据为string类型需要进行防sql注入的操作。 

下面是完整代码：

using System;  
using System.Collections;  
using System.Collections.Generic;  
using System.Linq;  
using System.Data;  
using System.Data.Common;  
using System.Data.SQLite;  
using System.Reflection;  
using MySql.Data;  
using MySql.Data.MySqlClient;  
  
namespace ORM  
{  
    public class DbAccess  
    {  
        private DbConnection dbConnection;  
  
        private DbCommand dbCommand;  
  
        private DbDataReader reader;  
  
        //打开数据库连接  
        public void OpenDB()  
        {  
            try  
            {  
                switch (DbConfig.Type)  
                {  
                    case DbType.Sqlite: dbConnection = new SQLiteConnection("data source = " + DbConfig.Host); break;  
                    case DbType.Mysql: dbConnection = new MySqlConnection(DbConfig.Host); break;  
                    default: break;  
                }  
                dbConnection.Open();  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
        }  
  
        //关闭数据库连接  
        public void CloseSqlConnection()  
        {  
            if (dbCommand != null)  
            {  
                dbCommand.Dispose();  
            }  
            dbCommand = null;  
            if (reader != null)  
            {  
                reader.Dispose();  
            }  
            reader = null;  
            if (dbConnection != null && dbConnection.State == ConnectionState.Open)  
            {  
                dbConnection.Close();  
                dbConnection.Dispose();  
            }  
            dbConnection = null;  
        }  
  
        //执行Sql命令  
        public int ExecuteQuery(string sql)  
        {  
            OpenDB();  
            dbCommand = dbConnection.CreateCommand();  
            dbCommand.CommandText = sql;  
            reader = dbCommand.ExecuteReader();  
            return reader.RecordsAffected;  
        }  
  
        //查询符合条件的第一个记录  
        public T FirstOrDefault<T>(Sql sql)  
        {  
            try  
            {  
                ExecuteQuery(sql.GetSql());  
                T result = default(T);  
                if (reader.Read())  
                {  
                    Type type = typeof(T);  
                    if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type.IsEnum)  
                    {  
                        if (type.IsEnum)  
                        {  
                            result = (T)Enum.ToObject(type, reader.GetValue(0));  
                        }  
                        else  
                        {  
                            result = (T)Convert.ChangeType(reader.GetValue(0), type);  
                        }  
                    }  
                    else  
                    {  
                        result = Activator.CreateInstance<T>();  
                        PropertyInfo[] properties = type.GetProperties();  
                        foreach (PropertyInfo property in properties)  
                        {  
                            string columName = AttributeProcess.GetColumnName(property);  
                            if (property.PropertyType.IsEnum)  
                            {  
                                property.SetValue(result, Enum.ToObject(property.PropertyType, reader.GetValue(reader.GetOrdinal(columName))), null);  
                            }  
                            else  
                            {  
                                property.SetValue(result, Convert.ChangeType(reader.GetValue(reader.GetOrdinal(columName)), property.PropertyType), null);  
                            }  
                        }  
                    }  
                }  
                return result;  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
            finally  
            {  
                CloseSqlConnection();  
            }  
        }  
  
        //查询所有符合条件的记录  
        public List<T> Fetch<T>(Sql sql)  
        {  
            try  
            {  
                ExecuteQuery(sql.GetSql());  
                List<T> list = new List<T>();  
                Type type = typeof(T);  
                if (type.IsPrimitive || type == typeof(string) || type == typeof(DateTime) || type.IsEnum)  
                {  
                    while (reader.Read())  
                    {  
                        if (type.IsEnum)  
                        {  
                            list.Add((T)Enum.ToObject(type, reader.GetValue(0)));  
                        }  
                        else  
                        {  
                            list.Add((T)Convert.ChangeType(reader.GetValue(0), type));  
                        }  
                    }  
                }  
                else  
                {  
                    while (reader.Read())  
                    {  
                        T result = Activator.CreateInstance<T>();  
                        PropertyInfo[] properties = type.GetProperties();  
                        foreach (PropertyInfo property in properties)  
                        {  
                            string columName = AttributeProcess.GetColumnName(property);  
                            if (property.PropertyType.IsEnum)  
                            {  
                                property.SetValue(result, Enum.ToObject(property.PropertyType, reader.GetValue(reader.GetOrdinal(columName))), null);  
                            }  
                            else  
                            {  
                                property.SetValue(result, Convert.ChangeType(reader.GetValue(reader.GetOrdinal(columName)), property.PropertyType), null);  
                            }  
                        }  
                        list.Add(result);  
                    }  
                }  
                return list;  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
            finally  
            {  
                CloseSqlConnection();  
            }  
        }  
  
        /// <summary>  
        /// 更新指定的列  
        /// </summary>  
        /// <typeparam name="T"></typeparam>  
        /// <param name="data"></param>  
        /// <param name="columns"></param>  
        /// <returns></returns>  
        public bool Update<T>(T data, IEnumerable<string> columns)  
        {  
            try  
            {  
                if (columns == null || columns.Count() == 0)  
                {  
                    Update<T>(data);  
                }  
                Type type = data.GetType();  
                string table = AttributeProcess.GetTableName(type);  
                string sql = "Update " + table + " Set ";  
                string where = " Where ";  
                List<string> sets = new List<string>();  
                PropertyInfo[] properties = type.GetProperties();  
                foreach (PropertyInfo property in properties)  
                {  
                    string column = AttributeProcess.GetColumnName(property);  
                    if (!AttributeProcess.IsPrimary(type, property))  
                    {  
                        if (columns.Any(a => a == column))  
                        {  
                            if (property.PropertyType == typeof(bool))  
                            {  
                                bool value = bool.Parse(property.GetValue(data, null).ToString());  
                                sets.Add(column + "=" + (value ? "1" : "0"));  
                            }  
                            else if (property.PropertyType.IsPrimitive)  
                            {  
                                sets.Add(column + "=" + property.GetValue(data, null));  
                            }  
                            else if (property.PropertyType.IsEnum)  
                            {  
                                int intValue = (int)property.GetValue(data, null);  
                                sets.Add(column + "=" + intValue);  
                            }  
                            else  
                            {  
                                if (Sql.InjectionDefend(property.GetValue(data, null).ToString()))  
                                {  
                                    sets.Add(column + "=\'" + property.GetValue(data, null) + "\'");  
                                }  
                            }  
                        }  
                    }  
                    else  
                    {  
                        if (property.PropertyType.IsPrimitive)  
                        {  
                            where += column + "=" + property.GetValue(data, null);  
                        }  
                        else  
                        {  
                            where += column + "=\'" + property.GetValue(data, null) + "\'";  
                        }  
                    }  
                }  
                sql += (string.Join(",", sets) + where);  
                ExecuteQuery(sql);  
                return true;  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
            finally  
            {  
                CloseSqlConnection();  
            }  
        }  
  
        //更新指定的记录  
        public bool Update<T>(T data)  
        {  
            try  
            {  
                Type type = data.GetType();  
                string table = AttributeProcess.GetTableName(type);  
                string sql = "Update " + table + " Set ";  
                List<string> sets = new List<string>();  
                string where = " Where ";  
                PropertyInfo[] properties = type.GetProperties();  
                foreach (PropertyInfo property in properties)  
                {  
                    string column = AttributeProcess.GetColumnName(property);  
                    if (!AttributeProcess.IsPrimary(type, property))  
                    {  
                        if (property.PropertyType == typeof(bool))  
                        {  
                            bool value = bool.Parse(property.GetValue(data, null).ToString());  
                            sets.Add(column + "=" + (value ? "1" : "0"));  
                        }  
                        else if (property.PropertyType.IsPrimitive)  
                        {  
                            sets.Add(column + "=" + property.GetValue(data, null));  
                        }  
                        else if (property.PropertyType.IsEnum)  
                        {  
                            int intValue = (int)property.GetValue(data, null);  
                            sets.Add(column + "=" + intValue);  
                        }  
                        else  
                        {  
                            if (Sql.InjectionDefend(property.GetValue(data, null).ToString()))  
                            {  
                                sets.Add(column + "=\'" + property.GetValue(data, null) + "\'");  
                            }  
                        }  
                    }  
                    else  
                    {  
                        if (property.PropertyType.IsPrimitive)  
                        {  
                            where += column + "=" + property.GetValue(data, null);  
                        }  
                        else  
                        {  
                            where += column + "=\'" + property.GetValue(data, null) + "\'";  
                        }  
                    }  
                }  
                sql += (string.Join(",", sets) + where);  
                ExecuteQuery(sql);  
                return true;  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
            finally  
            {  
                CloseSqlConnection();  
            }  
        }  
  
        //插入新数据  
        public bool Insert<T>(T data)  
        {  
            try  
            {  
                Type type = data.GetType();  
                string table = AttributeProcess.GetTableName(type);  
                List<string> columns = new List<string>();  
                List<string> values = new List<string>();  
                PropertyInfo[] properties = type.GetProperties();  
                foreach (PropertyInfo property in properties)  
                {  
                    if (!(AttributeProcess.IsPrimary(type, property) && AttributeProcess.IsIncrement(type)))  
                    {  
                        if (property.GetValue(data, null) != null)  
                        {  
                            columns.Add(AttributeProcess.GetColumnName(property));  
                            if (property.PropertyType == typeof(bool))  
                            {  
                                bool value = bool.Parse(property.GetValue(data, null).ToString());  
                                values.Add((value ? "1" : "0"));  
                            }  
                            else if (property.PropertyType.IsPrimitive)  
                            {  
                                values.Add(property.GetValue(data, null).ToString());  
                            }  
                            else if (property.PropertyType.IsEnum)  
                            {  
                                int intValue = (int)property.GetValue(data, null);  
                                values.Add(intValue.ToString());  
                            }  
                            else  
                            {  
                                if (Sql.InjectionDefend(property.GetValue(data, null).ToString()))  
                                {  
                                    values.Add("\'" + property.GetValue(data, null) + "\'");  
                                }  
                            }  
                        }  
                    }  
                }  
                string sql = "INSERT INTO " + table + "(" + string.Join(",", columns) + ")" + "VALUES" + "(" + string.Join(",", values) + ")";  
                ExecuteQuery(sql);  
                return true;  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
            finally  
            {  
                CloseSqlConnection();  
            }  
        }  
  
        //删除数据  
        public bool Delete<T>(object id)  
        {  
            try  
            {  
                Type type = typeof(T);  
                string table = AttributeProcess.GetTableName(type);  
                string sql = "DELETE FROM " + table + " WHERE ";  
                PropertyInfo[] properties = type.GetProperties();  
                foreach (PropertyInfo property in properties)  
                {  
                    if (AttributeProcess.IsPrimary(type, property))  
                    {  
                        sql += (AttributeProcess.GetColumnName(property) + "=");  
                        if (property.PropertyType.IsPrimitive)  
                        {  
                            sql += (id.ToString() + ";");  
                        }  
                        else  
                        {  
                            sql += ("\'" + id.ToString() + "\';");  
                        }  
                    }  
                }  
                ExecuteQuery(sql);  
                return true;  
            }  
            catch (Exception e)  
            {  
                throw e;  
            }  
            finally  
            {  
                CloseSqlConnection();  
            }  
        }  
    }  
}

 在之前建立的userinfo表中插入一条数据用于测试，如下图：


然后在main函数中添加如下代码进行测试：

 

static void Main(string[] args)  
{  
    DbAccess dao = new DbAccess();  
    Sql sql = new Sql();  
    sql.Select("*").From("userinfo");  
    sql.Where("Id=@0", 1);  
    User user = dao.FirstOrDefault<User>(sql);  
    Console.WriteLine(user.UserName);  
    user.UserName = "tczhoulan";  
    Console.WriteLine(dao.Update<User>(user, new string[] { "UserName" }));  
}

 

执行结果如下图：


再看数据库中的数据，UserName中的值已经被修改了，如下图所示：

到这里一个简单的ORM映射框架就基本完成了，当然这只是一个最简单的ORM框架，其中还有许多不完善的地方，如有需要可以自己在上面进行扩充，我也会慢慢的进行完善。

 转自：https://www.cnblogs.com/vaevvaev/p/7054951.html

误凡尘
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#根据反射和特性实现ORM映射实例分析
09-03
主要介绍了C#根据反射和特性实现ORM映射的方法,实例分析了反射的原理、特性与ORM的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
关于C#操作INI文件的总结
weixin_30872867的博客
09-22 74
关于C#操作INI文件的总结 INI文件其实是一种具有特定结构的文本文件，它的构成分为三部分，结构如下： [Section1]key1=value2key1=value2……[Section2]key1=value1key2=value2…… 文件由若干个段落（section）组成，每个段落又分成若干个键（key）和值（v...
C# 创建INI文件，写入并可读取
qq_34573534的博客
10-08 781
基于C#winform设计。 首先创建一个类，我命名为IniFiles。并引入命名空间using System.Runtime.InteropServices; 接着，声明API函数： 　　 [DllImport("kernel32")] private static extern long WritePrivateProfileString(string secti...
c#实现INI文件操作
qq_41145567的博客
05-29 2728
  INI文件其实是一种具有特定结构的文本文件，它的构成分为三部分，结构如下[Section1]key 1 = value2key 1 = value2……[Section2]key 1 = value1key 2 = value2    文件由若干个段落（section）组成，每个段落又分成若干个键（key）和值（value）。Windows系统自带的Win32的API函数GetPrivateP...
C# ORM框架 开源
System_Bug的专栏
05-24 4429
ORM源码： https://github.com/dewfn/SmiteRepositorySmiteRepository.NET ORM框架，基于Dapper效率高，操作实体类就可以实现数据库操作，很简单方便。联系 [email protected] 根据条件Update,Delete有修改字段，不会Update全字段,Insert也是。 各种表ORM查寻：Find,FindAll,Max,Min
ORM:C＃中的对象关系映射
05-26
C＃ORM 一个类库项目，在C＃中实现了一个简单，轻量级的对象关系映射器。 它最初是一个研究项目，目的是取代对庞大的Microsoft Entity Framework的需求。 该项目允许查询数据源是数据库还是Web服务（正在进行的...
Python ORM框架SQLAlchemy学习笔记之关系映射实例
01-20
昨天简单介绍了SQLAlchemy的使用，但是没有能够涉及其最精彩的ORM部分，今天我将简单说明一下，当然主要还是讲解官方文档的内容，由于是学习笔记，有可能存在精简或者自己理解的部分，不做权威依据。 当我们开始使用...
模拟：模拟ORM：LaravelPHP的数据映射器ORM
02-03
这是附带Laravel框架采用数据映射模式，而不是原来的Active Record方式雄辩的ORM的换位。 通过严格的关注点分离，它克服了Eloquent的一些体系结构限制； 例如，您可以使用Value Objects或Single-table-inheritance ...
C# WinForm读写INI文件
weixin_30443731的博客
03-31 197
作应用系统开发时，管理配置是必不可少的。例如数据库服务器的配置、安装和更新配置等等。由于Xml的兴起，现在的配置文件大都是以xml文档来存储。比如Visual Studio.Net自身的配置文件Mashine.config，Asp.Net的配置文件Web.Config，都是xml的格式。 传统的配置文件ini已有被xml文件逐步代替的趋势，但对于简单的配置，ini文件还是有用武之地的,尤其现在绿...
c# 如何读取和写入ini(配置文件)
weixin_34209851的博客
01-30 257
/// <summary> /// 配置文件操作类 /// </summary> public class iniOperate { /// <summary> /// ini配置文件路径 /// </summary> public string inipath;...
C#创建txt文件并写入内容
weixin_34138377的博客
03-22 4531
以注册登录为例 using System.Text; 1.注册 //注册 public string registered(string username,string password) { //判断是否已经有了这个文件 if (!System.IO.File.Exists("c:\\u...
自学C#笔记：如何创建、读写ini文件
weixin_42764060的博客
03-14 1521
学习用C#中操作ini文件过程中，在网上查了很多文章，但是感觉自己基础太薄弱，对各位大神发的文章不是特别理解，摸索了很久也才只学会了创建ini文件和读写ini文件。下面给出一个我写的小例子。 首先，建立一个winform项目，我将其命名为ini文件操作。如图所示 然后在项目中新建一个类，我将其命名为IniFiles,如图所示 打开IniFiles类，首先在这个类里面添加下列引用： ...
C#ORM（关系对象映射）的框架
weixin_44548405的博客
09-17 5055
一、关于ORM ORM的概念： 对象关系映射（Object Relationsl Mapping,简称ORM,或O/RM,或O/R mapping），是一种技术，用于实现面向对象编程语言里不同类型系统数据之间的转换。从效果上说，它其实是创建了一个可在编程语言里使用的“虚拟对象数据库”。 ORM的优势：实现快速开发，方便移植数据库。 .NET开发中的ORM框架： NHibernate 、MyBatis.NET 、LINQ to SQL(已经不再使用) 、 ADO.NET Entity Frame..
C# 自己实现的一套ORM程序附带实体生成工具
zhang116868的专栏
11-13 5112
程序全部是自己实现的，原理是对sql语句的包装，现在支持mysql和sqlite,可以扩展到现在主流的数据库。 程序下载地址：C# 自已实现ORM程序下载 实体生成工具下载：实体生成工具下载 下面对程序进行介绍。 首先添加引用：DB.DAL.dll，MySql.Data.dll，System.Data.SQLite.dll 建立数据源： <s...
C# 根据反射和特性实现ORM 映射[学习]
weixin_33922672的博客
08-07 167
  （一）关于反射 什么是反射？ 反射就是在运行时，动态获取对象信息的方法。比如：运行时获得对象有哪些属性，方法，委托等。 反射的作用？ 能够实现运行时，动态调用对象的方法，以及动态设置、获取属性值等。 反射的示例： using System; u...
C#制作ORM映射学习笔记三 ORM映射实现
tczhoulan的专栏
12-09 3196
现在开始实现ORM的主体模块，首先需要在项目中新建一个类，命名为DbAccess，然后在项目的引用中添加两个dll，分别是MySql.Data.dll和System.Data.SQLite.dll，这两个dll都可以在对应的数据库官网上下载到，为了方便我这里也提供一个下载地址。添加好dll后需要在DbAccess中添加几个名空间，具体代码如下： using System; using Syste
Django的ORM映射是什么
最新发布
05-24
Django的ORM (Object-Relational Mapping)映射，是指将数据库中的数据映射到Python对象上，从而使得Python程序可以直接操作数据库，而不需要使用SQL语句。ORM映射使得开发人员可以更加高效地开发和维护代码，同时也...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值