伪CodeFirst开荒方式接纳于Sqlite数据库
分类:计算机编程

图片 1

因为最近没有时间深入的研究EntityFramework的内部机制,所以具体的实现并不十分了解。微软最初的初衷是开发出一套通用的数据库访问逻辑,实现对Dal数据访问层的高度封装,其中就用到了工厂模式和抽象工厂模式。

在刚接触C#的时候由于公司使用的就是Oracle数据库,那么C#怎么连接Oracle数据库就成了首要去掌握的知识点了。在那时没有ODP.NET,但visual studio却对Oralce数据库的调用进行了集成,就是下图中的这个,尽管现在使用这个的时候visual studio提醒过时的,但在那时却是非常好用的。图片 2

ODP.NET:

在以下的说明中我主要以创建一个简单的web工程来讲解,Sqlite下EntityFramework的伪CodeFirst模式的实现。

为什么现在visual studio中这个程序集依然能使用,有ODP.NET,单单要拿出Oracle.ManagedDataAccess.dll进行本文的重点呢?

引用:

说明:以下Sqlite实现不支持CodeFirst的(Migration)数据库迁移,数据库是事前创建好的

1、visual studio中提醒过时,因为微软和甲骨文存在数据库的竞争关系,并且从.NET的更新来看这个程序集没有再更新过,对于数据库一直在更新而调用的程序集一直不更新敢用下去么?还有一个我认为非常重要的原因就是使用这个程序集,摆脱不了每一个运行程序的客户机上都要去安装Oracle客户端的事实,试想一下,如果用户数量巨大的时候,安装客户端的工作量就相当的大,很耗费资源;

using Oracle.DataAccess; //Oracle g 11.2.0
using Oracle.DataAccess.Client;
using Oracle.DataAccess.Types;
//下载 http://www.oracle.com/technetwork/topics/dotnet/downloads/net-downloads-160392.html
//引用:D:appgeovinduproduct11.2.0dbhome_1ODP.NETbin
//用法参考
//
//http://docs.oracle.com/cd/B28359_01/appdev.111/b28844/procedures_dot_net.htm
//http://docs.oracle.com/cd/B19306_01/win.102/b14307/OracleDataAdapterClass.htm //.net 4.0
//https://docs.oracle.com/cd/B19306_01/server.102/b14220/schema.htm

1.我们首先建立一个空的WebApplication1

2、甲骨文后来出了ODP.NET,各种资料以及官网上都说需要安装ODP.NET,然后引用Oracle.ManagedDataAccess.dll,他和visual studio中的程序集最大的区别在于会随着数据库更新,是oracle官方出的驱动;

  数据库连接字符串:

2.我们给当前的工程添加EntityFramework.dll类库,并使用Nuget来维护我们的程序包(Packages),如图所示:

3、其实经过测试,ODP.NET的安装完全是没有必要的,直接在网上下载一个Oracle.ManagedDataAccess.dll,按如下方式引用即可,使用此种方式减少了ODP.NET的安装,无视操作系统的位数,最重要的是减少了Oracle客户端的安装;

 public string connectionString = @"DATA SOURCE=oracle11g;USER ID=geovin;password=geovindu;";

图片 3

图片 4

  

图片 5

图片 6

