我有一个看起来像这样的课:

public class Field
{
    public string FieldName;
    public string FieldType;
}

并且List<Field>具有值的对象:

{"EmployeeID","int"},
{"EmployeeName","String"},
{"Designation","String"}

我想创建一个如下所示的类:

Class DynamicClass
{
    int EmployeeID,
    String EmployeeName,
    String Designation
}

有没有办法做到这一点？

我希望在运行时生成它.我不希望物理CS文件驻留在我的文件系统中.

假设我有一个包含四列的DataTable,Company(字符串),Fund(字符串),State(字符串),Value(double):

    table1.Rows.Add("Company 1","Fund 1","NY",100));
    table1.Rows.Add("Company 2","Fund 1","CA",200));
    table1.Rows.Add("Company 3","Fund 1","FL",300));
    table1.Rows.Add("Company 4","Fund 2","CA",400));
    table1.Rows.Add("Company 5","Fund 1","NY",500));
    table1.Rows.Add("Company 6","Fund 2","CA",600));
    table1.Rows.Add("Company 7","Fund 3","FL",700));

我想使用System.LINQ.Dynamic构建一个动态查询,该查询在公司,基金或州上分组,然后按条件选择我的组作为第一列,并且sum(value):

string groupbyvalue="Fund";
var q1= table1.AsEnumerable().AsQueryable()
              .GroupBy(groupbyvalue,"it")
              .Select("new ("+groupbyvalue+" as Group, Sum(Value) as TotalValue)");

在上面的查询中,所选的groupbyvalue(Group)将始终是一个字符串,并且总和将始终为double,因此我希望能够转换为类似List的内容,其中Result是具有属性Group的对象(字符串) )和TotalValue(双).

我遇到很多麻烦,有人可以解决这个问题吗？

如果我在实体框架中有三个类.

class Base {}

class Left : Base {}

class Right : Base {}

我打电话给 DBContext.Bases.ToList();

这会将Base完全键入的所有实例返回到其关联的继承类型中,正如一些人已经注意到的,EF对大型继承结构的性能至少可以说不是很好.我在我的项目中的实际查询是600行,只是为了返回一个实体,需要2秒生成.

如果你告诉它返回哪种类型,它们的查询运行速度要快得多,因为它不必连接整个结构.例如

DBContext.Bases.OfType<Left>.ToList();
or
DBContext.Bases.OfType<Right>.ToList();

但是我现在想只返回基类.不幸做的

DBContext.Bases.OfType<Base>.ToList(); 

与DBContext.Bases.ToList()相同;

它获得了WHOLE继承结构...... 在查看Base集合时,是否有任何方法(不在EF中创建新类型)只返回类Base？

对不起,我无法登录我的实际帐户...

也许我没有说清楚,我想带回所有对象(包括Base,Left和Right),但我只想返回Base类,即使在数据库中它们是实际的Left和Right类.

OFTYPE是一个很好的建议,但它过滤掉了我的所有实体,因为没有一个是实际的Base类型.但我想只返回Base类型对象中的Base类型值.

有任何想法吗？

只是尝试从JSON创建一个匿名类型,而不必提前了解任何参数,并完全解释它们(可能带有提示).即该值"看起来"像int,string或date.

到目前为止,我所知道的唯一方法是创建一个你已经知道的匿名类型.请参阅下面的.DeserializeAnonymousType(...)方法.

任何人都可以比这更好吗？谢谢.

        var jsonString = "{\"user_id\": 1, \"user_type\": \"moderator\", \"name\": \"Fred\"}";

        JToken root = JObject.Parse(jsonString);

        var anonTemplate = new{user_id=0, user_type="", name="" };

        var a = JsonConvert.DeserializeAnonymousType(root.ToString(), anonTemplate);


        var b = JsonConvert.DeserializeObject<Object>(root.ToString());  // actually turns into a JsonObject which is something differet.

更新

我下载了dynamicduck并且正在玩它.这种奇怪的动态"包装"理念是否能够以我需要的方式(可序列化等)实现？

http://weblogs.asp.net/britchie/archive/2010/08/05/json-net-dynamic-extensions.aspx

http://weblogs.asp.net/britchie/archive/2010/08/03/dynamicduck-duck-typing-in-a-dynamic-world.aspx

我有一个复选框列表,用户可以选中或取消选中复选框.

根据选中的复选框,我用以逗号分隔的方式存储该值.现在问题是基于我需要单独获取该特定列的选中复选框.在"选择"**

