Anonyme Art Ergebnis von SQL-Abfrage Ausführung Entität Framework

Question

Ich verwende Entity Framework 5.0 mit .net Framework 4.0 Code ersten Ansatz. Jetzt weiß ich, dass ich raw SQL in Entity Framework laufen kann durch folgende

var students = Context.Database.SqlQuery<Student>("select * from student").ToList(); 

Es funktioniert perfekt, aber was ich will, ist anonym Ergebnisse zurück. Zum Beispiel möchte ich nur bestimmte Spalten von Student-Tabelle wie folgende

var students = Context.Database.SqlQuery<Student>("select FirstName from student").ToList(); 

Es funktioniert nicht. es gibt Ausnahme

Der Datenleser ist nicht kompatibel mit dem angegebenen 'MyApp.DataContext.Student'. Ein Mitglied des Typs 'StudentId' hat keine entsprechende Spalte im Datenleser mit demselben Namen.

So habe ich dynamic Typ

versucht

var students = Context.Database.SqlQuery<dynamic>("select FirstName from student").ToList(); 

es ist auch nicht funktioniert, ist es ein leeres Objekt zurückgibt. Keine Daten verfügbar.

Gibt es eine Möglichkeit, anonyme Ergebnisse von einer dynamischen SQL-Abfrage zu erhalten?

Answer 1

Hier ist endgültige Lösung, die für mich in Ordnung war.

public static System.Collections.IEnumerable DynamicSqlQuery(this Database database, string sql, params object[] parameters) 
     { 
      TypeBuilder builder = createTypeBuilder(
        "MyDynamicAssembly", "MyDynamicModule", "MyDynamicType"); 

      using (System.Data.IDbCommand command = database.Connection.CreateCommand()) 
      { 
       try 
       { 
        database.Connection.Open(); 
        command.CommandText = sql; 
        command.CommandTimeout = command.Connection.ConnectionTimeout; 
        foreach (var param in parameters) 
        { 
         command.Parameters.Add(param); 
        } 

        using (System.Data.IDataReader reader = command.ExecuteReader()) 
        { 
         var schema = reader.GetSchemaTable(); 

         foreach (System.Data.DataRow row in schema.Rows) 
         { 
          string name = (string)row["ColumnName"]; 
          //var a=row.ItemArray.Select(d=>d.) 
          Type type = (Type)row["DataType"]; 
          if(type!=typeof(string) && (bool)row.ItemArray[schema.Columns.IndexOf("AllowDbNull")]) 
          { 
           type = typeof(Nullable<>).MakeGenericType(type); 
          } 
          createAutoImplementedProperty(builder, name, type); 
         } 
        } 
       } 
       finally 
       { 
        database.Connection.Close(); 
        command.Parameters.Clear(); 
       } 
      } 

      Type resultType = builder.CreateType(); 

      return database.SqlQuery(resultType, sql, parameters); 
     } 

     private 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; 
     } 

     private 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); 
     }  

Answer 2

Sie den Code aus hier versuchen können, scrollen Sie nach unten und finden Sie die von Stankovski implementieren: http://www.codeproject.com/Articles/206416/Use-dynamic-type-in-Entity-Framework-SqlQuery

Nachdem Sie den Code in einer statischen Klasse kopieren, können Sie diese Funktion aufrufen zu bekommen, was Sie wollen:

var students = Context.Database.DynamicSqlQuery("select FirstName from student").ToList() 

Answer 3

Wenn Sie eine Einheit, und Sie wollen nur einige der Eigenschaften sichern Ihnen eine noch bessere Lösung mit Hilfe der Reflexion zu bekommen.

Dieser Code baut auf dem gleichen Beispiel wie in der obigen Antwort auf.

Zusätzlich können Sie einen Typ und ein Array von Feldern angeben, die Sie zurück erhalten möchten.

Das Ergebnis ist vom Typ IEnumerable.

public static class DatabaseExtension 
{ 
    public static IEnumerable<T> DynamicSqlQuery<T>(this Database database, string[] fields, string sql, params object[] parameters) where T : new() 
    { 
     var type = typeof (T); 

     var builder = CreateTypeBuilder("MyDynamicAssembly", "MyDynamicModule", "MyDynamicType"); 

     foreach (var field in fields) 
     { 
      var prop = type.GetProperty(field); 
      var propertyType = prop.PropertyType; 
      CreateAutoImplementedProperty(builder, field, propertyType); 
     } 

     var resultType = builder.CreateType(); 

     var items = database.SqlQuery(resultType, sql, parameters); 
     foreach (object item in items) 
     { 
      var obj = new T(); 
      var itemType = item.GetType(); 
      foreach (var prop in itemType.GetProperties(BindingFlags.Instance | BindingFlags.Public)) 
      { 
       var name = prop.Name; 
       var value = prop.GetValue(item, null); 
       type.GetProperty(name).SetValue(obj, value); 
      } 
      yield return obj; 
     } 
    } 

    private 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; 
    } 

    private 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, 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); 
    }  
} 

Sie können es nennen diese Art und Weise:

var fields = new[]{ "Id", "FirstName", "LastName" }; 
var sql = string.Format("SELECT {0} FROM People WHERE Id = @id", string.Join(", ", fields)); 

var person = db.Database.DynamicSqlQuery<People>(fields, sql, new SqlParameter("id", id)) 
    .FirstOrDefault(); 

Eigentlich funktioniert es auf einfache Typen nur und es gibt keine Fehlerbehandlung.

Answer 4

Sie müssen Raw Sql dafür verwenden, das Entity-Framework SqlQuery<T> funktioniert nur für Objekte mit bekannten Typen.

hier ist die Methode, die ich verwenden:

public static IEnumerable<dynamic> DynamicListFromSql(this DbContext db, string Sql, Dictionary<string, object> Params) 
{ 
    using (var cmd = db.Database.Connection.CreateCommand()) 
    { 
     cmd.CommandText = Sql; 
     if (cmd.Connection.State != ConnectionState.Open) { cmd.Connection.Open(); } 

     foreach (KeyValuePair<string, object> p in Params) 
     { 
      DbParameter dbParameter = cmd.CreateParameter(); 
      dbParameter.ParameterName = p.Key; 
      dbParameter.Value = p.Value; 
      cmd.Parameters.Add(dbParameter); 
     } 

     using (var dataReader = cmd.ExecuteReader()) 
     { 
      while (dataReader.Read()) 
      { 
       var row = new ExpandoObject() as IDictionary<string, object>; 
       for (var fieldCount = 0; fieldCount < dataReader.FieldCount; fieldCount++) 
       { 
        row.Add(dataReader.GetName(fieldCount), dataReader[fieldCount]); 
       } 
       yield return row; 
      } 
     } 
    } 
} 

Sie können es so nennen:

List<dynamic> results = DynamicListFromSql(myDb,"select * from table where a=@a and b=@b", new Dictionary<string, object> { { "a", true }, { "b", false } }).ToList();