相关疑难解决方法(0)

我有三个(可能有超过3-4个通用列表,但在这个例子中让3)通用列表.

List<string> list1

List<string> list2

List<string> list3

所有列表都具有相同数量的元素(相同的计数).

我用它来组合两个ZIP列表:

var result = list1.Zip(list2, (a, b) => new {
  test1 = f,
  test2 = b
}

我用它来foreach声明,以避免foreach每个List,就像

foreach(var item in result){
Console.WriteLine(item.test1 + " " + item.test2);
}

如何在三个列表中使用带有Zip的simmilary？

谢谢

编辑:

我想要:

List<string> list1 = new List<string>{"test", "otherTest"};

List<string> list2 = new List<string>{"item", "otherItem"};

List<string> list3 = new List<string>{"value", "otherValue"};

ZIP之后(我不知道方法),我想结果(在VS2010调试模式下)

[0] { a = {"test"},
      b = {"item"},
      c = {"value"}
    }   

[1] { a = …

下面是一个示例代码,用于使用我在google搜索时在几个地方找到的yield关键字从数据库中检索数据:

public IEnumerable<object> ExecuteSelect(string commandText)
{
    using (IDbConnection connection = CreateConnection())
    {
        using (IDbCommand cmd = CreateCommand(commandText, connection))
        {
             connection.Open();
             using (IDbDataReader reader = cmd.ExecuteReader())
             {
                while(reader.Read())
                {
                    yield return reader["SomeField"];
                }
             }
             connection.Close();
        }
    }
}

我是否认为在此示例代码中,如果我们不遍历整个datareader,连接将不会被关闭？

如果我理解正确的收益,这是一个不会关闭连接的例子.

foreach(object obj in ExecuteSelect(commandText))
{
  break;
}

对于可能不是灾难性的数据库连接,我想GC最终会将其清理干净,但是如果不是连接它会是一个更关键的资源呢？

我有3个完全相同的项目集合.

我需要根据这3个集合项值创建一个新集合.

例如:

List<double> list1;
List<double> list2;
List<double> list3;

List<Item> list4;

public class Item
{
   public double Value1{get;set;}
   public double Value2{get;set;}
   public double Value3{get;set;}
}

我尝试使用Linq实现这一目标.

我试过了 :

    var query = from pt in list1
                from at in list2
                from ct in list3
                select new Item
                           {
                               Value1 = pt,
                               Value2 = at,
                               Value3 = ct
                           };

但我得到了OutOfMemoryException,我的3个列表很大.

有帮助吗？

我正在寻找的是一个基本的操作(我肯定有一个名字,我只是没有意识到atm).我有一个矩阵像:

{1,2,3}

{A,N,F}

{7,8,9}

我想改变它

{1,A,7}

{2,N,8}

{3,F,9}

(以上只是对象的标识符而不是实际值.实际对象属于同一类型且无序)

我更喜欢它的声明性解决方案,但速度是一个因素.我将不得不转动相当多的表(每分钟100k个单元),而慢速版将在关键路径上.

但是我对可读解决方案仍然更感兴趣.我正在寻找下面的替代解决方案.(换句话说,我不是指变化,而是一种不同的方法)

var  arrays = rows.Select(row => row.ToArray());
var cellCount = arrays.First().Length;
for(var i = 0;i<cellCount;i++){
  yield return GetRow(i,arrays);
}

IEnumerable<T> GetRow(int i,IEnumerable<T[]> rows){
  foreach(var row in rows}{
     yield return row[i]; 
  }
}

在两个几乎同样可读的解决方案中,我会更快,但可读性在速度之前

编辑 它将始终是一个方阵

这是来自Charles C Pinter的"摘要代数之书"的练习5.F.2:

我们G是该组{e, a, b, b^2, b^3, ab, ab^2, ab^3},其发电机满足a^2 = e,b^4 = e,ba = ab^3.写下表G.(G称为二面体组D4.)

这是一个小的Perl 6程序,它提供了一个解决方案:

sub generate(%eqs, $s)
{
    my @results = ();

    for %eqs.kv -> $key, $val {
        if $s ~~ /$key/ { @results.push($s.subst(/$key/, $val)); }
        if $s ~~ /$val/ { @results.push($s.subst(/$val/, $key)); }
    }

    for @results -> $result { take $result; }

    my @arrs = @results.map({ gather generate(%eqs, $_) }); …

我正在使用yield return迭代SqlDataReader记录:

IEnumerable<Reading> GetReadings() {
    using (var connection = new SqlConnection(_connectionString))
    {
        using (var command = new SqlCommand(_query, connection))
        {
            connection.Open();
            using (var reader = command.ExecuteReader())
            {
                while (reader.Read())
                {
                    yield return new Reading
                    {
                        End = reader.GetDateTime(0),
                        Value = reader.GetDouble(1)
                    };
                }
            }
            connection.Close();
        }
    }
}

然后我使用这个被接受的答案的改编版本来"拉"许多迭代器:

   var enumerators = data.Select(d => new
   {
       d.Key,
       Enumerator = d.Value.GetEnumerator()
   }).ToList();

   while (true)
   {
       foreach (var item in enumerators)
       {
           if (!item.Enumerator.MoveNext())
           {
               yield …

假设您有一个列表列表,例如'(("abc" "def" "ghi") ("012" "345" "678") ("jkl" "mno" "pqr"))或'(("ab" "cd" "ef") ("01" "23" "45")).

压缩给定列表中列表的规范方法是什么？即如何func定义如此

(func '(("ab" "cd" "ef") ("01" "23" "45")) :sep "|" :combiner #'concat) 
  ;; => ("ab|01" "cd|23" "ef|45")

(func '(("abc" "def" "ghi") ("012" "345" "678") ("jkl" "mno" "pqr")) ...)
  ;; => ("abc|012|jkl" "def|345|mno" "ghi|678|pqr")

哪个concat := (lambda (args) ...)是组合各个列表的头部的功能.

据推测,这种类型的操作被称为旋转或zipMany(根据不同语言的相关问题的答案).

我有类似的东西(双apply)

(apply #'mapcar #'(lambda (&rest args) (apply #'concatenate 'string args)) lst) …

我在一个文件夹中有一堆文本文件，它们都应该有相同的标题。换句话说，所有文件的前 100 行应该是相同的。所以我写了一个函数来检查这个条件：

private static bool CheckHeaders(string folderPath, int headersCount)
{
    var enumerators = Directory.EnumerateFiles(folderPath)
        .Select(f => File.ReadLines(f).GetEnumerator())
        .ToArray();
    //using (enumerators)
    //{
        for (int i = 0; i < headersCount; i++)
        {
            foreach (var e in enumerators)
            {
                if (!e.MoveNext()) return false;
            }
            var values = enumerators.Select(e => e.Current);
            if (values.Distinct().Count() > 1) return false;
        }
        return true;
    //}
}

我使用枚举器的原因是内存效率。我没有在内存中加载所有文件内容，而是逐行同时枚举文件，直到发现不匹配，或者检查了所有标题。

注释的代码行很明显我的问题。我想利用一个using块来安全地处理所有枚举器，但不幸的using (enumerators)是不能编译。显然using只能处理一个一次性物品。我知道我可以通过将整个事物包装在一个try-finally块中并最终在内部循环中运行处理逻辑来手动处理枚举器，但这似乎很尴尬。using在这种情况下，是否有任何机制可以使该语句成为可行的选择？

更新

我刚刚意识到我的函数有一个严重的缺陷。枚举器的构造并不稳健。锁定的文件可能会导致异常，而某些枚举器已被创建。这些枚举器不会被处理。这是我想要解决的问题。我在想这样的事情：

var enumerators = Directory.EnumerateFiles(folderPath)
    .ToDisposables(f …