db.Tasks.OrderBy(t => t.CreatedDate).ToList()
  .Select(t => new {
       Id = t.Id, 
       PriorityId = t.ProjectId, 
       Priority = t.Priority, 
       StatusId = t.StatusId, 
       Status = t.Status,
       EstimatedTime = t.EstimatedTime, 
       ActualTime = t.ActualTime, 
       Subject = t.Subject, 
       FileName = t.FileName,
       AssignedTo = t.AssignedTo, 
       Project = t.Project 
   }).ToList();

如果我选中复选框列表ActualTime,Subject,它应该是

db.Tasks.OrderBy(t => t.CreatedDate).ToList()
  .Select(t => new {
       Id = t.Id,       
       ActualTime = t.ActualTime, 
       Subject = t.Subject
   }).ToList();

如果我选中复选框列表主题,FileName,AssignedTo,它应该是

db.Tasks.OrderBy(t => t.CreatedDate).ToList()
  .Select(t => new {
           Id = t.Id,  
           Subject = t.Subject, 
           FileName = t.FileName,
           AssignedTo = …

我正在尝试将对象传递给 Web api 应用程序。在序列化对象时，它会将其转换为 json 字符串。但是在 wep api 应用程序端，它将对象参数作为 JObject 获取。此代码块来自 web api 应用程序；

//Read web api body content into a string variable
var resultStr = Request.Content.ReadAsStringAsync().Result;
//Convert json string to object with Newtonsoft
var obj = Newtonsoft.Json.JsonConvert.DeserializeObject<object>(resultStr);

此代码生成一个 JObject 但我需要一个匿名对象。Web api 项目不知道类型。可以接收任何对象类型。

我需要一个这样的对象。

object anonyObj = new { Prop1 = "Lorem" };

ExpandoObject 类型不符合我的要求，因此转换为动态类型对我来说不是一个解决方案。

如何返回依赖于fields参数的匿名类型,其中列出了必须包含在匿名类型中的属性？任务实体具有20多个属性,并且客户希望接收不同的属性组合.

public class Test
{
    public class Task
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        //... more 20 properties
    }

    public List<Task> Tasks = new List<Task>();

    public Test()
    {
        Tasks.Add(new Task { Id = 1, Name = "Task #1", Description = "Description task #1" });
        Tasks.Add(new Task { Id = 2, Name = "Task #2", Description = "Description task #2" });
        Tasks.Add(new Task { Id …

如何使用表达式树生成以下内容...

var people = context.Set<Person>();
var transactions = context.Set<FinancialTransaction>();

var dataview = people.Where( p => p.LastName == "Smith" );

var selection = dataview
        .Select( p => new
        {
            FirstName = p.FirstName,
            LastName = p.LastName,
            LastTransaction =
                transactions
                    .Where( t => t.AuthorizedPersonId == p.Id )
                    .Max( t => t.TransactionDateTime )
        } );

gReport.AutoGenerateColumns = true;
gReport.DataSource = selection.ToList();
gReport.DataBind();

我正在尝试使用Ethan Brown 在这里提供的LinqRuntimeTypeBuilder解决方案,但在如何为LastTransaction子查询创建表达式以及如何将查询绑定到GridView方面苦苦挣扎.

这就是我到目前为止......

var people = context.Set<Person>();
var transactions = context.Set<FinancialTransaction>();

var dataview = people.Where( p => p.LastName == "Smith" …

背景

我需要能够构建一个.Include,将结果过滤到特定日期或之前创建的记录.我不会知道原始LINQ语句中对象的类型,我将找到它们(通过大量的箍,但这是有效的).

我有一个像这样的对象图:

          A -> Ac
         /  \
  Bc <- B    \
       /      \  
Cc <- C        D -> Dc

对象Ac,Bc,Cc,和Dc都是动态发现的(也就是写原来的LINQ语句时,开发者没有键入这些关系).然后需要将它们添加到IQueryable表达式,并仅返回特定DateTime的值.

迄今为止的守则

我尝试构建一个构造lambda并比较日期的函数.到目前为止,如果原始查询是A.Include(x => x.B).Include(x => x.B.Select(y => y.C),我可以构造字符串"A.B.Bc",所以我知道A,B和Bc的类型,以及它们的相关方式.

private static IQueryable<T> FilterChangeTrackerToDate<T>(this IQueryable<T> query, string includeString, DateTime targetDateTime)
{
    var param = Expression.Parameter( typeof( T ), "x" );

    var prop = Expression.Property(param, includeString + ".CreatedUtc");

    var dateConst = Expression.Constant(targetDateTime);

    var compare = Expression.LessThanOrEqual(prop, dateConst);

    var lambda = …