/// <summary>
    /// 20160918 涂聚文
    /// Geovin Du
    /// </summary>
    public class BookKindListDAL : IBookKindList
    {

        ///<summary>
        /// 追加记录
        ///</summary>
        ///<param name="BookKindListInfo"></param>
        ///<returns></returns>
        public int InsertBookKindList(BookKindListInfo bookKindList)
        {
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
    new OracleParameter("temTypeName",OracleDbType.NVarchar2,1000),
    new OracleParameter("temParent",OracleDbType.Int32,4),
    };
                par[0].Value = bookKindList.BookKindName;
                par[1].Value = bookKindList.BookKindParent;
                ret = OracleHelper.ExecuteSql("proc_Insert_BookKindList", CommandType.StoredProcedure, par);
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        /// <summary>
        /// 追加记录返回
        /// </summary>
        /// <param name="authorList"></param>
        /// <param name="authorID"></param>
        /// <returns></returns>
        public int InsertBookKindOutput(BookKindListInfo bookKindList, out int bookKindLID)
        {
            bookKindLID = 0;
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
    new OracleParameter("temTypeName",OracleDbType.NVarchar2,1000),
                new OracleParameter("temParent",OracleDbType.Int32,4),
                new OracleParameter("temId",OracleDbType.Int32,4),
    };
                par[0].Value = bookKindList.BookKindName;
                par[1].Value = bookKindList.BookKindParent;
                par[2].Direction = ParameterDirection.Output;
                ret = OracleHelper.ExecuteSql("proc_Insert_BookKindOut", CommandType.StoredProcedure, par);
                if (ret > 0)
                {
                    bookKindLID =int.Parse(par[2].Value.ToString());
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        ///修改记录
        ///</summary>
        ///<param name="BookKindListInfo"></param>
        ///<returns></returns>
        public int UpdateBookKindList(BookKindListInfo bookKindList)
        {
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
    new OracleParameter("BookKindID",OracleDbType.Int32,4),
    new OracleParameter("BookKindName",OracleDbType.NVarchar2,1000),
    new OracleParameter("BookKindParent",OracleDbType.Int32,4),
    };
                par[0].Value = bookKindList.BookKindID;
                par[1].Value = bookKindList.BookKindName;
                par[2].Value = bookKindList.BookKindParent;
                ret = OracleHelper.ExecuteSql("proc_Update_BookKindList", CommandType.StoredProcedure, par);
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        /// 删除记录
        ///</summary>
        ///<param name="bookKindIDInfo"></param>
        ///<returns></returns>
        public bool DeleteBookKindList(int bookKindID)
        {
            bool ret = false;
            try
            {
                OracleParameter par = new OracleParameter("BookKindID", bookKindID);
                int temp = 0;
                temp = OracleHelper.ExecuteSql("proc_Delete_BookKindList", CommandType.StoredProcedure, par);
                if (temp != 0)
                {
                    ret = true;
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        /// 查询记录
        ///</summary>
        ///<param name="bookKindIDInfo"></param>
        ///<returns></returns>
        public BookKindListInfo SelectBookKindList(int bookKindID)
        {
            BookKindListInfo bookKindList = null;
            try
            {
                OracleParameter par = new OracleParameter("BookKindID", bookKindID);
                using (OracleDataReader reader = OracleHelper.GetReader("proc_Select_BookKindList", CommandType.StoredProcedure, par))
                {
                    if (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (int)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (int)reader["BookKindParent"] : 0;

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return bookKindList;
        }

        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public List<BookKindListInfo> SelectBookKindListAll()
        {
            List<BookKindListInfo> list = new List<BookKindListInfo>();
            BookKindListInfo bookKindList = null;
            try
            {
                using (OracleDataReader reader = OracleHelper.GetReader("proc_Select_BookKindListAll", CommandType.StoredProcedure, null))
                {
                    while (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (int)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (int)reader["BookKindParent"] : 0;
                        list.Add(bookKindList);

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return list;
        }
        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public DataTable SelectBookKindListDataTableAll()
        {
            DataTable dt = new DataTable();
            try
            {
                using (DataTable reader = OracleHelper.GetTable("proc_Select_BookKindListAll", CommandType.StoredProcedure, null))
                {
                    dt = reader;


                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return dt;
        }

    }

在这里安装EntityFramwork的时候我带上了版本号,因为EntityFramework5用的比较多,所以这里还是用老版本好了(2014年2月22日当前最新版本是6.0)。EntityFramework.dll在Nuget上的官网位置为:

图片 7

  System.Data.OracleClient(.net 4.0)

 

引用:

3.EntityFramework安装好了以后,我们就要添加Sqlite的dll程序集了,我这里下载了2个文件直接放在了项目的bin目录下,如下图:

那在哪里下载Oracle.ManagedDataAccess.dll呢?如果Oracle.ManagedDataAccess.dll有更新怎么知道呢?这个时候全宇宙最强大开发工具登场了!

using System.Collections;
using System.Data;
using System.Configuration;
using System.Data.OracleClient;//.net 4.0

//用法参考
//https://msdn.microsoft.com/en-us/library/system.data.oracleclient.oracledataadapter(v=vs.110).aspx
//http://blog.csdn.net/chinawn/article/details/336904
//C:Program FilesReference AssembliesMicrosoftFramework.NETFrameworkv4.0System.Data.OracleClient.dll

图片 8

图片 9

  数据库连接字符串:

当然我们也可以使用Package Manager Console完成操作:(Sqlite在Nuget上的地址为:)

图片 10

    public string connectionString = @"Data Source=(DESCRIPTION = (ADDRESS_LIST= (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))) (CONNECT_DATA = (SERVICE_NAME = oracle11g)));user id=geovin;password=geovindu;Persist Security Info=True;";

4.至此为止我们基本的配置已经完成了。下面开始按照CodeFirst模式创建实体模型类和数据上下文类了(DbContext)。

图片 11

  

先看看数据库上下文类:(以下代码仅供参考)

安装完成就可以撸代码了,并且如果有更新可以随时能看到。并且在编程方面和以前使用System.Data.OracleClient程序集没有多大的不同,基本上拿以前使用System.Data.OracleClient程序集的代码做少许的改动即可。

/// <summary>
    /// 20160918 涂聚文
    /// Geovin Du
    /// </summary>
    public class BookKindListDAL : IBookKindList
    {

        ///<summary>
        /// 追加记录
        ///</summary>
        ///<param name="BookKindListInfo"></param>
        ///<returns></returns>
        public int InsertBookKindList(BookKindListInfo bookKindList)
        {
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
    new OracleParameter("temTypeName",OracleType.NVarChar,1000),
    new OracleParameter("temParent",OracleType.Number,4),
    };
                par[0].Value = bookKindList.BookKindName;
                par[1].Value = bookKindList.BookKindParent;
                ret = OracleHelper.ExecuteSql("proc_Insert_BookKindList", CommandType.StoredProcedure, par);
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        /// <summary>
        /// 追加记录返回
        /// </summary>
        /// <param name="authorList"></param>
        /// <param name="authorID"></param>
        /// <returns></returns>
        public int InsertBookKindOutput(BookKindListInfo bookKindList, out int bookKindLID)
        {
            bookKindLID = 0;
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
    new OracleParameter("temTypeName",OracleType.NVarChar,1000),
                new OracleParameter("temParent",OracleType.Number,4),
                new OracleParameter("temId",OracleType.Number,4),
    };
                par[0].Value = bookKindList.BookKindName;
                par[1].Value = bookKindList.BookKindParent;
                par[2].Direction = ParameterDirection.Output;
                ret = OracleHelper.ExecuteSql("proc_Insert_BookKindOut", CommandType.StoredProcedure, par);
                if (ret > 0)
                {
                    bookKindLID =int.Parse(par[2].Value.ToString());
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        ///修改记录
        ///</summary>
        ///<param name="BookKindListInfo"></param>
        ///<returns></returns>
        public int UpdateBookKindList(BookKindListInfo bookKindList)
        {
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
    new OracleParameter("BookKindID",OracleType.Number,4),
    new OracleParameter("BookKindName",OracleType.NVarChar,1000),
    new OracleParameter("BookKindParent",OracleType.Number,4),
    };
                par[0].Value = bookKindList.BookKindID;
                par[1].Value = bookKindList.BookKindName;
                par[2].Value = bookKindList.BookKindParent;
                ret = OracleHelper.ExecuteSql("proc_Update_BookKindList", CommandType.StoredProcedure, par);
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        /// 删除记录
        ///</summary>
        ///<param name="bookKindIDInfo"></param>
        ///<returns></returns>
        public bool DeleteBookKindList(int bookKindID)
        {
            bool ret = false;
            try
            {
                OracleParameter par = new OracleParameter("BookKindID", bookKindID);
                int temp = 0;
                temp = OracleHelper.ExecuteSql("proc_Delete_BookKindList", CommandType.StoredProcedure, par);
                if (temp != 0)
                {
                    ret = true;
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        /// 查询记录
        ///</summary>
        ///<param name="bookKindIDInfo"></param>
        ///<returns></returns>
        public BookKindListInfo SelectBookKindList(int bookKindID)
        {
            BookKindListInfo bookKindList = null;
            try
            {
                OracleParameter par = new OracleParameter("BookKindID", bookKindID);
                using (OracleDataReader reader = OracleHelper.GetReader("proc_Select_BookKindList", CommandType.StoredProcedure, par))
                {
                    if (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (int)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (int)reader["BookKindParent"] : 0;

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return bookKindList;
        }

        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public List<BookKindListInfo> SelectBookKindListAll()
        {
            List<BookKindListInfo> list = new List<BookKindListInfo>();
            BookKindListInfo bookKindList = null;
            try
            {
                using (OracleDataReader reader = OracleHelper.GetReader("proc_Select_BookKindListAll", CommandType.StoredProcedure, null))
                {
                    while (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (int)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (int)reader["BookKindParent"] : 0;
                        list.Add(bookKindList);

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return list;
        }
        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public DataTable SelectBookKindListDataTableAll()
        {
            DataTable dt = new DataTable();
            try
            {
                using (DataTable reader = OracleHelper.GetTable("proc_Select_BookKindListAll", CommandType.StoredProcedure, null))
                {
                    dt = reader;


                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return dt;
        }

    }

 

1、使用了连接字符串,而不是用oracle客户端的服务名了;

  System.Data.OleDb

[csharp] view plaincopy图片 12图片 13

2、几个命名空间的变化;

 string connString = "Provider=OraOLEDB.Oracle.1;User ID=geovin;Password=geovindu;Data Source=(DESCRIPTION = (ADDRESS_LIST= (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))) (CONNECT_DATA = (SERVICE_NAME = oracle11g)))";
            OleDbConnection conn = new OleDbConnection(connString);
            try
            {
                conn.Open();
                MessageBox.Show(conn.State.ToString());
                DataTable dt = conn.GetSchema(this.comboBox1.Text.Trim());
                this.dataGridView1.DataSource = dt;
                this.textBox1.Text = GetColumnNames(dt);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message.ToString());
            }
            finally
            {
                conn.Close();
            }
  1. public partial class BloggingContext : DbContext  
  2. {  
  3.     public BloggingContext(): base("Name=BloggingContext")  
  4.     {  
  5.     }  
  6.     public DbSet<Blog> Blogs { get; set; }  
  7.     public DbSet<Post> Posts { get; set; }  
  8.   
  9.     protected override void OnModelCreating(DbModelBuilder modelBuilder)  
  10.     {  
  11.         modelBuilder.Configurations.Add(new BlogMap());  
  12.         modelBuilder.Configurations.Add(new PostMap());  
  13.     }  
  14. }  

下面是对数据库常用操作的封装

  oracle package sql:

其中Blog和Post是2个实体类(POCO),这里就不在赘述了。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using Oracle.ManagedDataAccess.Client;
using System.Data;
using System.IO;
using System.Collections;
using System.Diagnostics;
using Oracle.ManagedDataAccess.Types;

namespace OracleDemo
{
    public class OracleHelper
    {
        private static string connStr = "User Id=admin;Password=123;Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.0.1)(PORT=1521)))(CONNECT_DATA=(SERVICE_NAME=test)))";

        #region 执行SQL语句,返回受影响行数
        public static int ExecuteNonQuery(string sql, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = new OracleConnection(connStr))
            {
                conn.Open();
                using (OracleCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    return cmd.ExecuteNonQuery();
                }
            }
        }
        #endregion
        #region 执行SQL语句,返回DataTable;只用来执行查询结果比较少的情况
        public static DataTable ExecuteDataTable(string sql, params OracleParameter[] parameters)
        {
            using (OracleConnection conn = new OracleConnection(connStr))
            {
                conn.Open();
                using (OracleCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = sql;
                    cmd.Parameters.AddRange(parameters);
                    OracleDataAdapter adapter = new OracleDataAdapter(cmd);
                    DataTable datatable = new DataTable();
                    adapter.Fill(datatable);
                    return datatable;
                }
            }
        }
        #endregion
    }
}
/**创建一个名为pkgBookKinds的包查所表中所有内容**/
create or replace package pkg_BookKinds is
--定义一个公有的游标类型cursor_pdt
--ref 可以在程序间传递结果集
--一个程序里打开游标变量,在另外的程序里处理数据
type cursor_pdt is ref cursor;
--声明一个存储过程 ,游标类型参数为输出类型
procedure proc_GetAllBookKind(cur_set out cursor_pdt);
end pkg_BookKinds;

/**创建一个包体**/
create or replace package body pkg_BookKinds is
  --实现包中没有实现的存储过程
  procedure proc_GetAllBookKind(cur_set out cursor_pdt) as
    begin 
      --打开游标,由于定义游标时使用ref处理游标可以推迟到客户端
      open cur_set for select * from BookKindList;
      end;
end;


/**使用过程测试定义的存储过程**/
declare
--定义游标类型的变量
cur_set pkg_BookKinds.cursor_pdt;
--定义行类型
pdtrow BookKindList%rowtype;
begin
  --执行存储过程
  pkg_BookKinds.proc_GetAllBookKind(cur_set);
  --遍历游标中的数据
       LOOP
         --取当前行数据存入pdtrow
           FETCH cur_set INTO pdtrow;
           --如果未获取数据就结束循环
           EXIT WHEN cur_set%NOTFOUND;
           --输出获取到的数据
           DBMS_OUTPUT.PUT_LINE (pdtrow.BookKindID||','||pdtrow.BookKindName);
         END LOOP;
         CLOSE cur_set;
  end;

 

以下代码是调用部分

 

我们主要来关注下这个构造函数,它向程序集 EntityFramework.dll里面,命名空间namespace System.Data.Entity下的DbContext类传递了一个数据库连接字符串的名字。

                string sqlString = "Select a.col1,a.col2 From test a Where a.id=:id";
                DataTable dt = OracleHelper.ExecuteDataTable(sqlString,new OracleParameter(":id",1));
--创建包以游标的形式返回BookKindList的结果集
create or replace package pkg_BookKindList is
-- Author  : geovindu
  type mycur is ref cursor;  
  procedure fun_GetRecords(cur_return out mycur);
end pkg_BookKindList;

create or replace package body pkg_BookKindList is
  -- Function and procedure implementations
 procedure fun_GetRecords(cur_return out mycur)
  is    
  begin
   open cur_return for select * from BookKindList;

  end fun_GetRecords;

end pkg_BookKindList;


declare 
--定义游标类型的变量
cur_return pkg_BookKindList.mycur;
--定义行类型
pdtrow BookKindList%rowtype;
begin
  --执行存储过程
  pkg_BookKindList.fun_GetRecords(cur_return);
  --遍历游标中的数据
       LOOP
         --取当前行数据存入pdtrow
           FETCH cur_return INTO pdtrow;
           --如果未获取数据就结束循环
           EXIT WHEN cur_return%NOTFOUND;
           --输出获取到的数据
           DBMS_OUTPUT.PUT_LINE (pdtrow.BookKindID||','||pdtrow.BookKindName);
         END LOOP;
         CLOSE cur_return;
end;

为此我们来配置下当前Web.config文件里面的数据库连接字符串:

 

  

 

程序编写完成,生成完成后,目录大概如下:

 

[html] view plaincopy图片 14图片 15

图片 16

 C# 3.5 调用查询:

  1. <connectionStrings>  
  2.     <add name="BloggingContext"   
  3.                connectionString="Data Source=|DataDirectory|Enterprise.sqlite3"  
  4.                providerName="System.Data.SQLite" />  
  5. </connectionStrings>  

这时候拷贝Debug文件夹到目标客户电脑上即可直接运行了(前提是目标客户电脑上有.NET Framework),完全摆脱安装Oracle客户端。

 /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Form3_Load(object sender, EventArgs e)
        {
            BindGridView();
        }
        /// <summary>
        /// 
        /// </summary>
        private void BindGridView()
        {
            OracleConnection conn = new OracleConnection(connectionString);
            //ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString
            OracleCommand comm = new OracleCommand("pkg_BookKindList.fun_GetRecords", conn);
            comm.Parameters.Add("cur_return", OracleType.Cursor).Direction = ParameterDirection.Output;
            comm.CommandType = CommandType.StoredProcedure;
            DataSet ds = new DataSet();
            using (OracleDataAdapter da = new OracleDataAdapter(comm))
            {

                da.Fill(ds);
            }
            this.dataGridView1.DataSource = ds.Tables[0].DefaultView;


        }

我们来看看这个连接字符串,因为在web下我们可以使用|DataDirectory|来代表根目录下的App_Data文件夹,所以我们把连接字符串写成了上面的形式。

 

  

 

 /// <summary>
        /// 
        /// </summary>
        private void BindGridViewOther()
        {
            OracleConnection conn = new OracleConnection(connectionString);
            //ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString
            OracleCommand comm = new OracleCommand("pkg_BookKindList.fun_GetRecords", conn);
            comm.CommandType = CommandType.StoredProcedure;
            //定义参数,注意参数名必须与存储过程定义时一致,且类型为OracleType.Cursor
            OracleParameter cur_set = new OracleParameter("cur_return", OracleType.Cursor);
            //设置参数为输出类型
            cur_set.Direction = ParameterDirection.Output;           
            //添加参数
            comm.Parameters.Add(cur_set);
            DataSet ds = new DataSet();
            using (OracleDataAdapter da = new OracleDataAdapter(comm))
            {

                da.Fill(ds);
            }
            this.dataGridView1.DataSource = ds.Tables[0].DefaultView;


        }

下面列出2种类型数据库的类型做下对比:

  

SqlServer数据库连接字符串:

Oracle sql:

 

---某条记录的字段
drop PROCEDURE proc_Select_BookKindName;

CREATE OR REPLACE PROCEDURE proc_Select_BookKindName(kind_id IN BookKindList.BookKindID%type) AS
    --声明语句段
    v_name varchar2(20);
BEGIN
    --执行语句段
    SELECT o.BookKindName INTO v_name FROM BookKindList o where o.BookKindID=kind_id;
    dbms_output.put_line(v_name);
EXCEPTION
    --异常处理语句段
    WHEN NO_DATA_FOUND THEN dbms_output.put_line('NO_DATA_FOUND');
END;

--测试
begin
proc_Select_BookKindName(1);
end;



---一条记录
--创建包:
create or replace package pack_BookKindId is 
       type cur_BookKindId is ref cursor;  
end pack_BookKindId; 
--创建存储过程
create or replace procedure proc_curBookKindId(p_id in number,p_cur out pack_BookKindId.cur_BookKindId) 
is   
       v_sql varchar2(400);
begin  

       if p_id = 0 then   
          open p_cur for select * from BookKindList; 
       else   
          v_sql := 'select * from BookKindList where BookKindID =: p_id';  
          open p_cur for v_sql using p_id;   
       end if;  
end proc_curBookKindId;


--测试查询一条记录存储过程
-- Test statements here  
set serveroutput on
declare   
 v_id number := 1; --0 时,所有记录 
 v_row BookKindList%rowtype;   --注意这里是表名
 p_cur pack_BookKindId.cur_BookKindId;
begin   
 proc_curBookKindId(v_id, p_cur);  
 loop  
    fetch p_cur into v_row;  
    exit when p_cur%notfound;  
    DBMS_OUTPUT.PUT_LINE(v_row.BookKindName||'='||v_row.BookKindID);  
 end loop;  
 close p_cur;  
end; 

[html] view plaincopy图片 17图片 18

  

  1. <connectionStrings>  
  2.   <add name="BloggingContext" connectionString="  
  3.           Data Source=(localdb)v11.0;  
  4.           Initial Catalog=Blogging;Integrated Security=True;  
  5.           MultipleActiveResultSets=True"  
  6.           providerName="System.Data.SqlClient" />  
  7. </connectionStrings>  

ODP.NET:

Oracle数据库连接字符串:

  ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public List<BookKindListInfo> SelectBookKindListAll()
        {
            List<BookKindListInfo> list = new List<BookKindListInfo>();
            BookKindListInfo bookKindList = null;
            try
            {
                //定义参数,注意参数名必须与存储过程定义时一致,且类型为OracleType.Cursor
                OracleParameter cur_set = new OracleParameter("cur_return", OracleDbType.RefCursor);
                //设置参数为输出类型
                cur_set.Direction = ParameterDirection.Output;
                //OracleHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, "pkg_Select_BookKindListAll.proc_Select_BookKindListAll", cur_set)
                using (OracleDataReader reader = OracleHelper.GetReader("pkg_Select_BookKindListAll.proc_Select_BookKindListAll", CommandType.StoredProcedure, cur_set))
                {
                    while (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        string s = reader["BookKindID"].ToString();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (decimal)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (decimal)reader["BookKindParent"] : 0;
                        list.Add(bookKindList);

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return list;
        }
        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public DataTable SelectBookKindListDataTableAll()
        {
            DataTable dt = new DataTable();
            try
            {
                //定义参数,注意参数名必须与存储过程定义时一致,且类型为OracleType.Cursor
                OracleParameter cur_set = new OracleParameter("cur_return", OracleDbType.RefCursor);
                //设置参数为输出类型
                cur_set.Direction = ParameterDirection.Output;
                //添加参数
                //comm.Parameters.Add(cur_set);
                using (DataTable reader = OracleHelper.GetTable("pkg_Select_BookKindListAll.proc_Select_BookKindListAll", CommandType.StoredProcedure, cur_set))
                {
                    dt = reader;


                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return dt;
        }

 

  

 

[html] view plaincopy图片 19图片 20

  1. <connectionStrings>  
  2.   <add name="BloggingContext" connectionString="  
  3.     data source=test;password=123456;user id=sa;"  
  4.     providerName="Oracle.DataAccess.Client" />  
  5. </connectionStrings>  

只是数据提供程序不一样,也就是providerName属性值指定了当前的数据提供程序是什么。

 

下面的配置才是重点:

既然EntityFramework要提供一种通用的数据库访问逻辑,那么它就要适用于所有的数据库,那么微软是如何做到的呢?答案是抽象工厂

我们先在Web.config文件里面配置如下的配置节,稍后再讲整个的流程是如何运作的。

SqliteFactory数据工厂(针对Sqlite数据库)

 

[html] view plaincopy图片 21图片 22

  1. <system.data>  
  2.        <DbProviderFactories>  
  3.        <add name="SQLite Data Provider" invariant="  
  4.               System.Data.SQLite"   
  5.               description=".NET Framework Data Provider for SQLite"   
  6.               type="System.Data.SQLite.SQLiteFactory,   
  7.               System.Data.SQLite, Version=1.0.90.0, Culture=neutral,   
  8.               PublicKeyToken=db937bc2d44ff139" />  
  9.     </DbProviderFactories>  
  10. </system.data>  

 

Oracle数据工厂

 

[html] view plaincopy图片 23图片 24

  1. <system.data>  
  2.   <DbProviderFactories>  
  3.     <add name="Oracle Data Provider for .NET"  
  4.     invariant="Oracle.DataAccess.Client"   
  5.     description="Oracle Data Provider for .NET"  
  6.     type="Oracle.DataAccess.Client.OracleClientFactory,Oracle.DataAccess,  
  7.     Version=4.112.3.0, Culture=neutral, PublicKeyToken=89b483f429c47342" />  
  8.   </DbProviderFactories>  
  9. </system.data>  

 

这个配置节在C:WindowsMicrosoft.NETFrameworkv4.0.30319ConfigApp.config文件下面也有,默认的只有SqlServer数据库的,数据工厂。

System.Data程序集下面的System.Data.Common.DbProviderFactoriesConfigurationHandler 处理程序会解析<System.data/>配置节

在上面的:base("Name=BloggingContext")初始化DbContext构造函数的时候,就根据提供的数据库连接字符串找到了,当前的数据库提供程序(当前示例是:System.Data.Sqlite)

然后System.Data.Common下面的静态类DbProviderFactories的System.Data.Common.DbProviderFactories.GetFactoryClasses()。

(摘要:返回一个 System.Data.DataTable,其中包含有关实现 System.Data.Common.DbProviderFactory 的所有已安装提供程序的信息。)

然后GetFactory方法通过数据库连接字符串提供的providerName="System.Data.Sqlite",从GetFactoryClasses中找到invariant的值为System.Data.Sqlite的

已安装提供程序的信息(type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite, Version=1.0.90.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139")

这样通过反射就能动态创建System.Data.SQLite.SQLiteFactory工厂类了,工厂类创建完成以后,我们就能通过工厂类提供的工厂方法,创建Ado.net数据库访问实例就行数据库访问了。

        Oracle使用EntityFramework(CodeFirst模式)注意事项        

1、安装Oracle客户端,默认装在D:app下面(盘符随意)

2、我们看下Oracle自带的ODP.Net组件装在了以下的路径,D:appAdministratorproduct11.2.0dbhome_1ODP.NETbin4.0

3、我们要把第二步所示的目录下面的Oracle.DataAccess.dll拷贝到,Web引用程序的主站点下面,或者注册全局程序集缓存(GAC)

4、上述1-3的步骤,取决于你的Oracle客户端的版本,因为EntityFramework5.0只能运行在.NetFramework4.0以上,所以我们的Oracle.DataAccess.dll也必须是4.0的,也就是说D:appAdministratorproduct11.2.0dbhome_1ODP.NETbin  这个路径下必须有4.0的ODP.NET程序集,不然的话你就要去Oracle的官网下载ODAC对应.Net4.0的插件了。

5、同样要配置web.config文件的DbProviderFactorys(不要忘记了哦)

后续会补上类之间的继承关系。

 

应楼下要求附上Demo链接:请自行下载(如果对你有所帮助,不胜荣幸)

本文由pc28.am发布于计算机编程,转载请注明出处:伪CodeFirst开荒方式接纳于Sqlite数据库

上一篇:应用程式开拓平台,Smobiler开采平台 下一篇:没有了
猜你喜欢
热门排行
精彩图文
  • 应用程式开拓平台,Smobiler开采平台
    应用程式开拓平台,Smobiler开采平台
    最前面的话:Smobiler是一个在VS环境中使用.Net语言来开发APP的开发平台,也许比Xamarin更方便 .Net语言 APP开发平台——Smobiler学习日志:如何在手机上实现电
  • NET开拓能源大全
    NET开拓能源大全
    目录 API 应用框架(ApplicationFrameworks) 应用模板(ApplicationTemplates) 人工智能(ArtificialIntelligence) 程序集处理(AssemblyManipulation) 资源(Assets) 认证和授
  • STM32就学笔记之C语言篇
    STM32就学笔记之C语言篇
    【unsigned】 1、rewind(FILE *卡塔尔(英语:State of Qatar):回到文件开头处 2、fprintf(), fscanf(), fgets(), fputs() (1)、fprintf(#FILE *restrict#, #const char *restrict,...#卡塔尔(英语
  • python面向对象三大特征,面向对象
    python面向对象三大特征,面向对象
    面向对象-组合 风流罗曼蒂克、面向进度与面向对象的简要介绍 一、继承 大器晚成 什么是多态动态绑定(在这里起彼伏的背景下行使时,一时也称得上多
  • HttpRuntime的认知与抓好明白,异步HTTP乞请操作
    HttpRuntime的认知与抓好明白,异步HTTP乞请操作
    一、说明 上边最早介绍HttpRuntime的Web.config里的构造 1卡塔尔(英语:State of Qatar) 那些类 是本身 在安分守己项目中,优化驱除实际难题时,不参照第三方代码