转：EF调用存储过程、函数

1. public int AddVote(int titleId, int blockId, int typeId)  
2.         {  
3.             List<SqlParameter> paramArray = new List<SqlParameter>();  
4.             paramArray.Add(new SqlParameter("@titleId", titleId));  
5.             paramArray.Add(new SqlParameter("@blockId", blockId));  
6.             paramArray.Add(new SqlParameter("@typeId", typeId));  
7.             SqlParameter param = new SqlParameter("@num", SqlDbType.Int);  
8.             param.Direction = ParameterDirection.Output;  
9.             paramArray.Add(param);  
10.                           
11.             using (RPDBContext db = new RPDBContext())  
12.             {  
13.                 try  
14.                 {  
15.                     db.Database.ExecuteSqlCommand("EXEC [AddVote] @blockId,@titleId,@typeId,@num out", paramArray.ToArray());  
16.                 }  
17.                 catch (Exception ex)  
18.                 {  
19.                     throw;  
20.                 }  
21.                 int result = (int)paramArray[3].Value;  
22.                 return result;  
23.             }  
24.         }  

存储过程测试实例：

[sql]  view plain  copy

 

1. USE [HY_ReplyComment]  
2. GO  
3. /****** 对象:  StoredProcedure [dbo].[AddVote]    脚本日期: 06/10/2014 22:27:11 ******/  
4. SET ANSI_NULLS ON  
5. GO  
6. SET QUOTED_IDENTIFIER ON  
7. GO  
8.   
9. -- =============================================  
10. -- Author:        <Author,,Name>  
11. -- Create date: <Create Date,,>  
12. -- Description:    <Description,,>  
13. -- =============================================  
14. CREATE PROCEDURE [dbo].[AddVote]   
15.     @blockId int,  
16.     @titleId int,  
17.     @typeId int,  
18.     @num int output  
19. AS  
20. BEGIN  
21.     -- SET NOCOUNT ON added to prevent extra result sets from  
22.     -- interfering with SELECT statements.  
23.     SET NOCOUNT ON;  
24.   
25.     SELECT @num = Count(1) FROM [Vote] WHERE TitleId = @titleId AND BlockId = @blockId  
26.   
27. END  

 

 

 

一.ef4.1 codeFirst 修改表结构 增加字段等 EF code first需要重新生成库导致数据丢失的问题

说这个问题前 首先先说下 我使用ef4.1 codefirst的目的. 是因为可以有更纯净的POCO 不再有EDMX这些东西  而不是真正的用 code first 先有代码 再生成数据库.所以 我虽然使用

的是codefirst 但是本质依然是数据库优先.

所以这个被问的很多的问题 解决办法其实是非常简单的.只要你的数据库已经存在了 那么即使你用code first ef 也不会给你去生成数据库的. 这个时候 你增加表字段 甚至增加表 只要把

实体类也相应的修改 则数据库里的数据 是不会被清空的.

说下我的开发步骤  先设计数据库 并建立数据库=>通过EF工具生成映射和实体类=>开发代码     当遇到修改时=>  先修改数据库如添加字段或表等=>再修改实体类=>继续开发

这样就不会有重新生成数据的烦恼了 而且项目里也不会出现edmx~

还有 使用EF4.3 的数据迁移功能 也可以完美解决~

二.ef4.1 没有了edmx等复杂的东西 变得简单 干净  但如何使用存储过程,存储过程可以返回表 可以返回数值 也有可能是执行修改 删除 增加等  该怎么做？

说这个问题前 依然先说下我的观点.个人认为 既然使用orm框架  就应该把业务逻辑等 都放到业务逻辑层 而不应该再使用存储过程。我更偏重重业务逻辑层 轻存储过程这样的开发~

再ef4.0里 添加存储过程 比较容易 有edmx 调一调 存储过程就添加上了 但是在ef4.1里 只有干净的poco 不再有edmx了 改怎么办呢？尤其是存储过程可以是查表 查值 或者执行修改删除.

一个一个来解决

1.执行返回表类型的存储过程

先上存储过程 随手写的一个最简单的

Create PROCEDURE [dbo].[ProSelectStu]
    @StudentID int
AS
BEGIN
Select Student.* from Enrollment,Student  

where Enrollment.StudentID=Student.StudentID and Enrollment.StudentID=@StudentID
END
GO

执行存储过程的方法 是用直接执行sql的方式 我在我的文章第九篇 有过详细的介绍~大家可以先去看下

执行表的存储过程 其实是非常强大的 延迟加载 等都有体现 博客园的陆老师已经写了 写的非常清楚了~我这里就不再写了 大家可以去他那看下 提供个连接~

EF使用存储过程查询表的

2.执行返回值的存储过程

先上存储过程

CREATE PROCEDURE [dbo].[ProSelectCount]
    @StuId int
AS
BEGIN
    select COUNT(*) from Enrollment where StudentID=@StuId
END

一个简单的查询数量

这里用sqlQuery 执行访问 数据库 因为需要提供返回类型 而我们返回的是int 所以先得到int的类型

3.执行增删改

CREATE PROCEDURE [dbo].[ProDel]
    @stuId int,
    @courseId int
AS
BEGIN
    DELETE FROM [WLFSchool].[dbo].[Enrollment] 
    where StudentID=@stuId and CourseID=@courseId
END

这个用的是操作数据库 返回受影响行数

三.ef4.1 如何使用数据库视图？每个视图都要去建立对应的实体类么？有简单的方法么？

先说下最传统的方法 只需把视图 当成表 建立对应的实体类  然后加到dbcontext 里即可。没什么难度。

