标签: ienumerable

假设同一个集合上的两个itterations将以相同的顺序返回对象是否安全？显然,假设该集合没有另外改变.

public IEnumerable<ModuleData> ListModules()
{
    foreach (XElement m in Source.Descendants("Module"))
    {
        yield return new ModuleData(m.Element("ModuleID").Value);
    }
}

最初上面的代码很棒,因为如果不需要,就不需要评估整个集合.

但是,一旦枚举了所有模块,在没有更改时重复查询XDocument会变得更加昂贵.

因此,作为绩效改进:

public IEnumerable<ModuleData> ListModules()
{
    if (Modules == null)
    {
        Modules = new List<ModuleData>();
        foreach (XElement m in Source.Descendants("Module"))
        {
            Modules.Add(new ModuleData(m.Element("ModuleID").Value, 1, 1));
        }
    }
    return Modules;
}

如果我反复使用整个列表,那就太好了,但不是那么好.

是否存在中间点,我可以在整个列表被迭代之前返回,然后缓存它并将缓存提供给后续请求？

所以我内部有一个类和一个通用List,但它是私有的.

class Contacts
{
    List<Contact> contacts;
    ...
}

我想让这个课有效:

foreach(Contact in contacts) .... ;

像这样(不工作):

Contacts c;
foreach(Contact in c) .... ;

在上面的示例中,Contact类实例c必须从联系人返回每个项目(c的私有成员)

我该怎么做？我知道它必须是IEnumerable与yield return,但在哪里声明？

鉴于....

Public MasterList as IEnumerable(Of MasterItem)
Public Class MasterItem(Of T) 
    Public SubItems as IEnumerable(Of T)
End Class 

我想要一个IEnumerable(Of T),它将遍历MasterList中所有MasterItem的所有SubItems

我想认为有一个Linq工具可以做到这一点,或者我正在忽略的扩展方法.我需要一种在VB9(2008)中运行的机制,因此不使用Yield.

假设我有

var input = new int[] { 0, 1, 2, 3, 4, 5 };

如何将它们分组成对？

var output = new int[][] { new int[] { 0, 1 }, new int[] { 2, 3 }, new int[] { 4, 5 } };

最好使用LINQ

如果我单步执行以下代码,则会跳过对ReturnOne()的调用.

static IEnumerable<int> OneThroughFive()
{
    ReturnOne();
    yield return 2;
    yield return 3;
    yield return 4;
    yield return 5;
}

static IEnumerator<int> ReturnOne()
{
    yield return 1;
}

我只能假设编译器正在剥离它,因为我正在做的是无效的.我希望能够将我的枚举分离成各种方法.这可能吗？

我们可以在单元测试中使用循环吗？

我的方法返回一个IEnumerable<IEnumerable>,我想在IEnumerable<IEnumerable>创建它的地方单元测试这个逻辑.基本上我想测试一下元素的数量IEnumerable是否符合预期.

我没有找到另一种方法来测试内部IEnumerable而没有循环语句.如果这是一个很好的做法,请告诉我.

我怎么能转换DataTable的IEnumerable<dynamicObject>？

例如,我想转换任何 DataTable

ID | Name          DI | emaN
---------    or    ---------
 1 | x              2 | x
 2 | y              1 | y

在对象列表中

// list 1      (ex 1)             // list 2    (ex 2)
{                                 {
  { ID = 1, Name = "x" }            { DI = 2, emaN = "x" }
  { ID = 2, Name = "y" }            { DI = 1, emaN = "y" }
}                                 }

所以

list1.First().ID    // 1 …

在当前项目中,客户要求以两种方式回答调查问卷的可能性:一次使用Wizard(一次一个问题)和Listing(一次性所有问题).两种方式都已实施.

使用AJAX按照手册的章节从数据库加载问题(这非常快).目前最重要的章节有230问题(每个都有4个HTML输入字段 - 输入/文本,选择等).如果用户选择此类章节以Listing格式回答,<form>则将包含920要发布到服务器的大约字段.

我正在做一个使用jQuery serialize方法传递数据的AJAX POST请求:

data: $("#questions :input").serialize()

此序列化需要207.143ms完成.我在Firefox中使用Firebug调试了这个值:

console.profile();
$("#questions :input").serialize();
console.profileEnd();

这又是超级快......

在对以下操作方法收到的数据进行保湿时会出现问题:

public async Task<ActionResult> ListSaveAsync(IEnumerable<AnswerViewModel> questions)

如您所见,发布的数据是绑定到的数据IEnumerable<AnswerViewModel> questions.AnswerViewModel只有4个字段来存储每个答案.

问题是,在单击"保存"按钮以触发此操作方法的断点之后需要相当长的时间(精确地为10秒),也就是说,大概在模型绑定器中花费了10秒.

值得一提的是,我正在使用Steve Sanderson的@ Html.BeginCollectionItem助手来帮助从HTTP POST实现ViewModel集合属性.查看数据如何在ViewModel(Keys)中获取:

你知道我可以尝试做些什么来优化这个吗？

我想过4个解决方法:

1. 仅保存修改后的问题.要做到这一点我需要加载列表时,每个答案的值存储在数据属性并提交时,它与实际值进行比较<form>,因为这家伙表明这里.

2. AnswerViewModel在客户端创建JavaScript对象并将其传递给action方法.这会减轻Model Binder吗？

3. 滚动我自己的模型绑定...但我真的不知道它是否会比ASP.NET MVC附带的默认绑定更快.从我所看到的,默认模型绑定器做了很多反思来设置值/水合动作的模型参数,这可能是瓶颈.

4. 使用FormCollection并通过钥匙发布数据获取每个值,如图所示手动执行验证列举在这里.

你还有什么建议？

更新1

我使用选项3并实现了一个自定义模型绑定器:AnswerModelBinder : IModelBinder并在特定的操作方法中使用它:

public async Task<ActionResult> ListSaveAsync(
             [ModelBinder(typeof(AnswerModelBinder))]List<AnswerViewModel> questions) …

在以下代码中:

public class A
{
    public decimal Decimal { get; set; }
}

public decimal Test()
{
    return new List<A>().Sum(SumDecimal);
}

public decimal SumDecimal(A a)
{
    return a.Decimal;
}

该行return new List<A>().Sum(SumDecimal);有一个错误,指出这SumDecimal是一个模糊的调用.

为什么编译器无法推断出类型SumDecimal.但是,以下工作:

return new List<A>().Sum((Func<A, decimal>) SumDecimal);

当然,通常的lambda方式也适用:

return new List<A>().Sum(x => SumDecimal(x));

在更多实验中,如果我编写自己的扩展方法:

public static class MyExtensions
{
    public static T MySum<T, T2>(this IEnumerable<T2> ie, Func<T2, T> d)
    {
        return default(T);
    }
}

并称之为,编译器推断得很好:

return new List<A>().MySum(SumDecimal);

我看到,IEnumerable<T>.Sum目前超载int, …