public static HashSet <ArabicRomanNumeral> GetArabicRomanNumeralsMapping(int upToArabicNumber = DICTIONARY_PREPOPULATION_SIZE) { if (upToArabicNumber == DICTIONARY_PREPOPULATION_SIZE) { return(new HashSet <ArabicRomanNumeral>(_arabicRomanNumeralsMapping.Take(upToArabicNumber))); } if (upToArabicNumber < DICTIONARY_PREPOPULATION_SIZE) { return ((HashSet <ArabicRomanNumeral>) new HashSet <ArabicRomanNumeral>(_arabicRomanNumeralsMapping).Take(upToArabicNumber)); } if (upToArabicNumber >= DICTIONARY_PREPOPULATION_SIZE) { if (_arabicRomanNumeralsMapping.Count >= upToArabicNumber) { return(new HashSet <ArabicRomanNumeral>(_arabicRomanNumeralsMapping.Take(upToArabicNumber))); } HashSet <ArabicRomanNumeral> largerMapping = GenerateAdditionalMappings(DICTIONARY_PREPOPULATION_SIZE + 1, upToArabicNumber); _arabicRomanNumeralsMapping = (HashSet <ArabicRomanNumeral>)_arabicRomanNumeralsMapping.Union(largerMapping); } return(_arabicRomanNumeralsMapping); }
private void ConnectToPeersLoop() { while (!cancellationTokenSource.IsCancellationRequested) { int connectedCount = connectedPeers.Count; int unconnectedCount = unconnectedPeers.Count; if (connectedCount < ConnectedMax) { Task[] tasks = { }; if (unconnectedCount > 0) { IPEndPoint[] endpoints; lock (unconnectedPeers) { endpoints = unconnectedPeers.Take(ConnectedMax - connectedCount).ToArray(); } tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray(); } else if (connectedCount > 0) { lock (connectedPeers) { foreach (RemotePeer node in connectedPeers) { node.RequestPeers(); } } } else { tasks = Settings.Default.SeedList.OfType <string>().Select(p => p.Split(':')).Select(p => ConnectToPeerAsync(p[0], int.Parse(p[1]))).ToArray(); } try { Task.WaitAll(tasks, cancellationTokenSource.Token); } catch (OperationCanceledException) { break; } } for (int i = 0; i < 50 && !cancellationTokenSource.IsCancellationRequested; i++) { Thread.Sleep(100); } } }
private static bool SearchWordHelper(char[][] board, string word, int row, int col, HashSet <Tuple <int, int> > visitedCells) { bool success = false; if (word.Length == 0) { return(true); } Tuple <int, int> matchingCell; Stack <Tuple <int, int> > matchingAdjcentCells = new Stack <Tuple <int, int> >(); int visitedCellCount = visitedCells.Count; if (GetNextMatchingAdjecentCells(board, row, col, word[0], matchingAdjcentCells, visitedCells)) { while (!success && matchingAdjcentCells.Count > 0) { matchingCell = matchingAdjcentCells.Pop(); visitedCells.Add(matchingCell); success = SearchWordHelper(board, word.Substring(1), matchingCell.Item1, matchingCell.Item2, visitedCells); if (!success) { visitedCells = visitedCells.Take(visitedCellCount).ToHashSet(); } } } return(success); }
private void TryRenderOrientationData() { int dataCount = Math.Min(RenderConfig.MaxParallelTerrainRefreshes, FreeBakerTriplets.Count); var dataToProcess = UnrenderedOrientationData.Take(dataCount).ToArray(); for (int i = 0; i < dataToProcess.Length; i++) { var activeData = dataToProcess[i]; activeData.BakerTriplet = FreeBakerTriplets.Dequeue(); RenderOrientation(activeData.Chunk, activeData.BakerTriplet.Item1); RenderWeights(activeData.Chunk, activeData.BakerTriplet.Item2); RenderDuck(activeData.Chunk, activeData.BakerTriplet.Item3); } for (int i = 0; i < dataToProcess.Length; i++) { var activeData = dataToProcess[i]; activeData.BakerTriplet.Item1.ReadPixels(); activeData.BakerTriplet.Item2.ReadPixels(); activeData.BakerTriplet.Item3.ReadPixels(); UnrenderedOrientationData.Remove(activeData); } }
private async Task <Action[]> MergeActionsAsync(ISourceBlock <Action[]> actionSource, int?take) { var result = new Action[0]; while (await actionSource.OutputAvailableAsync()) { Console.WriteLine($"[{DateTime.Now:T}] OutputAvailableAsync"); var next = await actionSource.ReceiveAsync(); Console.WriteLine($"[{DateTime.Now:T}] Merging next result {next.Length}. Total {result.Length}"); if (next.Length == 0) { continue; } IEnumerable <Action> current = new HashSet <Action>(result.Concat(next)).OrderByDescending(action => action.ActionDateTime); if (take.HasValue) { current = current.Take(take.Value); } result = current.ToArray(); Console.WriteLine($"[{DateTime.Now:T}] Merged with next result {next.Length}. Total {result.Length}"); } return(result); }
public async Task <string[]> Collect(string keyPhrase, int max) { if (max <= 0) { throw new AppException("Invalid 'max' value"); } var collection = await GetCollection(Enumerable.Empty <Guid>(), keyPhrase); if (collection == null) { return(new string[0]); } var searched = new HashSet <Guid>(); var result = new HashSet <string>(); do { searched.Add(collection.Id); var phrases = await GetPhrases(collection); result.UnionWith(phrases); await _dbContext.SaveChangesAsync(); } while (searched.Count < 5 && result.Count < max && (collection = await GetCollection(searched)) != null); return(result.Take(max).ToArray()); }
protected override void DoEndOfFile() { foreach (KeyValuePair <FieldIndex, HashSet <string> > entry in _incorrectDataFormat) { FieldIndex fieldIndex = entry.Key; HashSet <string> incorrectDataFormat = entry.Value; string errorsToShow = string.Join(", ", incorrectDataFormat .Take(NumberOfShownErrors) .Select(s => "'" + s + "'") .ToList() ); string message = string.Format(Messages.ControlDataFormatMessage, errorsToShow); if (incorrectDataFormat.Count > NumberOfShownErrors) { int remainingErrors = incorrectDataFormat.Count - NumberOfShownErrors; message += string.Format(Messages.ControlDataFormatMessageExtension, remainingErrors); } _testResults.Add(new TestResult(ResultType.Error, AddmlLocation.FromFieldIndex(fieldIndex), message)); } _incorrectDataFormat.Clear(); }
public List <Video> GetRelatedVideos([FromRoute] int[] videoIDS, [FromRoute] int limit = 5) { AssociationRuleMatcher <int> classifier = CreateAprioriClassifier(); // Get the videos that appear most with the video who's ID is the given argument videoID int[][] matches = classifier.Decide(videoIDS); List <Video> videos = new List <Video>(); HashSet <int> ids = new HashSet <int>(); // Merge all the video IDs into a single HashSet, this will remove duplicates. foreach (int[] e in matches) { foreach (int f in e) { ids.Add(f); } } // Take only the given amount of videos from the argument 'limit'. ids = ids.Take(limit).ToHashSet(); // Get the full video model for each of the IDs. foreach (int id in ids) { videos.Add(_context.Video.FirstOrDefault(video => video.ID == id)); } return(videos); }
public void ClearOldPages() { if (!_viewedPages.Contains(CurrentPageNumber)) { _viewedPages.Add(CurrentPageNumber); } if (_viewedPages.Count > MAX_PAGE_CACHE) { // First try to remove just the last item _viewedPages.Take(_viewedPages.Count - MAX_PAGE_CACHE) .Where(p => Math.Abs(p - CurrentPageNumber) > MAX_PAGE_CACHE); // Get furthest pages from current List <Tuple <int, int> > pageDistances = new List <Tuple <int, int> >(); foreach (int page in _viewedPages) { pageDistances.Add(new Tuple <int, int>(Math.Abs(page - CurrentPageNumber), page)); } // Take extra pages and clean them foreach (var page in pageDistances.OrderByDescending(d => d.Item1) .Take(pageDistances.Count - MAX_PAGE_CACHE) .Select(d => d.Item2)) { int index = GetIndexFromPageNumber(page); ClearPage(Pages[index]); _viewedPages.Remove(page); } } }
public void Trie_ScaleTest() { var allTypes = new HashSet <string>(); var allAssemblies = AppDomain.CurrentDomain.GetAssemblies(); foreach (var assembly in allAssemblies) { var types = assembly.GetTypes(); foreach (var type in types) { allTypes.Add(type.Name.ToLowerInvariant()); } } var step = allTypes.Count / 5; for (var length = step; length < allTypes.Count; length += step) { Measure.Method(() => { var t = new Trie(allTypes.Take(length)); }) .SampleGroup($"Indexing {length} / {allTypes.Count}") .WarmupCount(1) .MeasurementCount(5) .Run(); } }
public Card drawcard() { Card card = (Card)shuffledCards.Take(1).Single(); shuffledCards.Remove(card); return(card); }
public static IEnumerable <string> GetHives(string message, string hiveTargets) { var hives = new HashSet <string> { "hive" }; if (!string.IsNullOrEmpty(hiveTargets)) { foreach (var item in hiveTargets.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)) { var hiveName = GetHiveName(item, true); if (string.IsNullOrEmpty(hiveName)) { continue; } hives.Add(hiveName); } } if (message.Contains("#")) { foreach (Match item in Regex.Matches(message, @"(?<!\w)#\w+")) { var hiveName = GetHiveName(item.Value, false); if (string.IsNullOrEmpty(hiveName)) { continue; } hives.Add(hiveName); } } return(hives.Take(15)); }
private void DoUpgrade(HashSet <BuildingBlock> all_blocks, int targetGrade, bool increment, BasePlayer player) { var todo = all_blocks.Take(configData.BatchSize).ToArray(); foreach (var building_block in todo) { all_blocks.Remove(building_block); var target_grade = NextBlockGrade(building_block, targetGrade, increment ? 1 : -1); if (!CanUpgrade(building_block, (BuildingGrade.Enum)target_grade)) { continue; } building_block.SetGrade((BuildingGrade.Enum)target_grade); building_block.SetHealthToMax(); building_block.SendNetworkUpdate(BasePlayer.NetworkQueue.Update); building_block.UpdateSkin(); Interface.CallHook("OnStructureUpgrade", building_block, player, (BuildingGrade.Enum)target_grade); } if (all_blocks.Count > 0) { NextTick(() => DoUpgrade(all_blocks, targetGrade, increment, player)); } else { PrintMessage(player, increment ? "FinishedUp" : "FinishedDown"); runningPlayers.Remove(player.userID); } }
public override string ToString() { StringBuilder sb = new StringBuilder(); sb.Append('{'); foreach (T element in _set.Take(50)) { sb.Append(element.ToString()); sb.Append(", "); } if (_set.Count <= 50) { if (sb[sb.Length - 1] == ' ') { sb.Remove(sb.Length - 2, 2); } } else { sb.Append("..."); } sb.Append('}'); return(sb.ToString()); }
public virtual IList <Product> GetCrosssellProductsByShoppingCart(IList <OrganizedShoppingCartItem> cart, int numberOfProducts) { var result = new List <Product>(); if (numberOfProducts == 0) { return(result); } if (cart == null || cart.Count == 0) { return(result); } var cartProductIds = new HashSet <int>(cart.Select(x => x.Item.ProductId)); var csItems = GetCrossSellProductsByProductIds(cartProductIds); var productIdsToLoad = new HashSet <int>(csItems.Select(x => x.ProductId2).Except(cartProductIds)); if (productIdsToLoad.Count > 0) { result.AddRange(GetProductsByIds(productIdsToLoad.Take(numberOfProducts).ToArray())); } return(result); }
public string[] GetVocabulary(ITokenizer tokenizer, IEnumerable <Sms> smses) { var spamSmsmes = smses .Where(x => x.Label == SmsLabel.Spam); var spamWords = spamSmsmes .SelectMany(x => tokenizer.Tokenize(x.Text)).Distinct().ToArray(); var tokenizedSpamSmses = spamSmsmes.Select((x => tokenizer.Tokenize(x.Text))).ToArray(); var topSpamWords = new HashSet <string>(spamWords.OrderByDescending(x => tokenizedSpamSmses.Count(y => y.Contains(x))).Take(30)); var hamSmsmes = smses .Where(x => x.Label == SmsLabel.Ham); var hamWords = hamSmsmes .SelectMany(x => tokenizer.Tokenize(x.Text)).Distinct().ToArray(); var tokenizedHamSmses = hamSmsmes.Select((x => tokenizer.Tokenize(x.Text))).ToArray(); var topHamWords = new HashSet <string> (hamWords.OrderByDescending(x => tokenizedHamSmses.Count(y => y.Contains(x))).Take(30)); var intersection = new HashSet <string>(topHamWords); intersection.IntersectWith(topSpamWords); topHamWords.ExceptWith(intersection); topSpamWords.ExceptWith(intersection); return(topSpamWords.Take(10).Union(topHamWords.Take(10)).ToArray()); }
public IEnumerable <long> TakeFreeSectors(int count) { if (_freeSectors.Count < count) { for (long i = 0; i < _bitmapManager.Length; i++) { if (!_bitmapManager.Get(i)) { _freeSectors.Add(i); if (_freeSectors.Count >= Math.Max(count, 1024 * 4)) { break; } } } } var result = _freeSectors.Take(count).ToArray(); foreach (var sector in result) { _bitmapManager.Set(sector, true); _usingSectorCount++; } _freeSectors.ExceptWith(result); return(result); }
public async Task <CommandResult> CleanAsync(ulong u, int quota, CleanType[] types) { if (quota > 300) { return(new QuiccbanFailResult(_responseService.Get("clean_amount_too_large"))); } types = types ?? new CleanType[] { }; var distinctedTypes = types.Distinct(); var messages = new HashSet <IUserMessage>(); int attemptCount = 0; ulong lastMessageId = 0; grabMessages: int getAmount = quota - messages.Count; var unfilteredMessages = (lastMessageId == 0 ? await Context.Channel.GetMessagesAsync(Context.Message.Id, Direction.Before, getAmount).FlattenAsync() : await Context.Channel.GetMessagesAsync(lastMessageId, Direction.Before, getAmount).FlattenAsync()); lastMessageId = unfilteredMessages.LastOrDefault() == null ? lastMessageId : unfilteredMessages.LastOrDefault().Id; var channelMessages = unfilteredMessages.Where(x => x is IUserMessage && (DateTimeOffset.UtcNow - x.CreatedAt).TotalDays < 14).Cast <IUserMessage>(); if (u != 0) { channelMessages.Where(x => x.Author.Id == u); } _helperService.FilterCleaningCollection(ref channelMessages, types); foreach (var message in channelMessages) { if (!messages.Any(x => x.Id == message.Id)) { messages.Add(message); } else { attemptCount = 5; break; } } if (attemptCount < 5 && messages.Count < quota && channelMessages.Count() != 0) { attemptCount++; goto grabMessages; } if (messages.Count == 0) { return(new QuiccbanFailResult(_responseService.Get("clean_no_messages"))); } await Context.Channel.DeleteMessagesAsync(messages.Take(quota)); return(new QuiccbanSuccessResult(string.Format(_responseService.Get("clean_success"), messages.Take(quota).Count()))); }
/// <summary> /// This method looks for the requestedPackage and downloads it. /// If requested, it also installs the dependencies associated with the requestedPackage /// </summary> /// <param name="requestedPackage"></param> /// <param name="autoInstallDependencis"></param> /// <returns></returns> static async Task PerformPackageActionAsync(NugetPackage requestedPackage, bool autoInstallDependencis, List <NugetPackage> installedPackages, Func <NugetPackage, SourcePackageDependencyInfo, ISettings, SourceCacheContext, List <NugetPackage>, Task> action) { ServicePointManager.Expect100Continue = true; ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; var packageId = requestedPackage.Id; var packageVersion = requestedPackage.VersionRange.MinVersion; var nuGetFramework = NuGetFramework.ParseFolder(requestedPackage.TargetFramework); var settings = Settings.LoadDefaultSettings(root: requestedPackage.RootPath); var providers = Repository.Provider.GetCoreV3(); var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers); var repositories = new List <SourceRepository>(); if (requestedPackage.Source != null) { repositories.Add(Repository.CreateSource(providers, new PackageSource(requestedPackage.Source.ToString()))); } foreach (var depSource in requestedPackage.DependencySources) { repositories.Add(Repository.CreateSource(providers, new PackageSource(depSource.ToString()))); } repositories.AddRange(sourceRepositoryProvider.GetRepositories()); using (var cacheContext = new SourceCacheContext()) { var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default); var dependencyWalkLevel = autoInstallDependencis? -1 : 0; await GetPackageDependencyInfo(dependencyWalkLevel, new PackageIdentity(packageId, packageVersion), nuGetFramework, cacheContext, _logger, repositories, availablePackages, installedPackages); var resolverContext = new PackageResolverContext( DependencyBehavior.Lowest, new[] { packageId }, Enumerable.Empty <string>(), Enumerable.Empty <PackageReference>(), Enumerable.Empty <PackageIdentity>(), availablePackages, repositories.Select(s => s.PackageSource), _logger); IEnumerable <SourcePackageDependencyInfo> packagesToInstall = null; if (autoInstallDependencis) { packagesToInstall = availablePackages; } else { packagesToInstall = availablePackages.Take(1); } foreach (var packageToInstall in packagesToInstall) { await action(requestedPackage, packageToInstall, settings, cacheContext, installedPackages); } } }
public override void Run(string[] args) { var filenames = string.Empty; var options = new OptionSet() { { "f=|files=", "Merges the specified split files.", f => filenames = f } }; options.Parse(args); if (string.IsNullOrWhiteSpace(filenames)) { throw new OptionSetException(options); } var splitFiles = new HashSet<string>(Directory.EnumerateFiles(@".\", filenames)); var workFiles = new List<string>(splitFiles.Take(splitFiles.Count - Take >= Take ? Take : splitFiles.Count)); splitFiles.RemoveWhere(s => workFiles.Contains(s)); int splitId = 0; bool firstRun = true; var createdFiles = new HashSet<string>(); while (workFiles.Count > 1 || firstRun) { int written = 0; var multiQueue = new MultiQueue(workFiles); using (var stream = Utils.FindFirstSplitFile("merge", ref splitId)) { createdFiles.Add(stream.Name); Console.WriteLine("Merging {0} into {1}", string.Join(",", from f in workFiles select Path.GetFileName(f)), Path.GetFileName(stream.Name)); foreach (var item in multiQueue.Merge()) { stream.Write(item.ToGuid().ToByteArray(), 0, 16); if (++written % 1000000 == 0) { Console.WriteLine("Written {0} lines", written); } } } Console.WriteLine("Written {0} lines", written); Console.WriteLine("Excluded {0} duplicates.", multiQueue.Duplicates); if (!firstRun) { workFiles.ForEach(f => File.Delete(f)); } workFiles = new List<string>(splitFiles.Take(splitFiles.Count - Take >= Take ? Take : splitFiles.Count)); splitFiles.RemoveWhere(s => workFiles.Contains(s)); if (workFiles.Count < Take) { splitFiles = createdFiles; createdFiles = new HashSet<string>(); workFiles = new List<string>(splitFiles.Take(Take)); splitFiles.RemoveWhere(s => workFiles.Contains(s)); firstRun = false; } } }
public List <BlobStoreData> GetTopN(int topN) { lock (Cache) { return(CacheKeys.Take(Math.Min(CacheKeys.Count, topN)).Select(k => { return GetBlobByRef(k); }).ToList()); } }
private void ConnectToPeersLoop() { while (disposed == 0) { int connectedCount = connectedPeers.Count; int pendingCount = pendingPeers.Count; int unconnectedCount = unconnectedPeers.Count; int maxConnections = Math.Max(CONNECTED_MAX + CONNECTED_MAX / 5, PENDING_MAX); if (connectedCount < CONNECTED_MAX && pendingCount < PENDING_MAX && (connectedCount + pendingCount) < maxConnections) { Task[] tasks = { }; if (unconnectedCount > 0) { IPEndPoint[] endpoints; lock (unconnectedPeers) { endpoints = unconnectedPeers.Take(maxConnections - (connectedCount + pendingCount)).ToArray(); } tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray(); } else if (connectedCount > 0) { lock (connectedPeers) { foreach (RemoteNode node in connectedPeers) { node.RequestPeers(); } } } else { tasks = Settings.Default.SeedList.OfType <string>().Select(p => p.Split(':')).Select(p => ConnectToPeerAsync(p[0], int.Parse(p[1]))).ToArray(); } Task.WaitAll(tasks); } for (int i = 0; i < 50 && disposed == 0; i++) { Thread.Sleep(100); } } }
private string GetPreview(HashSet <string> identities) { if (identities.Count <= 3) { return(string.Join(", ", identities)); } else { return(string.Join(", ", identities.Take(3)) + "..."); } }
public HashSet <Student> GetStudents() { if (Students != null) { return(Students.Take(Students.Count).ToHashSet()); } else { throw new NullReferenceException(); } }
private void ConnectToPeersLoop() { while (disposed == 0) { int connectedCount = connectedPeers.Count; int unconnectedCount = unconnectedPeers.Count; if (connectedCount < ConnectedMax) { Task[] tasks = { }; if (unconnectedCount > 0) { IPEndPoint[] endpoints; lock (unconnectedPeers) { endpoints = unconnectedPeers.Take(ConnectedMax - connectedCount).ToArray(); } tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray(); } else if (connectedCount > 0) { lock (connectedPeers) { foreach (RemoteNode node in connectedPeers) { node.RequestPeers(); } } } else { tasks = Settings.Default.SeedList.OfType <string>().Select(p => p.Split(':')).Select(p => ConnectToPeerAsync(p[0], int.Parse(p[1]))).ToArray(); } Task.WaitAll(tasks); } for (int i = 0; i < 50 && disposed == 0; i++) { Thread.Sleep(100); } } }
private void ConnectToPeersLoop() { while (disposed == 0) { int connectedCount = connectedPeers.Count; int pendingCount = pendingPeers.Count; int unconnectedCount = unconnectedPeers.Count; int maxConnections = Math.Max(CONNECTED_MAX + CONNECTED_MAX / 5, PENDING_MAX); if (connectedCount < CONNECTED_MAX && pendingCount < PENDING_MAX && (connectedCount + pendingCount) < maxConnections) { Task[] tasks; if (unconnectedCount > 0) { IPEndPoint[] endpoints; lock (unconnectedPeers) { endpoints = unconnectedPeers.Take(maxConnections - (connectedCount + pendingCount)).ToArray(); } tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray(); } else if (connectedCount > 0) { lock (connectedPeers) { tasks = connectedPeers.Values.ToArray().Select(p => Task.Run(new Action(p.RequestPeers))).ToArray(); } } else { tasks = SeedList.Select(p => ConnectToPeerAsync(p)).ToArray(); } Task.WaitAll(tasks); } for (int i = 0; i < 50 && disposed == 0; i++) { Thread.Sleep(100); } } }
private void SavePackagesToSettingsStore() { // only save if there are new package added if (_packagesCache.Count > 0) { // IMPORTANT: call ToList() here. Otherwise, we may read and write to the settings store at the same time var loadedPackagesMetadata = LoadPackageMetadataFromSettingsStore().ToList(); _settingsManager.SavePackageMetadata( _packagesCache. Take(MaximumPackageCount). Concat(loadedPackagesMetadata)); } }
void UpdateLights() { pointLightTargets.Take(MAX_LIGHTS).ForEachWithIndex((pointLight, idx) => { _lightPositions[idx] = pointLight.position; _lightIntensities[idx] = pointLight.intensity; _lightRanges[idx] = pointLight.range; _lightColors[idx] = pointLight.color; }); for (int idx = pointLightTargets.Count; idx < MAX_LIGHTS; idx++) { _lightIntensities[idx] = 0.0f; } }
public static IEnumerable <string> GetMentions(string message) { var mentions = new HashSet <string> { }; if (!string.IsNullOrEmpty(message)) { foreach (Match item in Regex.Matches(message, @"(?<!\w)@\w+")) { mentions.Add(item.Value.TrimStart('@')); } } return(mentions.Take(15)); }
private HashSet <Vector3Int> CalculateZoneCost(HashSet <Vector3Int> newPositionsSet) { resourceManager.AddMoney(structuresOldQuantity * structureData.placementCost); int numberToPlace = resourceManager.HowManyStructuresCanIPlace(structureData.placementCost, newPositionsSet.Count); if (numberToPlace < newPositionsSet.Count) { newPositionsSet = new HashSet <Vector3Int>(newPositionsSet.Take(numberToPlace).ToList()); } structuresOldQuantity = newPositionsSet.Count; resourceManager.SpendMoney(structuresOldQuantity * structureData.placementCost); Debug.Log(structuresOldQuantity); return(newPositionsSet); }
public IEnumerable <object> GetPropertyValues() { yield return(Name); yield return(TimesUsed); yield return(FileSize); yield return(string.Join(", ", UsedInWallsets)); yield return(string.Join(", ", UsedInstancesSamples.Take(3))); foreach (string s in GetPropertyValuesSpecific()) { yield return(s); } }
protected async Task FetchUrlInfos(Status[] ses) { if (ses == null || ses.Length == 0) return; var mem = MemoryCache.Default; var urls = new HashSet<string>(); foreach (var s in ses) { var us = Utils.ExtractUrlFromWeibo(s.text); foreach(var url in us) { if (mem.Get("http://t.cn/" + url) == null) urls.Add(url); } //urls.Add(us); if (s.retweeted_status != null) { var rus = Utils.ExtractUrlFromWeibo(s.retweeted_status.text); foreach (var url in rus) { if (mem.Get("http://t.cn/" + url) == null) urls.Add(url); } } } if(urls.Count >= 20) { var tasks = new Task[2]; var u1 = urls.Take(20); tasks[0] = FetchUrlInfosImp(u1); var u2 = urls.Skip(20); tasks[1] = FetchUrlInfosImp(u2); await Task.WhenAll(tasks); }else { await FetchUrlInfosImp(urls); } }