public void Initialize() { order = new Order(); order.OrderEntries = null; order.SentDate = DateTime.Now; order.Id = 10; order.User = null; userAcc = new UserAccount(); userAcc.Id = 5; orders = new List<Order>(); orderManagementDaoMock = _factory.CreateMock<IOrderManagementDao>(); oms.OrderManagementDao = orderManagementDaoMock.MockObject; // NMock.Actions.InvokeAction saveOrder = new NMock.Actions.InvokeAction(new Action(() => orders = new List<Order>(){order})); // orderManagementDaoMock.Expects.Any.MethodWith(x => x.SaveOrUpdate(order)).Will(saveOrder); orderInformationDaoMock = _factory.CreateMock<IOrderInformationsDao>(); ois.OrderInformationDao = orderInformationDaoMock.MockObject; orderInformationDaoMock.Expects.Any.MethodWith<Order>(x => x.GetOrderById(order.Id)).WillReturn(order); orderInformationDaoMock.Expects.Any.MethodWith<Order>(x => x.GetOrderById(-1)).WillReturn(null); // orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetOrdersByUserId(userAcc.Id)).WillReturn(orders.Where(x => x.User.Id == userAcc.Id)); orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetOrdersByUserId(-1)).WillReturn(orders.Where(x => x.User.Id == userAcc.Id)); orderInformationDaoMock.Expects.Any.Method(x => x.GetUndeliveredOrders()).WillReturn(orders.Where(x => x.Status != Order.OrderState.DELIVERED)); orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetUndeliveredByUserId(userAcc.Id)).WillReturn(orders.Where(x => x.Status != Order.OrderState.DELIVERED && x.User.Id == userAcc.Id)); //orderInformationDaoMock.Expects.Any.MethodWith(x => x.GetDeliveredOrdersByUserId(userAcc.Id)).WillReturn(orders.Where(x => x.Status == Order.OrderState.DELIVERED && x.User.Id == userAcc.Id)); }
public ComponentInfo(string id, Type serviceType, Type componentType, IList<IPolicy> policies, bool lifeManagement) { id.ThrowIfNullArgument(nameof(id)); _id = id; _serviceType = serviceType; _componentType = componentType; if (_serviceType == null && _componentType == null) ExceptionHelper.ThrowInfoNotComplete(_id); _lifecycleManagement = lifeManagement; _buildPolicies = new List<IPolicy>(); var preCreation = policies.Where(p => p.Stage == Stages.PreCreation).ToArray(); if (preCreation.Length == 0)//If no policy define for PreCreation, stateless will be default policy _buildPolicies.Add(new StatelessPolicy()); else _buildPolicies.AddRange(preCreation); var creation = policies.Where(p => p.Stage == Stages.Creation).ToArray(); if (creation.Length == 0)//If no policy define for Creation, activator will be default policy _buildPolicies.Add(new ActivatorPolicy()); else _buildPolicies.AddRange(creation); _buildPolicies.AddRange(policies.Where(p => p.Stage == Stages.Initialization || p.Stage == Stages.PostInitialization)); }
public override bool Upgrade(PackageSession session, ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage, IList<PackageLoadingAssetFile> assetFiles) { // Paradox 1.1 projects didn't have their dependency properly updated (they might have been marked as 1.0). // We know they are 1.1 only because there is a .props file. // This check shouldn't be necessary from 1.2. var packagePath = dependentPackage.FullPath; var propsFilePath = UPath.Combine(packagePath.GetParent(), (UFile)(packagePath.GetFileName() + ".props")); if (!File.Exists(propsFilePath) && dependency.Version.MinVersion < new PackageVersion("1.1.0-beta")) { log.Error("Can't upgrade old projects from {0} 1.0 to 1.1", dependency.Name); return false; } // Nothing to do for now, most of the work is already done by individual asset upgraders // We can later add logic here for package-wide upgrades (i.e. GameSettingsAsset) if (dependency.Version.MinVersion < new PackageVersion("1.2.0-beta")) { // UIImageGroups and SpriteGroups asset have been merged into a single SpriteSheet => rename the assets and modify the tag var uiImageGroups = assetFiles.Where(f => f.FilePath.GetFileExtension() == ".pdxuiimage"); var spitesGroups = assetFiles.Where(f => f.FilePath.GetFileExtension() == ".pdxsprite"); RenameAndChangeTag(assetFiles, uiImageGroups, "!UIImageGroup"); RenameAndChangeTag(assetFiles, spitesGroups, "!SpriteGroup"); } return true; }
public ICard HighestCard(IList<ICard> cards) { //TODO use aggregates instead: //ICard highestTrumpCard = // _Cards.Where(a => a.Suit == _Trump).Aggregate(card, // (curMin, x) => // (x.Rank > curMin.Rank ? x : curMin)); var trumpCards = cards.Where(a => a.Suit == _Trump).ToList(); if (trumpCards.Any()) { ICard highestTrumpCard = trumpCards[0]; foreach (var card in trumpCards) { if (card.Rank > highestTrumpCard.Rank) { highestTrumpCard = card; } } return highestTrumpCard; } var firstSuit = cards[0].Suit; return cards.Where(a => a.Suit == firstSuit).Aggregate( (curMin, x) => (x.Rank > curMin.Rank ? x : curMin)); }
/// <summary> /// Deals the specified players. /// </summary> /// <param name="players">The players.</param> /// <param name="cardsOnBoard">The cards on board.</param> public void Deal(IList<IParticipant> players, ICard[] cardsOnBoard) { this.Shuffle(); int toTakeFromDeckIndex = 0; // deal cards to players foreach (IParticipant player in players.Where(p => p.IsInGame)) { this.DealCardsToPlayers(player, ref toTakeFromDeckIndex); } // place cards on board Point boardCardsPosition = GlobalVariables.BoardCardsPlace; int positionCardChangeX = boardCardsPosition.X; for (int i = 0; i < 5; i++) { this.DealCardsOnBoard( cardsOnBoard, i, ref toTakeFromDeckIndex, boardCardsPosition, ref positionCardChangeX); } // turn the player cards up foreach (var player in players.Where(p => p.IsInGame && p is Player)) { player.Hand.CurrentCards[0].IsFacingUp = true; player.Hand.CurrentCards[1].IsFacingUp = true; } }
IEnumerable<ModuleDefMD> SortGraph(IEnumerable<ModuleDefMD> roots, IList<DependencyGraphEdge> edges) { var visited = new HashSet<ModuleDefMD>(); var queue = new Queue<ModuleDefMD>(roots); do { while (queue.Count > 0) { var node = queue.Dequeue(); visited.Add(node); Debug.Assert(!edges.Where(edge => edge.To == node).Any()); yield return node; foreach (DependencyGraphEdge edge in edges.Where(edge => edge.From == node).ToList()) { edges.Remove(edge); if (!edges.Any(e => e.To == edge.To)) queue.Enqueue(edge.To); } } if (edges.Count > 0) { foreach (var edge in edges) { if (!visited.Contains(edge.From)) { queue.Enqueue(edge.From); break; } } } } while (edges.Count > 0); }
public void UpdateInvoiceDetails(IList<InvoiceDetail> invoiceDetails, IList<int> deleteIds) { Process(() => { if (invoiceDetails != null && invoiceDetails.Count > 0) { var ids = invoiceDetails.Select(x => x.Id); var invoicesInDb = invoiceDetailRepository.Query().Where(x => ids.Contains(x.Id)).ToList(); var idsInDb = invoicesInDb.Select(x => x.Id); foreach (var invoice in invoicesInDb) { var item = invoiceDetails.Where(x => x.Id == invoice.Id).First(); invoice.Description = item.Description; invoice.Quantity = item.Quantity; invoice.Price = item.Price; } var invoicesNotInDb = invoiceDetails.Where(x => !idsInDb.Contains(x.Id)); foreach (var invoice in invoicesNotInDb) { invoiceDetailRepository.Insert(invoice); } } if (deleteIds != null && deleteIds.Count > 0) { DeleteInvoiceDetails(deleteIds); } this.unitOfWork.Commit(); }); }
public async Task<IssuesCollectionStatistics> Calculate(IList<JiraIssue> issues) { if(issues == null || issues.Any() == false) return null; return await Task.Factory.StartNew(() => { return new IssuesCollectionStatistics { IssuesCount = issues.Count(), ResolvedIssuesCount = issues.Where(i => i.Resolved.HasValue).Count(), UnresolvedIssuesCount = issues.Where(i => i.Resolved.HasValue == false).Count(), AverageResolutionTimeHours = issues .Where(i => i.Resolved.HasValue) .Select(i => (i.Resolved.Value - i.Created).TotalHours).Average(), MaxResolutionTimeHours = issues .Where(i => i.Resolved.HasValue) .Select(i => (i.Resolved.Value - i.Created).TotalHours).Max(), TotalStorypoints = issues.Sum(i => i.StoryPoints), AverageStorypointsPerTask = issues.Average(i => i.StoryPoints), AverageSubtasksCount = issues.Average(i => i.Subtasks), EpicsInvolved = issues.Select(i => i.EpicLink).Distinct().Count(), DistinctReporters = issues.Select(i => i.Reporter).Distinct().Count() }; }); }
private string FormatDeletePatterns(IList<ITriple> deletePatterns, string updateGraphUri) { var deleteCmds = new StringBuilder(); int propId = 0; if (deletePatterns.Any(p => IsGraphTargeted(p) && IsGrounded(p))) { deleteCmds.AppendLine("DELETE DATA {"); foreach (var patternGroup in deletePatterns.Where(p => IsGraphTargeted(p) && IsGrounded(p)).GroupBy(p=>p.Graph)) { deleteCmds.AppendFormat("GRAPH <{0}> {{", patternGroup.Key); deleteCmds.AppendLine(); foreach (var deletePattern in patternGroup) { AppendTriplePattern(deletePattern, deleteCmds); } deleteCmds.AppendLine("}"); } deleteCmds.AppendLine("};"); } foreach (var deletePattern in deletePatterns.Where(p=>IsGraphTargeted(p) && !IsGrounded(p))) { deleteCmds.AppendFormat("WITH <{0}> DELETE {{ {1} }} WHERE {{ {1} }};", deletePattern.Graph, FormatDeletePattern(deletePattern, ref propId)); } if (deletePatterns.Any(p => !IsGraphTargeted(p) && IsGrounded(p))) { // Delete from default graph deleteCmds.AppendLine("DELETE DATA {"); foreach (var p in deletePatterns.Where(p => !IsGraphTargeted(p) && IsGrounded(p))) { AppendTriplePattern(p, deleteCmds); } // If an update graph is specified delete from that too if (updateGraphUri != null) { deleteCmds.AppendFormat("GRAPH <{0}> {{", updateGraphUri); deleteCmds.AppendLine(); foreach (var p in deletePatterns.Where(p => !IsGraphTargeted(p) && IsGrounded(p))) { AppendTriplePattern(p, deleteCmds); } deleteCmds.AppendLine("}"); } deleteCmds.AppendLine("};"); } foreach (var deletePattern in deletePatterns.Where(p => !IsGraphTargeted(p) && !IsGrounded(p))) { var cmd = String.Format("DELETE {{ {0} }} WHERE {{ {0} }};", FormatDeletePattern(deletePattern, ref propId)); deleteCmds.AppendLine(cmd); if (updateGraphUri != null) { deleteCmds.AppendFormat("WITH <{0}> ", updateGraphUri); deleteCmds.AppendLine(cmd); } } return deleteCmds.ToString(); }
public virtual void PrintReportFooter(StreamWriter streamWriter, IList<AllItem> allItems) { int drCount = allItems.Count(ai => ai.Classification == "Dr"); int crCount = allItems.Count(ai => ai.Classification == "Cr"); decimal drAmount = allItems.Where(ai => ai.Classification == "Dr").Sum(ai => ai.Amount); decimal crAmount = allItems.Where(ai => ai.Classification == "Cr").Sum(ai => ai.Amount); streamWriter.WriteLine(string.Format(this.reportFooterFormat, drCount, drAmount, crCount, crAmount)); }
private IEnumerable<FieldDeclarationSyntax> GetRuleViolations(IList<dynamic> fieldsInfo) { if (fieldsInfo.Any(f => !f.IsCollection)) { return fieldsInfo.Where(f => f.IsCollection).Select(f => f.Syntax as FieldDeclarationSyntax); } if (fieldsInfo.Any(f => f.IsCollection)) { return fieldsInfo.Where(f => f.IsCollection).Skip(1).Select(f => f.Syntax as FieldDeclarationSyntax); } return new List<FieldDeclarationSyntax>(); }
private static AmazonChartModel SetChartModel(DateTime from, DateTime to, IList<KeyValuePair<DateTime, decimal>> items) { var data = new Dictionary<string, decimal>(); var labels = new List<string>(); var ts = to - from; var factor = (ts.Days/7)+1; var oldDate = DateTime.Parse(from.Date.ToString()); var currentDate = oldDate; for (var i = 0; i < 7; i++) { oldDate = currentDate; currentDate = oldDate.AddDays(ts.Days <= 7 ? 1 : factor); labels.Add(oldDate.ToString("dd/MM")); data.Add(oldDate.ToString("dd/MM"), i == 0 ? items.Where(x => x.Key.Date == currentDate.Date).Sum(x => x.Value) : items.Where(x => oldDate.Date <= x.Key && x.Key <= currentDate.Date) .Sum(x => x.Value)); } return new AmazonChartModel { Labels = labels, Data = data }; }
public void AddButtons(IList<CustomMenu> menuList) { var rootMenus = menuList.Where(p => !p.ParentMenuID.HasValue).Select(p => new MenuButton { ID = p.ID, Type = MenuTypeToString((EnumMenuType)p.Type), Name = p.Name, Key = p.Key, Url = p.View_Url }).ToList(); var childrenMenu = menuList.Where(p => p.ParentMenuID.HasValue).GroupBy(p => p.ParentMenuID); foreach (var menuButton in rootMenus) { if (!childrenMenu.Any(p => p.Key == menuButton.ID)) { continue; } var subMenus = childrenMenu.FirstOrDefault(p => p.Key == menuButton.ID); menuButton.SubButton = subMenus.Select(p => new MenuButton { Type = MenuTypeToString((EnumMenuType)p.Type), Name = p.Name, Key = p.Key, Url = p.View_Url }).ToList(); menuButton.Key = string.Empty; menuButton.Type = string.Empty; menuButton.Url = string.Empty; } Button = rootMenus; }
private static bool TryFindMatchingArgument(IList<string> args, string argumentKey, out string arg) { arg = null; //if the key ends with a colon (:) that means it has an associated value, otherwise there should be no additional characters //and the key is the entire argument // IEnumerable<string> matchingArgs; if(argumentKey.EndsWith(":", StringComparison.OrdinalIgnoreCase) ) { matchingArgs = args.Where(a => a.StartsWith(argumentKey, StringComparison.OrdinalIgnoreCase)); } else { matchingArgs = args.Where(a => a.Equals(argumentKey, StringComparison.OrdinalIgnoreCase)); } if (matchingArgs.Count() > 1) { throw new ApplicationException(string.Format("Multiple arguments of name {0} specified", argumentKey)); } else if (matchingArgs.Count() == 1) { arg = matchingArgs.First(); return true; } return false; }
public static int CalculateUnverifiedRank(this Competitor competitor , IList<Match> matches) { return (competitor.Rating + matches.Where(x => x.Loser.ProfileUserId == competitor.ProfileUserId && !x.IsResolved) .Sum(x => x.LoserRatingDelta) + matches.Where(x => x.Winner.ProfileUserId == competitor.ProfileUserId && !x.IsResolved) .Sum(x => x.WinnerRatingDelta)); }
private static void _writeResults( IList<Result> results ) { Console.WriteLine( "************************************************************************" ); Console.WriteLine(); Console.WriteLine( "Singletons" ); Console.WriteLine( "==============================" ); Console.WriteLine( "Fastest registrations --------" ); results .Where( r => r.Mode == "Singleton" ) .OrderBy( r => r.RegisterTime ) .ToList() .ForEach( r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.RegisterTime ) ); Console.WriteLine(); Console.WriteLine( "Fastest resolvers ------------" ); results .Where( r => r.Mode == "Singleton" ) .OrderBy( r => r.ResolveTime ) .ToList() .ForEach( r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.ResolveTime ) ); Console.WriteLine(); Console.WriteLine(); Console.WriteLine( "Transients" ); Console.WriteLine( "==============================" ); Console.WriteLine( "Fastest registrations --------" ); results .Where( r => r.Mode == "Transient" ) .OrderBy( r => r.RegisterTime ) .ToList() .ForEach( r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.RegisterTime ) ); Console.WriteLine(); Console.WriteLine( "Fastest resolvers ------------" ); results .Where( r => r.Mode == "Transient" ) .OrderBy( r => r.ResolveTime ) .ToList() .ForEach( r => Console.WriteLine( " {0," + ( Program.MaxContainerNameLength + 1 ) + "}: {1,11:##0.0000}ms", r.Name, r.ResolveTime ) ); Console.WriteLine(); Console.WriteLine(); }
public QuestionListPage(IList<Question> questionList, string filter, AppEnums.QuestionListFilter filterType ) { InitializeComponent(); switch (filterType) { case AppEnums.QuestionListFilter.UnAnswered: { QuestionList = questionList.Where(x => x.Unanswered).ToList(); StudyPlan = filter; this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode); break; } case AppEnums.QuestionListFilter.AnsweredCorrectly: { QuestionList = questionList.Where(x => x.AnsweredCorrectly != null && x.AnsweredCorrectly.Value).ToList(); StudyPlan = filter; this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode); break; } case AppEnums.QuestionListFilter.AnsweredIncorrectly: { QuestionList = questionList.Where(x => x.AnsweredCorrectly != null && x.AnsweredCorrectly.Value.Equals(false)).ToList(); StudyPlan = filter; this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode); break; } case AppEnums.QuestionListFilter.StudyPlan: { QuestionList = questionList.Where(x => x.StudyPlan.Equals(filter)).ToList(); StudyPlan = filter; this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode); break; } case AppEnums.QuestionListFilter.Favorite: { QuestionList = questionList.Where(x => x.IsFavorite != null && x.IsFavorite.Value).ToList(); StudyPlan = filter; this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode); break; } default: this.BindingContext = AppCache.AssignNumberToQuestion(QuestionList, SessionType.PractiseMode); break; } }
/// <summary> /// Initializes a new instance of <see cref="HookableSagaStore"/> with <paramref name="pipelineHooks"/> safe to enumerate multiple times. /// </summary> /// <param name="sagaStore">The underlying <see cref="IStoreSagas"/> implementation to be decorated.</param> /// <param name="pipelineHooks">The set of zero or more <see cref="PipelineHook"/> implementations used to extend <see cref="IStoreSagas"/> behavior.</param> private HookableSagaStore(IStoreSagas sagaStore, IList<PipelineHook> pipelineHooks) { Verify.NotNull(sagaStore, nameof(sagaStore)); this.sagaStore = sagaStore; this.preGetHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPreGet).ToArray(); this.postGetHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPostGet).Reverse().ToArray(); this.preSaveHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPreSave).ToArray(); this.postSaveHooks = pipelineHooks.Where(pipelineHook => pipelineHook.ImplementsPostSave).Reverse().ToArray(); }
protected virtual IEnumerable<SiteMapNode> GroupNodes(IList<SiteMapNode> nodes) { //get root nodes var rootNodes = nodes.Where(x => x.IsRootNode).ToList(); //populate child nodes for each root node foreach (var node in rootNodes) { var children = nodes.Where(x => x.ParentId == node.Id).ToList(); node.Children = children; } return rootNodes; }
public ResultsViewModel(string query, IList<Match> matches, double elapsedMilliseconds, int nodes) { if (matches == null) throw new ArgumentNullException("matches"); Query = query; Words = matches.Where(m => m.Type == MatchType.Word).Select(m => m.Value).ToList(); Anagrams = matches.Where(m => m.Type == MatchType.Anagram).Select(m => m.Value).ToList(); Near = matches.Where(m => m.Type == MatchType.Near).Select(m => m.Value).ToList(); ElapsedMilliseconds = elapsedMilliseconds; Nodes = nodes; }
private void ObtenerRematesAdicionales(ref IList<co_re_remates> listRemates, co_re_remates remate) { if (remate.id_familia == Constantes.FAMILIA_BIENESMUEBLES || remate.id_familia == Constantes.FAMILIA_BIENESMUEBLES_VENTADIRECTA) { listRemates = listRemates.Where(c => c.id_familia == Constantes.FAMILIA_BIENESMUEBLES || c.id_familia == Constantes.FAMILIA_BIENESMUEBLES_VENTADIRECTA).ToList(); } else if (remate.id_familia == Constantes.FAMILIA_PROPIEDADES || remate.id_familia == Constantes.FAMILIA_PROPIEDADES_VENTADIRECTA) { listRemates = listRemates.Where(c => c.id_familia == Constantes.FAMILIA_PROPIEDADES || c.id_familia == Constantes.FAMILIA_PROPIEDADES_VENTADIRECTA).ToList(); } }
public static Statistics GetStatistics(IList<PlayTime> playTimes, IList<Program> programs, TimePeriod timePeriod) { var helper = new DateTimeHelper(); List<PlayTime> times; switch (timePeriod) { case TimePeriod.Day: times = playTimes.Where(x => helper.IsToday(x.Timestamp)).ToList(); break; case TimePeriod.Week: times = playTimes.Where(x => helper.IsCurrentWeek(x.Timestamp)).ToList(); break; case TimePeriod.Month: times = playTimes.Where(x => helper.IsCurrentMonth(x.Timestamp)).ToList(); break; case TimePeriod.Year: times = playTimes.Where(x => helper.IsCurrentYear(x.Timestamp)).ToList(); break; case TimePeriod.Ever: times = playTimes.ToList(); break; default: throw new ArgumentOutOfRangeException(nameof(timePeriod), timePeriod, null); } var statistic = new Statistics { TimePeriod = timePeriod, TimePlayed = TimeSpan.FromMilliseconds(times.Select(x => x.Duration.TotalMilliseconds).Sum()) }; var games = new List<GameStatistic>(); foreach (var gameId in times.Select(x => x.Program).Distinct()) { var game = programs.FirstOrDefault(x => x.Guid == gameId); if (game == null) continue; games.Add(new GameStatistic { Name = game.Name, Icon = game.Icon, Guid = game.Guid, ChartColor = GetColor(game), TimePlayed = TimeSpan.FromMilliseconds( times.Where(x => x.Program == game.Guid).Select(x => x.Duration.TotalMilliseconds).Sum()) }); } statistic.Games = games.OrderByDescending(x => x.TimePlayed).ToList(); return statistic; }
public DiagnosticsListMessage(IList<DiagnosticMessageView> diagnostics, FrameworkData frameworkData) { if (diagnostics == null) { throw new ArgumentNullException(nameof(diagnostics)); } Diagnostics = diagnostics; Errors = diagnostics.Where(msg => msg.Severity == DiagnosticMessageSeverity.Error).ToList(); Warnings = diagnostics.Where(msg => msg.Severity == DiagnosticMessageSeverity.Warning).ToList(); Framework = frameworkData; }
public static void RegisterDisplayModes(IList<IDisplayMode> displayModes) { // The default mode var defaultMode = displayModes.Where(c => c.DisplayModeId == "").FirstOrDefault(); // The mobile view var mobileMode = displayModes.Where(c => c.DisplayModeId == "Mobile").FirstOrDefault(); displayModes.Clear(); displayModes.Add(mobileMode); displayModes.Add(defaultMode); }
public Span TokensToSpan(IList<Token> tokens, Options options) { var handlersToMatch = _registry .GetHandlers(HandlerType.Endian) .Concat(_registry.GetHandlers(HandlerType.Date)); foreach (var handler in handlersToMatch) { if (handler.Match(tokens, _registry)) { var targetTokens = tokens .Where(x => x.IsNotTaggedAs<Separator>()) .ToList(); return ExecuteHandler(handler, targetTokens, options); } } foreach (var handler in _registry.GetHandlers(HandlerType.Anchor)) { if (handler.Match(tokens, _registry)) { var targetTokens = tokens .Where(x => x.IsNotTaggedAs<Separator>()) .ToList(); return ExecuteHandler(handler, targetTokens, options); } } foreach (var handler in _registry.GetHandlers(HandlerType.Arrow)) { if (handler.Match(tokens, _registry)) { var targetTokens = tokens .Where(x => x.IsNotTaggedAs<SeparatorAt>() && x.IsNotTaggedAs<SeparatorComma>() && x.IsNotTaggedAs<SeparatorDate>()) .ToList(); return ExecuteHandler(handler, targetTokens, options); } } foreach (var handler in _registry.GetHandlers(HandlerType.Narrow)) { if (handler.Match(tokens, _registry)) { return ExecuteHandler(handler, tokens, options); } } return null; }
private IList<Resource> GetResourceTree(IList<Resource> list,Guid fcode) { var ss=list.Where(r=>r.F_ResourceID.Equals(fcode)); foreach(Resource re in ss) { if(list.Count(r=>r.F_ResourceID.Equals(re.ResourceID))>0) { re.children=GetResourceTree(list.Where(r=>r.F_ResourceID.Equals(re.ResourceID)).ToList() ,re.ResourceID); } } return ss.ToList(); }
public void Update(IList<ICreature> creatures, IList<Tuple<ObjectType, IList<double>>> objects, MineSweeperSettings settings) { Image = new Bitmap(Width, Height); using (var graphics = Graphics.FromImage(Image)) { var eliteSweeperPen = new Pen(_bestColor); var sweeperPen = new Pen(_neutralColor); var minePen = new Pen(Color.DarkGray); var blackPen = new Pen(Color.Black); var redPen = new Pen(Color.Maroon); // Elite Sweepers foreach (var sweeper in creatures.OrderByDescending(x => x.Fitness).Take(settings.EliteCount)) { drawSweeper(graphics, eliteSweeperPen, eliteSweeperPen.Brush, sweeper, settings.SweeperSize); } // Normal Sweepers foreach (var sweeper in creatures.OrderByDescending(x => x.Fitness).Skip(settings.EliteCount)) { drawSweeper(graphics, sweeperPen, sweeperPen.Brush, sweeper, settings.SweeperSize); } // Mines var mines = objects.Where(x => x.Item1 == ObjectType.Mine).Select(x => x.Item2); foreach (var mine in mines) { drawMine(graphics, redPen, minePen.Brush, mine, settings.MineSize); } // ClusterMines var clusterMines = objects.Where(x => x.Item1 == ObjectType.ClusterMine).Select(x => x.Item2); foreach (var mine in clusterMines) { drawMine(graphics, blackPen, sweeperPen.Brush, mine, settings.MineSize + 1); } // Holes var holes = objects.Where(x => x.Item1 == ObjectType.Hole).Select(x => x.Item2); foreach (var hole in holes) { drawMine(graphics, redPen, redPen.Brush, hole, settings.MineSize + 1); } eliteSweeperPen.Dispose(); sweeperPen.Dispose(); minePen.Dispose(); blackPen.Dispose(); redPen.Dispose(); } }
public IList<Resource> BuidTree(IList<Resource> list, string ReFcode) { var ss = list.Where(r => r.F_ResourceID.Equals(Guid.Parse(ReFcode))); foreach (Resource resource in ss) { if (list.Count(r => r.F_ResourceID.Equals(resource.ResourceID)) > 0) { resource.children = new List<Resource>(); resource.children = BuidTree(list.Where(r => r.F_ResourceID.Equals(resource.ResourceID)).ToList(), resource.ResourceID.ToString()); } } return ss.ToList(); }
public TestAssembly(string assemblyName, IList<IFilter> filters) { Name = assemblyName; _filters = filters; _testAssembly = Assembly.UnsafeLoadFrom(assemblyName); Classes = ( from type in _testAssembly.GetTypes() where type.GetCustomAttributes(typeof(TestClassAttribute), true).Any() where !type.IsAbstract select new TestClass(type, _filters)).ToList(); _initializeClasses = Classes.Where(testClass => testClass.HasAssemblyInitialize).ToList(); _cleanupClasses = Classes.Where(testClass => testClass.HasAssemblyCleanup).ToList(); }
/// <summary> /// Converts the specified input classes into the output classes. /// </summary> /// <param name="inputClasses">The input classes.</param> /// <returns>The output classes</returns> public static IEnumerable<OutputClass> Convert(IList<InputClass> inputClasses) { var axList = inputClasses.Where(x => x.Ax == true).ToList(); var ayList = inputClasses.Where(x => x.Ay == true).ToList(); var bxList = inputClasses.Where(x => x.Bx == true).ToList(); var byList = inputClasses.Where(x => x.By == true).ToList(); var groupA = Join(axList, ayList, "A"); var groupB = Join(bxList, byList, "B"); var outputList = groupA.Concat(groupB); return outputList; }