再说一个问题 使用linq 有个非常美妙的功能 投影映射 和C#3.0的 匿名函数 让我们很多情况 不需要视图的

                                  from c in classes
                                  from s in students
                                  where c.ClassID == s.ClassID
                                  order by c.CreateTime
                                  select new
                                  {
                                      Name = s.Name,
                                      Age = s.Age,
                                      ClassName = c.ClassName                                 
                                 };

再通过  var result 接受上面的值  这样我们就不用去数据库建视图 不用再建实体类 是不是很省事呢？

如果公司强大的DBA 已经给我们建好了很多视图 是不是就要一个个去写实体类呢？如果你使用的是C#4.0 那么可以用动态的 来解决这个问题~

像下面这样使用 是不是很爽

这个不仅可以查询视图 普通的表 只要是SQL语句 都可以自动生成动态类 让你用~

下面是扩展方法  和 使用Emit 来动态构建 感谢 ASP.NET 韋 给的帮助~~

  public static class DatabaseExtensions
    {
        public static IEnumerable SqlQueryForDynamic(this Database db,
                string sql,
                params object[] parameters)
        {
            IDbConnection defaultConn = new System.Data.SqlClient.SqlConnection();

            return SqlQueryForDynamicOtherDB(db, sql, defaultConn, parameters);
        }

        public static IEnumerable SqlQueryForDynamicOtherDB(this Database db,
                      string sql,
                      IDbConnection conn,
                      params object[] parameters)
        {
            conn.ConnectionString = db.Connection.ConnectionString;

            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            IDbCommand cmd = conn.CreateCommand();
            cmd.CommandText = sql;

            IDataReader dataReader = cmd.ExecuteReader();

            if (!dataReader.Read())
            {
                return null; //无结果返回Null
            }

            #region 构建动态字段

            TypeBuilder builder = DatabaseExtensions.CreateTypeBuilder(
                          "EF_DynamicModelAssembly",
                          "DynamicModule",
                          "DynamicType");

            int fieldCount = dataReader.FieldCount;
            for (int i = 0; i < fieldCount; i++)
            {
                //dic.Add(i, dataReader.GetName(i));

                //Type type = dataReader.GetFieldType(i);

                DatabaseExtensions.CreateAutoImplementedProperty(
                  builder,
                  dataReader.GetName(i),
                  dataReader.GetFieldType(i));
            }

            #endregion

            dataReader.Close();
            dataReader.Dispose();
            cmd.Dispose();
            conn.Close();
            conn.Dispose();

            Type returnType = builder.CreateType();

            if (parameters != null)
            {
                return db.SqlQuery(returnType, sql, parameters);
            }
            else
            {
                return db.SqlQuery(returnType, sql);
            }
        }

        public static TypeBuilder CreateTypeBuilder(string assemblyName,
                              string moduleName,
                              string typeName)
        {
            TypeBuilder typeBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
              new AssemblyName(assemblyName),
              AssemblyBuilderAccess.Run).DefineDynamicModule(moduleName).DefineType(typeName,
              TypeAttributes.Public);
            typeBuilder.DefineDefaultConstructor(MethodAttributes.Public);
            return typeBuilder;
        }

        public static void CreateAutoImplementedProperty(
                            TypeBuilder builder,
                            string propertyName,
                            Type propertyType)
        {
            const string PrivateFieldPrefix = "m_";
            const string GetterPrefix = "get_";
            const string SetterPrefix = "set_";

            // Generate the field.
            FieldBuilder fieldBuilder = builder.DefineField(
              string.Concat(
                PrivateFieldPrefix, propertyName),
              propertyType,
              FieldAttributes.Private);

            // Generate the property
            PropertyBuilder propertyBuilder = builder.DefineProperty(
              propertyName,
              System.Reflection.PropertyAttributes.HasDefault,
              propertyType, null);

            // Property getter and setter attributes.
            MethodAttributes propertyMethodAttributes = MethodAttributes.Public
              | MethodAttributes.SpecialName
              | MethodAttributes.HideBySig;

            // Define the getter method.
            MethodBuilder getterMethod = builder.DefineMethod(
                string.Concat(
                  GetterPrefix, propertyName),
                propertyMethodAttributes,
                propertyType,
                Type.EmptyTypes);

            // Emit the IL code.
            // ldarg.0
            // ldfld,_field
            // ret
            ILGenerator getterILCode = getterMethod.GetILGenerator();
            getterILCode.Emit(OpCodes.Ldarg_0);
            getterILCode.Emit(OpCodes.Ldfld, fieldBuilder);
            getterILCode.Emit(OpCodes.Ret);

            // Define the setter method.
            MethodBuilder setterMethod = builder.DefineMethod(
              string.Concat(SetterPrefix, propertyName),
              propertyMethodAttributes,
              null,
              new Type[] { propertyType });

            // Emit the IL code.
            // ldarg.0
            // ldarg.1
            // stfld,_field
            // ret
            ILGenerator setterILCode = setterMethod.GetILGenerator();
            setterILCode.Emit(OpCodes.Ldarg_0);
            setterILCode.Emit(OpCodes.Ldarg_1);
            setterILCode.Emit(OpCodes.Stfld, fieldBuilder);
            setterILCode.Emit(OpCodes.Ret);

            propertyBuilder.SetGetMethod(getterMethod);
            propertyBuilder.SetSetMethod(setterMethod);
        }

    }

四.ef4.1 如何执行SQL函数等操作？

添加引用  System.Data.Objects.SqlClient.SqlFunctions 主要是这个命名空间

使用方法~上一个工作中的例子~

var query = from s in student.T_StudentInfo
                        where SqlFunctions.DateDiff("day", s.CreateTime, "2011/11/4") == 0
                        select s.StudentName;

使用SQL 的datadiff 函数~~

如果觉得文章对您有帮助，请不吝点个赞，表示一下支持！谢谢！