C# 循环遍历可观察集合以创建新的可观察集合

大家好，我有一个可观察的集合，我想要的是创建一个新的可观察集合，它将获取原始集合的前6个对象，并跳过下12个对象，但在循环中，因此，只要其中有对象，就执行6跳过12，执行6跳过12

我读过take和skip方法，并使用过它们，但收效甚微。如果我说take 6，它会先取6，然后停止循环，如果我做take 6，skip 12，它甚至不会进入循环，只是跳过它，依此类推。希望你们能帮忙这里有一些代码

 private void UcitajReport()
    {
        _report = new ObservableCollection<ReportClass>();


        foreach (Brojevi b in SviBrojevi.Skip(0).Take(6))


        {


            ReportClass r = new ReportClass();

            r.RpBrId = b.ID;
            r.RpBrBroj = b.Broj;
            r.RpBrKolo = b.Kolo;

            r.RpKlKolo = (from ko in Kola
                        where ko.ID == b.KoloId
                        select ko.Naziv).First();


            r.RpKlGodina = (from ko in Kola
                            where ko.ID == b.KoloId
                            select ko.Godina).First();


            r.RpKlDatum = (from ko in Kola
                           where ko.ID == b.KoloId
                           select ko.Datum).First();


            r.RpBjBoja = (from ko in Kola
                          where ko.ID == b.KoloId
                          select ko.Boja).First();


            r.RpDobIznos = (from d in Dobici
                            where d.Kolo == b.Kolo
                            select d.Iznos).First();


            _report.Add(r);


        }

    }

private void UcitajReport（）
{
_报告=新的ObservableCollection（）；
foreach（SviBrojevi中的Brojevi b.跳过（0）.取（6））
{
ReportClass r=新的ReportClass（）；
r、 RpBrId=b.ID；
r、 RpBrBroj=b.Broj；
r、 RpBrKolo=b.Kolo；
r、 RpKlKolo=（来自科拉的ko）
其中ko.ID==b.KoloId
选择ko.Naziv.First（）；
r、 RpKlGodina=（来自科拉的ko）
其中ko.ID==b.KoloId
选择ko.Godina）.First（）；
r、 RpKlDatum=（来自科拉的ko）
其中ko.ID==b.KoloId
选择ko.Datum）.First（）；
r、 RpBjBoja=（来自科拉的ko）
其中ko.ID==b.KoloId
选择ko.Boja）；
r、 RpDobIznos=（从多比奇中的d开始）
其中d.Kolo==b.Kolo
选择d.Iznos）.First（）；
_报告.添加（r）；
}
}

您的收藏似乎需要分页选项。 您可以使用Util方法来完成这项工作

下面是列表，您可以实现自己的可观察集合

    public static List<T> PaginateWithOffset<T>(List<T> list, int offset, int pageSize)
    {
        List<T> tempList = new List<T>();
        if (offset < 0 || pageSize < 0 || offset >= list.Count || list.Count == 0)
        {
            return list;
        }
        else
        {
            int endPage = offset + pageSize;
            int startPage = offset;
            if ((startPage < list.Count && endPage > list.Count) || (pageSize == 0))
            {
                endPage = list.Count;
            }

            for (int i = startPage; i < endPage; i++)
            {
                tempList.Add(list[i]);
            }

            return tempList;
        }
    }

public static List PaginateWithOffset（List List，int offset，int pageSize）
{
列表模板列表=新建列表（）；
如果（偏移量<0 | |页面大小<0 | |偏移量>=list.Count | | list.Count==0）
{
退货清单；
}
其他的
{
int endPage=偏移量+页面大小；
int起始页=偏移量；
if（（起始页list.Count）| |（页面大小==0））
{
endPage=list.Count；
}
对于（int i=startPage；i

我建议您使用扩展方法，我已经实现了这一点，但它可能会得到改进（例如，检查输入值是否为负值…），但我将留给您：

public static class MyExtentionMethods
{
    public static ObservableCollection<T> TakeSomeIgnoreSome<T>(this ObservableCollection<T> collection, int numberGet, int numberIgnore)
    {
        var col = new ObservableCollection<T>();
        var enumerator = collection.GetEnumerator();
        int counter = 0;
        bool getting = true;
        while(enumerator.MoveNext())
        {
            if (getting)
                col.Add(enumerator.Current);

            counter++;

            if (getting && counter == numberGet || !getting && counter == numberIgnore)
            {
                getting ^= true;
                counter = 0;
            }

        }
        return col;
    }
}

公共静态类MyExtensionMethods
{
公共静态ObservableCollection TakeSomeIgnoreSome（此ObservableCollection集合，int numberTarget，int numberRignore）
{
var col=新的ObservableCollection（）；
var枚举器=collection.GetEnumerator（）；
int计数器=0；
bool-getting=true；
while（枚举数.MoveNext（））
{
如果（得到）
col.Add（枚举器当前）；
计数器++；
if（get&&counter==numbertarget | |！get&&counter==numberIgnore）
{
得到^=真；
计数器=0；
}
}
返回列；
}
}

我可以这样做：

var coll = new ObservableCollection<string>() 
        {
            "test1","test2","test3","test4","test5","test6","test7","test8","test9","test10","test11","tes12t","test13","test14","test15"
        };
        var res = coll.TakeSomeIgnoreSome(3,4); // returns 1,2,3,8,9,10,15

var coll=新的ObservableCollection（）
{
“测试1”、“测试2”、“测试3”、“测试4”、“测试5”、“测试6”、“测试7”、“测试8”、“测试9”、“测试10”、“测试11”、“测试12T”、“测试13”、“测试14”、“测试15”
};
var res=coll.TakeSomeIgnoreSome（3,4）；//返回1,2,3,8,9,10,15

就我个人而言，我只是将foreach迭代器作为一个整数进行跟踪，并在循环中进行一些检查，通过比较迭代器值与“skip”值和“keep”值来确定您是否对当前项感兴趣

类程序
{
静态void Main（字符串[]参数）
{
var populatedList=新列表
{
“一”，“二”，“三”，“四”，“五”，
“六”，“七”，“八”，“九”，“十”
};
var fillThisList=新列表（）；
int-itr=1；
int=3；
int skip=7；
foreach（填充列表中的变量项）
{
如果（itr==跳过）
{
//重置迭代器
itr=1；
继续；
}
如果（itr）这很好，但是您确实应该处理
枚举器
，
IEnumerator
是一个一次性类。或者在
集合
上使用
foreach
而不是显式调用
集合。GetEnumerator（）
，foreach将在完成循环后处理枚举器。
class Program
{
    static void Main(string[] args)
    {
        var populatedList = new List<String>
        {
            "One", "Two", "Three", "Four", "Five",
            "Six", "Seven", "Eight", "Nine", "Ten"
        };

        var fillThisList = new List<String>();

        int itr = 1;
        int keep = 3;
        int skip = 7;
        foreach (var item in populatedList)
        {
            if (itr == skip)
            {
                // reset the iterator
                itr = 1;
                continue;
            }
            if (itr <= keep)
            {
                fillThisList.Add(item);
            }
            itr++;
        }
    }
}