C# IReadOnlyList.Count方法代码示例

        static IReadOnlyList<IMemberDefinition> CreateNodes(CallInfo callInfo, IReadOnlyList<object> args)
        {
            var result = new List<IMemberDefinition>();

            int difference;
            var nameCount = callInfo.ArgumentNames.Count;
            var argumentCount = args.Count;

            if (argumentCount != nameCount)
            {
                if (nameCount != args.Count(x => !(x is IMemberDefinition)))
                    throw new NotSupportedException("Unnamed arguments must be MemberDefinition instances.");

                difference = argumentCount - nameCount;
            }
            else
            {
                difference = 0;
            }

            var argumentNames = callInfo.ArgumentNames;

            for (var i = argumentCount - 1; i >= 0; i--)
            {
                var argument = args[i];

                var dynamicMember = argument as IMemberDefinition;
                if (dynamicMember == null)
                {
                    var name = argumentNames[i - difference];

                    var @delegate = argument as Delegate;
                    if (@delegate != null)
                    {
                        dynamicMember = MemberDefinition.Method(name, @delegate);
                    }
                    else
                    {
                        var type = argument as Type;

                        if (type == null)
                            throw new NotSupportedException("Definitions require a type.");

                        if (typeof(Delegate).IsAssignableFrom(type))
                        {
                            dynamicMember = MemberDefinition.EmptyMethod(name, type);
                        }
                        else
                        {
                            dynamicMember = MemberDefinition.Property(name, type);
                        }
                    }
                }

                result.Add(dynamicMember);   
            }

            return result;
        }

 private int WorkoutValueOfNames(IReadOnlyList<string> orderedNames)
 {
     var result = 0;
     for (var i = 0; i < orderedNames.Count(); i++)
     {
         result += (i + 1) * GetNameWorth(orderedNames[i]);
     }
     return result;
 }

        /// <summary>
        /// Default Constructor
        /// </summary>
        /// <param name="arguments">Arguments</param>
        public Parameters(IReadOnlyList<string> arguments)
        {
            if (null == arguments)
            {
                throw new ArgumentNullException("arguments");
            }
            if (!arguments.Any() || arguments.Count() > 4)
            {
                throw new ArgumentException("Invalid parameter count.");
            }

            this.arguments = arguments;
        }

 public void SelectMusicFiles(IReadOnlyList<MusicFile> musicFiles)
 {
     // Do not wait for the operation to complete. Continue immediately.
     SaveCurrentSelectedFileAsync().IgnoreResult();
     
     if (musicFiles.Count() <= 1)
     {
         MusicPropertiesViewModel.MusicFile = musicFiles.FirstOrDefault();
     }
     else
     {
         MusicPropertiesViewModel.MusicFile = musicFileContext.CreateFromMultiple(musicFiles);
     }
 }

 /// <summary>
 /// Constructs a template from its textual representation, such as <c>shelves/*/books/**</c>.
 /// </summary>
 /// <param name="template">The textual representation of the template. Must not be null.</param>
 public PathTemplate(string template)
 {
     GaxPreconditions.CheckNotNull(template, nameof(template));
     _segments = template.Split(s_slashSplit).Select(Segment.Parse).ToList();
     _parameterSegments = _segments.Where(s => s.Kind != SegmentKind.Literal).ToList();
     int pathWildcardCount = _segments.Count(s => s.Kind == SegmentKind.PathWildcard);
     if (pathWildcardCount > 1)
     {
         throw new ArgumentException("Template contains multiple path wildcards", nameof(template));
     }
     _hasPathWildcard = pathWildcardCount != 0;
     _originalTemplate = template;
     ParameterNames = _parameterSegments.Select(x => x.Value).ToList().AsReadOnly();
 }

        public async Task<IReadOnlyList<StorageFolder>> loadFolders()
        {
            int count;
            StorageFolder rootFolder = KnownFolders.PicturesLibrary;
            StorageFolder myfolder = await rootFolder.GetFolderAsync("YouMapsImages");
            
            folders = await myfolder.GetFoldersAsync();
             count = folders.Count();
           if(count == 0)
           {
               await myfolder.CreateFolderAsync("default", CreationCollisionOption.FailIfExists);
               await myfolder.GetFoldersAsync();
           }

           return folders;
            
        }

        private IEnumerable<TabPane> GetTabPanes(IReadOnlyList<Product> products)
        {
            var tabPanes = new List<TabPane>();

            for (var i = 0; i <= (products.Count() - 1) / DisplayCount; i++)
            {
                var productItems = new List<ProductItem>();
                for (var j = i * DisplayCount; j < (i + 1) * DisplayCount; j++)
                {
                    if (j < products.Count)
                    {
                        var productItem = new ProductItem()
                        {
                            Id = products[j].Id.ToString(),
                            Name = products[j].Name,
                            Image350x280Path = products[j].Image350x280Path,
                            Image800x640Path = products[j].Image800x640Paths.First(im => im.IsActive).Path,
                            RatingImagePath = products[j].RatingImagePath,
                            OldPrice = products[j].OldPrice.HasValue ? products[j].OldPrice.Value.ToString("C") : string.Empty,
                            NewPrice = products[j].NewPrice.ToString("C"),
                            ExTax = (products[j].NewPrice - products[j].NewPrice * .15m).ToString("C"),
                            Description =
                                products[j].Description.Length > 140
                                    ? string.Format("{0}...", products[j].Description.Substring(0, 140))
                                    : products[j].Description
                        };
                        productItems.Add(productItem);
                    }
                }

                var tabPane = new TabPane
                {
                    Active = i == 0 ? "active" : string.Empty,
                    ProductItems = productItems
                };
                tabPanes.Add(tabPane);
            }
            return tabPanes;
        }

        static IReadOnlyList<Member> CreateValueNodes(CallInfo callInfo, IReadOnlyList<object> args)
        {
            var result = new List<Member>();

            int difference;
            var nameCount = callInfo.ArgumentNames.Count;
            var argumentCount = args.Count;
            if (argumentCount != nameCount)
            {
                if (nameCount != args.Count(x => !(x is Member)))
                    throw new NotSupportedException("Unnamed arguments must be MemberDefinition instances.");

                difference = argumentCount - nameCount;
            }
            else
            {
                difference = 0;
            }

            var argumentNames = callInfo.ArgumentNames;

            for (var i = argumentCount - 1; i >= 0; i--)
            {
                var argument = args[i];

                var dynamicMember = argument as Member;
                if (dynamicMember == null)
                {
                    var name = argumentNames[i - difference];
                    dynamic value = argument;
                    dynamicMember = Member.Unknown(name, value);
                }

                result.Add(dynamicMember);
            }

            return result;
        }

        private IEnumerable<ProductsItem> GetProductsBlocks(IReadOnlyList<Product> products)
        {
            var productsBlocks = new List<ProductsItem>();

            for (var i = 0; i <= (products.Count() - 1) / DisplayCount; i++)
            {
                var productBlocks = new List<ProductBlock>();
                for (var j = i*DisplayCount; j < (i + 1)*DisplayCount; j++)
                {
                    if (j < products.Count)
                    {
                        var productBlock = new ProductBlock
                        {
                            Id = products[j].Id.ToString(),
                            Name = products[j].Name,
                            Image240x192Path = products[j].Image240x192Path,
                            Image800x640Path = products[j].Image800x640Paths.First(im => im.IsActive).Path,
                            RatingImagePath = products[j].RatingImagePath,
                            OldPrice = products[j].OldPrice.HasValue?products[j].OldPrice.Value.ToString("C"):string.Empty,
                            NewPrice = products[j].NewPrice.ToString("C"),
                            ExTax = (products[j].NewPrice - products[j].NewPrice*.15m).ToString("C"),
                            Description =
                                products[j].Description.Length > 140
                                    ? string.Format("{0}...", products[j].Description.Substring(0, 140))
                                    : products[j].Description
                        };
                        productBlocks.Add(productBlock);
                    }
                }
                var productsItem = new ProductsItem
                {
                    ProductBlocks = productBlocks
                };
                productsBlocks.Add(productsItem);
            }
            return productsBlocks;
        }

        private IEnumerable<ImageAdditionalModel> GetImageAdditionalModels(IReadOnlyList<ProductImagePath> image800x640Paths)
        {
            var imageAdditional = new List<ImageAdditionalModel>();
            for (var i = 0; i <= (image800x640Paths.Count() - 1) / DisplayCount; i++)
            {
                var imagePaths = new List<string>();
                for (var j = i * DisplayCount; j < (i + 1) * DisplayCount; j++)
                {
                    if (j < image800x640Paths.Count)
                    {
                        imagePaths.Add(image800x640Paths[j].Path);
                    }
                }
                var imageAdditionalItem = new ImageAdditionalModel
                {
                    Active = i == 0 ? "active" : string.Empty,
                    Paths = imagePaths
                };
                imageAdditional.Add(imageAdditionalItem);
            }

            return imageAdditional;
        }

        private IEnumerable<RelatedProductBlock> GetRelatedProductBlocks(IReadOnlyList<Product> relatedProducts)
        {
            var relatedProductBlocks=new List<RelatedProductBlock>();
            for (var i = 0; i <= (relatedProducts.Count() - 1) / DisplayCount; i++)
            {
                var relatedProductsModel = new List<RelatedProductViewModel>();
                for (var j = i * DisplayCount; j < (i + 1) * DisplayCount; j++)
                {
                    if (j < relatedProducts.Count)
                    {
                        var relatedProduct = new RelatedProductViewModel
                        {
                            Id = relatedProducts[j].Id.ToString(),
                            Name = relatedProducts[j].Name,
                            Image800x640Path = relatedProducts[j].Image800x640Paths.First(im => im.IsActive).Path,
                            RatingImagePath = relatedProducts[j].RatingImagePath,
                            OldPrice = relatedProducts[j].OldPrice.HasValue?relatedProducts[j].OldPrice.Value.ToString("C"):string.Empty,
                            NewPrice = relatedProducts[j].NewPrice.ToString("C")
                        };
                        relatedProductsModel.Add(relatedProduct);
                    }
                }

                var relateProductBlock = new RelatedProductBlock
                {
                    Active = i == 0 ? "active" : string.Empty,
                    RelatedProducts = relatedProductsModel
                };
                relatedProductBlocks.Add(relateProductBlock);
            }
            return relatedProductBlocks;
        }

 private static int FindLineWith(IReadOnlyList<string> lines, string find)
 {
     var line = -1;
     for (var i = 0; i < lines.Count(); i++)
     {
         if (lines[i].Contains(find))
             line = i;
     }
     return line;
 }

        /// <summary>
        ///     Filters a mixable tracks by genre.
        /// </summary>
        /// <param name="mixTracks">The mix tracks.</param>
        /// <param name="cycleTracks">The cycle tracks.</param>
        private static void FilterMixableTracksByGenre(List<Track> mixTracks, IReadOnlyList<Track> cycleTracks)
        {
            if (cycleTracks.Count == 0) return;

            const int genreTracksPerCycle = 16;

            var removeTracks = new List<Track>();
            foreach (var track in mixTracks)
            {
                var genre = GetGenreForClumpingPurposes(track.Genre);
                if (cycleTracks.Count(mt => GetGenreForClumpingPurposes(mt.Genre) == genre) > genreTracksPerCycle)
                    removeTracks.Add(track);

                if (cycleTracks.Count > 1 &&
                    GetGenreForClumpingPurposes(cycleTracks[cycleTracks.Count - 1].Genre) == genre &&
                    GetGenreForClumpingPurposes(cycleTracks[cycleTracks.Count - 2].Genre) == genre)
                {
                    removeTracks.Add(track);
                }
            }
            if (removeTracks.Count <= 0) return;

            if (mixTracks.Count - removeTracks.Count <= 1)
            {
            }
            else
            {
                mixTracks.RemoveAll(t => removeTracks.Exists(rt => rt.Description == t.Description));
            }
        }

        // The assembly info must be in the last minus 1 position because:
        // - assemblyInfo should be in the end to override attributes
        // - assemblyInfo cannot be in the last position, because last file contains the main
        private static IEnumerable<string> GetSourceFiles(IReadOnlyList<string> sourceFiles, string assemblyInfo)
        {
            if (!sourceFiles.Any())
            {
                yield return assemblyInfo;
                yield break;
            }

            foreach (var s in sourceFiles.Take(sourceFiles.Count() - 1))
                yield return s;

            yield return assemblyInfo;

            yield return sourceFiles.Last();
        }

        /// <summary>
        ///     Filters mixable tracks by genre.
        /// </summary>
        /// <param name="mixTracks">The mix tracks.</param>
        /// <param name="cycleTracks">The cycle tracks.</param>
        private static void FilterMixableTracksByArtist(List<Track> mixTracks, IReadOnlyList<Track> cycleTracks)
        {
            if (cycleTracks.Count == 0) return;

            const int artistTracksPerCycle = 8;

            var removeTracks = new List<Track>();
            foreach (var track in mixTracks)
            {
                var artist = GetArtistForClumpingPurposes(track.Artist);
                if (cycleTracks.Count(mt => GetArtistForClumpingPurposes(mt.Artist) == artist) > artistTracksPerCycle)
                    removeTracks.Add(track);

                if (cycleTracks.Count > 1 &&
                    GetArtistForClumpingPurposes(cycleTracks[cycleTracks.Count - 1].Artist) == artist &&
                    GetArtistForClumpingPurposes(cycleTracks[cycleTracks.Count - 2].Artist) == artist)
                {
                    removeTracks.Add(track);
                }
            }

            mixTracks.RemoveAll(t => removeTracks.Exists(rt => rt.Description == t.Description));
        }