c# - 聚合IEnumerable中的一系列连续块

过于简化，人为的问题

我有一个可枚举的实例，其中可以包含一系列连续的元素，而其他一些元素则相互分散。一个简单的例子

var items = new[]
            {"1","1","1","1","1","varX","1","1","1","1","varY","1","1"};

如您所见，字符串1被重复，然后不时地还有其他内容（非常容易识别）。可以说，我想以一种可枚举的方式聚合

var aggregated = new[]
          { "11111", "varX", "1111", "varY","11"};

显然，这只是“所有1的级联”，然后是“ var”，接着是下一组1的级联。等等

不要太在意字符串的细节；将“ 1”视为对象Word的实例，将“ var”视为对象Variable的实例。现在，我想将Word的内容连接在一起（以构成一个句子），并以不同的方式处理Variable的内容

我将如何使用LINQ或只是普通的foreach编写该聚合？

略有简化，同一个问题

我有一个“令牌”的清单。只有两种类型的令牌，它们都从基本令牌继承：

public abstract class Token{}
public class WordToken : Token {}
public class VariableToken : Token {}

字符串：


  世界您好{varX}您好{varY}再见


将由我的代码标记为以下枚举

  var tokens = new[]
    {
       WordToken,
       WordToken,
       VariableToken,
       WordToken,
       WordToken,
       WordToken,
       VariableToken,
       WordToken
    };

我想把它变成

var newList = new []
    {
       FragmentToken,
       VariableToken,
       FragmentToken,
       VariableToken,
       FragmentToken
     };

其中FragmentToken是所有单词串联在一起的地方

显而易见的第一步是汇总原始列表以使

var step = new[]
    {
          new[]{WordToken, WordToken},
          new[]{VariableToken},
          new[]{ WordToken, WordToken, WordToken},
          new[]{VariableToken},
          new[]{WordToken}
    };

然后，我可以轻松地进行下一步，但是我无法理解如何进行此第一步。

最佳答案

这是否接近您想要的解决方案？

public abstract class Token : IComparable
{
    public int CompareTo(object obj)
    {
        if (obj == null)
        {
            return -1;
        }
        return GetType().FullName.CompareTo(obj.GetType().FullName);
    }
}
public class WordToken : Token { }
public class VariableToken : Token { }

public static class ListExtensions
{
    public static IEnumerable<IEnumerable<TEntity>> JoinRepeatedValues<TEntity>(this IEnumerable<TEntity> collection)
        where TEntity : IComparable
    {
        var joinedRepeatedValuesCollection = new List<List<TEntity>>();
        var lastValue = default(TEntity);
        foreach (var item in collection)
        {
            if (item.CompareTo(lastValue) != 0)
            {
                joinedRepeatedValuesCollection.Add(new List<TEntity> { item });
            }
            else
            {
                var lastAddedValue = joinedRepeatedValuesCollection.Last();
                lastAddedValue.Add(item);
            }
            lastValue = item;
        }
        return joinedRepeatedValuesCollection;
    }

}
class Program
{
    static void Main(string[] args)
    {
        var tokens = new Token[]
                            {
                                new WordToken(),
                                new WordToken(),
                                new VariableToken(),
                                new WordToken(),
                                new WordToken(),
                                new WordToken(),
                                new VariableToken(),
                                new WordToken()
                            };

        var joinedValues = tokens.JoinRepeatedValues();
        var items = new[] { "1", "1", "1", "1", "1", "varX", "1", "1", "1", "1", "varY", "1", "1" }.JoinRepeatedValues();
    }
}

关于c# - 聚合IEnumerable中的一系列连续块，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/16178641/