public static async Task <bool> RemoveServerAsync(string forumUrl) { forumUrl = resolveFullPath(forumUrl); if (!subs.Contains(forumUrl)) { return(false); } string value = cfg.AppSettings.Settings[CFG_PREFIX].Value; List <string> forums = new List <string>(value.Split(CFG_SEPARATOR, StringSplitOptions.RemoveEmptyEntries)); // Remove from local list if (forums.Contains(forumUrl)) { forums.Remove(forumUrl); } // Remove from subs list subs = new ConcurrentBag <string>(subs.Except(new string[] { forumUrl })); WowCircleForum forumObj = null; if (snapshot.ContainsKey(forumUrl)) { snapshot.Remove(forumUrl, out forumObj); } await RefreshCfgAsync(forums); return(true); }
private void OnParticipantMessageReceived(Participant participant, string message) { var data = new { Name = participant.Name, Body = message }; foreach (var otherParticipant in participants.Except(new[] { participant })) { otherParticipant.SendMessage(data); } }
private void Events_AskForStockSubscriptionEvent(string tradingSymbol, StockSubscribeMode mode, bool isSubscribe) { switch (mode) { case StockSubscribeMode.LTP: if (isSubscribe) { if (!_configuredStocksForLTP.Any(s => s.Equals(tradingSymbol))) { _configuredStocksForLTP.Add(tradingSymbol); } } else { var stock = _configuredStocksForLTP.FirstOrDefault(s => s.Equals(tradingSymbol)); if (stock != null) { _configuredStocksForLTP = new ConcurrentBag <string>(_configuredStocksForLTP.Except(new[] { tradingSymbol })); if (_cachedStockLtp.ContainsKey(tradingSymbol)) { _cachedStockLtp.Remove(tradingSymbol); } } } break; } StartStopLTP(_configuredStocksForLTP.Any()); }
public Glass TakeGlassFromBarTop() { Glass glass = barTop.ElementAt(0); barTop = new ConcurrentBag <Glass>(barTop.Except(new[] { glass })); return(glass); }
public void RemoveConnectionFromMatch(string connectionId, SimplerMatchHub hub) { foreach (var match in Matches.ToList()) { if (match.ConnectionIds.Contains(connectionId)) { var thePlayer = match.Players.FirstOrDefault(p => p.ConnectionId == connectionId); if (thePlayer != null) { System.Console.WriteLine($"Client Disconnected: {hub.Context.ConnectionId}"); hub.GetOtherMatchConnections(match).SendAsync("ShipQuitTheGame", thePlayer.Id); match.Players.Remove(thePlayer); } match.ConnectionIds = new ConcurrentBag <string>(match.ConnectionIds.Except(new[] { connectionId })); } if (!match.ConnectionIds.Any()) { System.Console.WriteLine("Will remove match"); Matches = new ConcurrentBag <SimplerMatchState>(Matches.Except(new[] { match })); } } }
/// <summary> /// Overrides the controlled instance /// </summary> /// <typeparam name="T">Old controlled instance</typeparam> /// <typeparam name="T2">Overriding instance</typeparam> protected void OverrideControlledInstance <T, T2>() where T : AbstractedSubController where T2 : new() { var oldController = _abstractedSubControllers.FirstOrDefault(x => x is T); if (typeof(T2) == typeof(T) || oldController == null) { // nothing to override return; } var instance = new T2(); var controller = instance as AbstractedSubController; if (controller == null) { return; } controller.Character = Character; oldController.OnOverwritten(); _abstractedSubControllers = new ConcurrentBag <AbstractedSubController>(_abstractedSubControllers.Except(new[] { oldController })) { controller }; controller.OnAdded(); }
private void TrimExcess() { List <WeakReference <T> > toRemove = new List <WeakReference <T> >(); foreach (int i in hashTable.Keys) { ConcurrentBag <WeakReference <T> > bucket = hashTable[i]; foreach (WeakReference <T> item in bucket) { if (!item.TryGetTarget(out T output)) { toRemove.Add(item); } } // Remove the identified items if (toRemove.Count == bucket.Count) { hashTable.TryRemove(i, out bucket); } else { hashTable.TryUpdate(i, new ConcurrentBag <WeakReference <T> >(bucket.Except(toRemove)), bucket); } Interlocked.Add(ref ExcessCountdown, toRemove.Count()); toRemove.Clear(); } }
public List <Glass> RemoveGlasses() { int glassesToRemove = glassesOnTable.Count; List <Glass> glassesToReturn = new List <Glass>(); glassesToReturn.AddRange(glassesOnTable.Take <Glass>(glassesToRemove).ToList()); glassesOnTable = new ConcurrentBag <Glass>(glassesOnTable.Except(glassesToReturn)); return(glassesToReturn); }
/// <summary> /// Handles a connection closure. /// </summary> /// <param name="closeReason">The reason for the <see cref="Connection"/> being closed.</param> /// <param name="connection">The <see cref="Connection"/> that closed.</param> private void connectionClosed(CloseReason closeReason, Connection connection) { if (connection.GetType().Equals(typeof(TcpConnection))) { List <UdpConnection> udpConnections = new List <UdpConnection>(); TcpConnection tcpConnection = (TcpConnection)connection; while (!connections.TryRemove(tcpConnection, out udpConnections)) { Thread.Sleep(new Random().Next(0, 8)); //If we could not remove the tcpConnection, try it again. } udpConnections.ForEach(u => u.ExternalClose(closeReason)); // cleanup the event handler for the TCP connection. connection.ConnectionEstablished -= udpConnectionReceived; } else if (connection.GetType().Equals(typeof(UdpConnection))) { TcpConnection tcpConnection = this[(UdpConnection)connection]; //UDP connection already removed because the TCP connection is already dead. if (tcpConnection == null) { return; } connections[tcpConnection].Remove((UdpConnection)connection); } #if NET46 else if (connection.GetType().Equals(typeof(BluetoothConnection))) { //Remove the bluetooth connection from the bag. bluetoothConnections = new ConcurrentBag <BluetoothConnection>(bluetoothConnections.Except(new[] { (BluetoothConnection)connection })); } #endif if (connectionLost != null && connectionLost.GetInvocationList().Length > 0 && connection.GetType().Equals(typeof(TcpConnection))) { connectionLost(connection, ConnectionType.TCP, closeReason); } else if (connectionLost != null && connectionLost.GetInvocationList().Length > 0 && connection.GetType().Equals(typeof(UdpConnection))) { connectionLost(connection, ConnectionType.UDP, closeReason); } #if NET46 else if (connectionLost != null && connection.GetType().Equals(typeof(BluetoothConnection))) { connectionLost(connection, ConnectionType.Bluetooth, closeReason); } #endif // remove the connection lost event handler to enable GC. connection.NetworkConnectionClosed -= connectionClosed; }
public void ThenAllMessagesAreAccountedFor() { WaitUtility.WaitUntil("Not all messages received by the server in the given time.", () => Assert.AreEqual(0, expectedToServer.Except(messagesToServer).Count()), TimeSpan.FromMinutes(1)); WaitUtility.WaitUntil("Not all messages received by the clients in the given time.", () => Assert.AreEqual(0, expectedToClients.Except(messagesToClients).Count()), TimeSpan.FromMinutes(1)); Assert.AreEqual(0, messagesToServer.Except(expectedToServer).Count(), "Additional, unexpected messages received by the server."); Assert.AreEqual(0, messagesToClients.Except(expectedToClients).Count(), "Additional, unexpected messages received by the clients."); }
internal void HandleResponse(string serialized, T service, DisterService <T> disterService, string id) { var o = disterService.Serializer.Deserialize(serialized, responseType); var arr = waitingChunks.ToArray(); if (arr.Any(x => x.Key == id)) { var currentChunk = arr.First(x => x.Key == id); waitingChunks = new ConcurrentBag <KeyValuePair <string, object> >(waitingChunks.Except(new[] { currentChunk })); responseHandler(o, service); } }
void OnPositionUpdate() { try { var positions = Client.GetPositions(ProductCode).GetResult(); positions.Except(_positions).ForEach(e => PositionChanged?.Invoke(e, true)); // Notify opened positions _positions.Except(positions).ForEach(e => PositionChanged?.Invoke(e, false)); // Notify closed positions Interlocked.Exchange(ref _positions, new ConcurrentBag <BfPosition>(positions)); } catch (Exception ex) { DebugEx.Trace(ex.Message); } }
public bool RemoveMap(IMap map) { if (map == null || !_maps.Contains(map)) { return(false); } _maps = new ConcurrentBag <IMap>(_maps.Except(new[] { map })); if (MapDeleted != null) { MapDeleted(map); } return(true); }
private void RemovePeer(PeerConnector peerConnector, IpAddress ipAdr) { if (peerConnector == null) { throw new ArgumentNullException(nameof(peerConnector)); } if (ipAdr == null) { throw new ArgumentNullException(nameof(ipAdr)); } _peers = new ConcurrentBag <PeerConnector>(_peers.Except(new[] { peerConnector })); _peersRepository.RemovePeer(ipAdr); peerConnector.Dispose(); }
/// <summary> /// TCPs the or UDP connection closed. /// </summary> /// <param name="closeReason">The close reason.</param> /// <param name="connection">The connection.</param> private void connectionClosed(CloseReason closeReason, Connection connection) { if (connection.GetType().Equals(typeof(TcpConnection))) { List <UdpConnection> udpConnections = new List <UdpConnection>(); TcpConnection tcpConnection = (TcpConnection)connection; while (!connections.TryRemove(tcpConnection, out udpConnections)) { Thread.Sleep(new Random().Next(0, 8)); //If we could not remove the tcpConnection, try it again. } udpConnections.ForEach(u => u.ExternalClose(closeReason)); } else if (connection.GetType().Equals(typeof(UdpConnection))) { TcpConnection tcpConnection = this[(UdpConnection)connection]; if (tcpConnection == null) { return; //UDP connection already removed } //because the TCP connection is already dead. connections[tcpConnection].Remove((UdpConnection)connection); } else if (connection.GetType().Equals(typeof(BluetoothConnection))) { //Remove the bluetooth connection from the bag. bluetoothConnections = new ConcurrentBag <BluetoothConnection>(bluetoothConnections.Except(new[] { (BluetoothConnection)connection })); } if (connectionLost != null && connectionLost.GetInvocationList().Length > 0 && connection.GetType().Equals(typeof(TcpConnection))) { connectionLost(connection, ConnectionType.TCP, closeReason); } else if (connectionLost != null && connectionLost.GetInvocationList().Length > 0 && connection.GetType().Equals(typeof(UdpConnection))) { connectionLost(connection, ConnectionType.UDP, closeReason); } else if (connectionLost != null && connection.GetType().Equals(typeof(BluetoothConnection))) { connectionLost(connection, ConnectionType.Bluetooth, closeReason); } }
public Task UpdateUser(UserViewModel viewModel) { var user = _users.FirstOrDefault(u => u.Email.Equals(viewModel.Email)); if (user == null) { _users.Add(viewModel); } else { _users = new ConcurrentBag <UserViewModel>(_users.Except(new[] { viewModel })) { viewModel } }; return(Task.CompletedTask); } }
public override async Task OnConnectedAsync() { var connectionID = Context.ConnectionId; await base.OnConnectedAsync(); string assignedAnimal; lock (_connectionIdsAndAssignedAnimal) { assignedAnimal = _animals.Except(_connectionIdsAndAssignedAnimal.Select(connections => connections.Value)).OrderBy(x => Guid.NewGuid()).First(); _connectionIdsAndAssignedAnimal.Add(connectionID, assignedAnimal); } await Clients.Caller.SendAsync("animalAssigned", assignedAnimal); await Clients.Others.SendAsync("newAnimalInTheFlock", assignedAnimal); await Clients.Caller.SendAsync("updatedAnimalList", _connectionIdsAndAssignedAnimal.Select(c => c.Value)); }
private ConcurrentBag <T> Remove <T>(ConcurrentBag <T> chatters, T disconnectedChatUser) { return(chatters = new ConcurrentBag <T>(chatters?.Except(new[] { disconnectedChatUser }))); }
private void Remove <T>(ConcurrentBag <T> players, T playerWithoutGame) { players = new ConcurrentBag <T>(players?.Except(new[] { playerWithoutGame })); }
public static ConcurrentBag <T> Without <T>(this ConcurrentBag <T> bag, T item) { return(new ConcurrentBag <T>(bag.Except(new[] { item }))); }
private ConcurrentBag <T> Remove <T>(ConcurrentBag <T> players, T playerWithoutGame) { return(new ConcurrentBag <T>(players?.Except(new[] { playerWithoutGame }))); }
public override ActionTaskResult Process(ActionContext context) { int bundleSize = GetBundleSize(); int maxDegreeOfParallelism = GetMaxDegreeOfParallelism(); string[] channels = context.Parameters.GetChannels(); bool localize = context.Parameters.GetLocalize(); int marketingProductContentId = int.Parse(_settingsService.GetSetting(SettingsTitles.MARKETING_PRODUCT_CONTENT_ID)); string productsFieldName = _settingsService.GetSetting(SettingsTitles.MARKETING_PRODUCT_PRODUCTS_FIELD_NAME); Dictionary <int, int[]> articleIdsToCheckRelationsByContentId; int[] productIds; if (context.ContentItemIds == null || context.ContentItemIds.Length == 0) { productIds = DoWithLogging( () => Helpers.GetAllProductIds(int.Parse(context.Parameters["site_id"]), context.ContentId, _provider.GetCustomer()), "Getting all products from content {contentId}", context.ContentId ); articleIdsToCheckRelationsByContentId = new Dictionary <int, int[]> { { context.ContentId, productIds } }; } else { productIds = DoWithLogging( () => Helpers.ExtractRegionalProductIdsFromMarketing(context.ContentItemIds, _articleService, marketingProductContentId, productsFieldName), "Getting regional product ids from marketing products content {contentId} using field {fieldName} and ids {ids}", marketingProductContentId, productsFieldName, context.ContentItemIds ); articleIdsToCheckRelationsByContentId = Helpers.GetContentIds(productIds, _provider.GetCustomer()); } if (productIds.Length == 0) { return(ActionTaskResult.Error(new ActionTaskResultMessage() { ResourceClass = nameof(SendProductActionStrings), ResourceName = nameof(SendProductActionStrings.NotFound), Extra = string.Join(", ", context.ContentItemIds) }, context.ContentItemIds)); } foreach (var articleIdsWithContentId in articleIdsToCheckRelationsByContentId) { var checkResult = DoWithLogging( () => _articleService.CheckRelationSecurity(articleIdsWithContentId.Key, articleIdsWithContentId.Value, false), "Checking relation security in content {contentId} for articles {ids}", articleIdsWithContentId.Key, articleIdsWithContentId.Value ); string idsstr = string.Join(", ", checkResult.Where(n => !n.Value)); if (!string.IsNullOrEmpty(idsstr)) { return(ActionTaskResult.Error(new ActionTaskResultMessage() { ResourceClass = nameof(SendProductActionStrings), ResourceName = nameof(SendProductActionStrings.NoRelationAccess), Extra = idsstr }, context.ContentItemIds)); } } const string skipPublishingKey = "skipPublishing"; bool skipPublishing = context.Parameters.ContainsKey(skipPublishingKey) && bool.Parse(context.Parameters[skipPublishingKey]); const string skipLiveKey = "skipLive"; bool skipLive = context.Parameters.ContainsKey(skipLiveKey) && bool.Parse(context.Parameters[skipLiveKey]); const string ignoredStatusKey = "IgnoredStatus"; string ignoredStatus = (context.Parameters.ContainsKey(ignoredStatusKey)) ? context.Parameters[ignoredStatusKey] : null; float currentPercent = 0; object percentLocker = new object(); var parts = productIds.Section(bundleSize).ToArray(); var filteredInStage = new ConcurrentBag <int>(); var filteredInLive = new ConcurrentBag <int>(); var failed = new ConcurrentDictionary <int, object>(); var missing = new ConcurrentBag <int>(); var excluded = new ConcurrentBag <int>(); var frozen = new ConcurrentBag <int>(); var invisibleOrArchivedIds = new ConcurrentBag <int>(); var errors = new ConcurrentBag <Exception>(); var validationErrors = new ConcurrentDictionary <int, ActionTaskResult>(); var validationErrorsSerialized = new ConcurrentDictionary <int, string>(); Parallel.ForEach(parts, new ParallelOptions { MaxDegreeOfParallelism = maxDegreeOfParallelism }, () => { HttpContextUserProvider.ForcedUserId = context.UserId; return(new Local { ProductService = ObjectFactoryBase.Resolve <IProductService>(), QpNotificationService = ObjectFactoryBase.Resolve <IQPNotificationService>(), XmlProductService = ObjectFactoryBase.Resolve <IXmlProductService>() }); }, (idsToProcess, ps, tl) => { try { if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(tl); } var localInvisibleOrArchivedIds = new HashSet <int>(); Article[] prodsStage = DoWithLogging( () => tl.ProductService.GetProductsByIds(idsToProcess.ToArray()), "Getting products {ids}", idsToProcess.ToArray() ); IEnumerable <string> ignoredStatuses = ignoredStatus?.Split(',') ?? Enumerable.Empty <string>().ToArray(); var excludedStage = prodsStage.Where(n => ignoredStatuses.Contains(n.Status)).ToArray(); foreach (var item in excludedStage) { excluded.Add(item.Id); } prodsStage = prodsStage.Except(excludedStage).ToArray(); var frozenIds = new int[0]; if (!skipLive) { var idsToCheck = prodsStage.Select(p => p.Id).ToArray(); frozenIds = DoWithLogging( () => _freezeService.GetFrozenProductIds(idsToCheck), "Getting freezing state for products {ids}", idsToCheck ); } prodsStage = prodsStage.Where(p => !frozenIds.Contains(p.Id)).ToArray(); foreach (int id in frozenIds) { frozen.Add(id); } if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(tl); } //Валидация продуктов foreach (int id in prodsStage.Where(w => !w.Archived && w.Visible).Select(s => s.Id)) { var xamlValidationErrors = DoWithLogging( () => _articleService.XamlValidationById(id, true), "Validating XAML for product {id}", id ); var validationResult = ActionTaskResult.FromRulesException(xamlValidationErrors, id); if (!validationResult.IsSuccess) { validationErrors.TryAdd(id, validationResult); validationErrorsSerialized.TryAdd(id, validationResult.ToString()); } } prodsStage = prodsStage.Where(w => !validationErrors.Keys.Contains(w.Id)).ToArray(); var prodsLive = new Article[] { }; if (!skipLive) { if (!skipPublishing) { prodsLive = prodsStage; } else { prodsLive = DoWithLogging( () => tl.ProductService.GetProductsByIds(idsToProcess.ToArray(), true), "Getting separate live products {ids}", idsToProcess.ToArray() ); } } if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(tl); } lock (percentLocker) { currentPercent += (float)50 / parts.Length; } TaskContext.SetProgress((byte)currentPercent); // архивные или невидимые продукты следует удалить с витрин foreach (var product in prodsLive.Where(product => product.Archived || !product.Visible)) { localInvisibleOrArchivedIds.Add(product.Id); } if (!skipLive) { foreach (var item in idsToProcess.Except(prodsLive.Select(y => y.Id))) { missing.Add(item); } } //неопубликованные или расщепленные публикуем сразу int[] prodsToPublishIds = null; if (!skipPublishing) { prodsToPublishIds = prodsLive .Where(x => !x.Archived && x.Visible && ( !x.IsPublished || PublishAction.GetAllArticlesToCheck(x).Any(p => !p.IsPublished) || _freezeService.GetFreezeState(x.Id) == FreezeState.Unfrosen ) ) .Select(x => x.Id) .ToArray(); if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(tl); } // удалим требующие публикации или удаления продукты prodsLive = prodsLive .Where(p => !prodsToPublishIds.Contains(p.Id) && !localInvisibleOrArchivedIds.Contains(p.Id)) .ToArray(); } if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(tl); } lock (percentLocker) { currentPercent += (float)30 / parts.Length; } TaskContext.SetProgress((byte)currentPercent); foreach (var id in localInvisibleOrArchivedIds) { invisibleOrArchivedIds.Add(id); } int sectionSize = Math.Min(bundleSize, 5); var tasks = ArticleFilter.LiveFilter.Filter(prodsLive) .Section(sectionSize) .Select(z => tl.QpNotificationService .SendProductsAsync(z.ToArray(), false, context.UserName, context.UserId, localize, false, channels) .ContinueWith(y => UpdateFilteredIds(filteredInLive, y.IsFaulted ? null : y.Result, z, y.Exception, errors, failed))) .Concat(ArticleFilter.DefaultFilter.Filter(prodsStage) .Section(sectionSize) .Select(z => tl.QpNotificationService.SendProductsAsync(z.ToArray(), true, context.UserName, context.UserId, localize, false, channels) .ContinueWith(y => UpdateFilteredIds(filteredInStage, y.IsFaulted ? null : y.Result, z, y.Exception, errors, failed)))) .ToArray(); if (tasks.Length > 0) { float percentsPerTask = (float)10 / parts.Length / tasks.Length; tasks = tasks .Select(x => x.ContinueWith(y => { lock (percentLocker) { currentPercent += percentsPerTask; } TaskContext.SetProgress((byte)currentPercent); })) .ToArray(); DoWithLogging(() => Task.WaitAll(tasks), "Sending notifications for live ({liveIds}) and stage ({stageIds}) products", ArticleFilter.LiveFilter.Filter(prodsLive).Select(n => n.Id).ToArray(), ArticleFilter.DefaultFilter.Filter(prodsStage).Select(n => n.Id).ToArray() ); } else { lock (percentLocker) { currentPercent += (float)10 / parts.Length; } TaskContext.SetProgress((byte)currentPercent); } if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(tl); } // эти продукты имеют неопубликованные или расщепленные статьи if (!skipPublishing && prodsToPublishIds.Length > 0) { var publishAction = ObjectFactoryBase.Resolve <PublishAction>(); var publishActionContext = new ActionContext { ContentItemIds = prodsToPublishIds, Parameters = new Dictionary <string, string>() { { ignoredStatusKey, ignoredStatus } }, UserId = context.UserId, UserName = context.UserName }; try { DoWithLogging( () => publishAction.Process(publishActionContext), "Calling PublishAction for products {ids}", prodsToPublishIds ); } catch (ActionException ex) { var ids = ex.InnerExceptions.OfType <ProductException>().Select(x => x.ProductId); Logger.Error() .Exception(ex) .Message("Exception has been thrown while publishing products {ids}", prodsToPublishIds) .Write(); foreach (var pID in ids) { failed.TryAdd(pID, null); } } catch (Exception ex) { Logger.Error() .Exception(ex) .Message("Exception has been thrown while publishing products {ids}", prodsToPublishIds) .Write(); } } lock (percentLocker) { currentPercent += (float)10 / parts.Length; } TaskContext.SetProgress((byte)currentPercent); return(tl); } catch (Exception ex) { Logger.Error().Message("SendProductAction exception").Exception(ex).Write(); foreach (var item in idsToProcess) { failed.TryAdd(item, null); } errors.Add(ex); } HttpContextUserProvider.ForcedUserId = 0; return(tl); }, tt => { }); if (TaskContext.IsCancellationRequested) { TaskContext.IsCancelled = true; return(ActionTaskResult.Error(new ActionTaskResultMessage() { ResourceClass = nameof(SendProductActionStrings), ResourceName = nameof(SendProductActionStrings.Cancelled) }, context.ContentItemIds)); } var productsToRemove = new int[0]; var productsToRemoveCheck = missing .Concat(invisibleOrArchivedIds) .Except(excluded) .Except(frozen) .Except(validationErrors.Keys) .ToArray(); if (productsToRemoveCheck.Length > 0) { // проверяем, какие из проблемных продуктов присутствуют на витрине var cmService = ObjectFactoryBase.Resolve <IList <IConsumerMonitoringService> >(); productsToRemove = DoWithLogging( () => cmService.SelectMany(s => s.FindExistingProducts(productsToRemoveCheck)).Distinct().ToArray(), "Checking whether products {ids} are missing on fronts", productsToRemoveCheck ); if (productsToRemove.Length > 0) { // эти продукты отсутствуют в DPC или не видны, но остались на витрине // их надо удалить с витрин var service = ObjectFactoryBase.Resolve <IQPNotificationService>(); var productService = ObjectFactoryBase.Resolve <IProductService>(); DoWithLogging( () => Task.WhenAll(productsToRemove.Section(20).Select( s => service.DeleteProductsAsync( productService.GetSimpleProductsByIds(s.ToArray()), context.UserName, context.UserId, false) ) ).Wait(), "Removing missing products from fronts {ids}", productsToRemove ); } } DoWithLogging( () => _validationService.UpdateValidationInfo(productIds, validationErrorsSerialized), "Updating validation info for products {ids}", productIds ); int[] notFound = missing.Except(productsToRemove).Except(excluded).Except(frozen).Except(validationErrors.Keys).ToArray(); var notSucceeded = failed.Keys.Concat(notFound).Concat(excluded).Concat(frozen) .Concat(validationErrors.Keys).ToArray(); var result = new ActionTaskResult() { FailedIds = notSucceeded }; var msg = new ActionTaskResultMessage() { ResourceClass = nameof(SendProductActionStrings) }; if (notSucceeded.Any()) { msg.ResourceName = nameof(SendProductActionStrings.PartiallySucceededResult); msg.Extra = string.Join(", ", notSucceeded); msg.Parameters = new object[] { productIds.Length - notSucceeded.Length, productIds.Length }; } else { msg.ResourceName = nameof(SendProductActionStrings.SucceededResult); msg.Parameters = new object[] { productIds.Length }; } result.Messages.Add(msg); if (errors.Any()) { result.Messages.Add(new ActionTaskResultMessage() { ResourceClass = nameof(SendProductActionStrings), ResourceName = nameof(SendProductActionStrings.Errors), Extra = string.Join(", ", errors.Select(x => x.Message).Distinct()) }); } AddMessages(result, nameof(SendProductActionStrings.ExcludedByStatus), excluded.ToArray()); AddMessages(result, nameof(SendProductActionStrings.ExcludedWithFreezing), frozen.ToArray()); AddMessages(result, nameof(SendProductActionStrings.NotFoundInDpc), notFound.ToArray()); AddMessages(result, nameof(SendProductActionStrings.RemovedFromFronts), productsToRemove.ToArray()); AddMessages(result, nameof(SendProductActionStrings.NotPassedByStageFiltration), filteredInStage.ToArray()); AddMessages(result, nameof(SendProductActionStrings.NotPassedByLiveFiltration), filteredInLive.ToArray()); if (validationErrors.Any()) { result.Messages.AddRange(validationErrors.SelectMany(v => v.Value.Messages)); } TaskContext.Result = result; return(result); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.EnableConcurrentExecution(); analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze); analysisContext.RegisterCompilationStartAction(startContext => { var instantiatedTypes = new ConcurrentBag<INamedTypeSymbol>(); var internalTypes = new ConcurrentBag<INamedTypeSymbol>(); Compilation compilation = startContext.Compilation; // If the assembly being built by this compilation exposes its internals to // any other assembly, don't report any "uninstantiated internal class" errors. // If we were to report an error for an internal type that is not instantiated // by this assembly, and then it turned out that the friend assembly did // instantiate the type, that would be a false positive. We've decided it's // better to have false negatives (which would happen if the type were *not* // instantiated by any friend assembly, but we didn't report the issue) than // to have false positives. INamedTypeSymbol internalsVisibleToAttributeSymbol = compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.InternalsVisibleToAttribute"); if (AssemblyExposesInternals(compilation, internalsVisibleToAttributeSymbol)) { return; } INamedTypeSymbol systemAttributeSymbol = compilation.GetTypeByMetadataName("System.Attribute"); INamedTypeSymbol iConfigurationSectionHandlerSymbol = compilation.GetTypeByMetadataName("System.Configuration.IConfigurationSectionHandler"); INamedTypeSymbol configurationSectionSymbol = compilation.GetTypeByMetadataName("System.Configuration.ConfigurationSection"); INamedTypeSymbol safeHandleSymbol = compilation.GetTypeByMetadataName("System.Runtime.InteropServices.SafeHandle"); INamedTypeSymbol traceListenerSymbol = compilation.GetTypeByMetadataName("System.Diagnostics.TraceListener"); INamedTypeSymbol mef1ExportAttributeSymbol = compilation.GetTypeByMetadataName("System.ComponentModel.Composition.ExportAttribute"); INamedTypeSymbol mef2ExportAttributeSymbol = compilation.GetTypeByMetadataName("System.Composition.ExportAttribute"); startContext.RegisterOperationAction(context => { IObjectCreationExpression expr = (IObjectCreationExpression)context.Operation; var namedType = expr.Type as INamedTypeSymbol; if (namedType != null) { instantiatedTypes.Add(namedType); } }, OperationKind.ObjectCreationExpression); startContext.RegisterSymbolAction(context => { INamedTypeSymbol type = (INamedTypeSymbol)context.Symbol; if (type.GetResultantVisibility() != SymbolVisibility.Public && !IsOkToBeUnused(type, compilation, systemAttributeSymbol, iConfigurationSectionHandlerSymbol, configurationSectionSymbol, safeHandleSymbol, traceListenerSymbol, mef1ExportAttributeSymbol, mef2ExportAttributeSymbol)) { internalTypes.Add(type); } }, SymbolKind.NamedType); startContext.RegisterCompilationEndAction(context => { IEnumerable<INamedTypeSymbol> uninstantiatedInternalTypes = internalTypes .Except(instantiatedTypes) .Where(type => !HasInstantiatedNestedType(type, instantiatedTypes)); foreach (INamedTypeSymbol type in uninstantiatedInternalTypes) { context.ReportDiagnostic(type.CreateDiagnostic(Rule, type.FormatMemberName())); } }); }); }
internal static Result Send(int[] ids, int bundleSize) { var parts = ids.Section(bundleSize); var failed = new ConcurrentBag <int>(); var missing = new ConcurrentBag <int>(); var invisibleOrArchived = new ConcurrentBag <int>(); var errors = new ConcurrentBag <Exception>(); var productsToPublish = new ConcurrentBag <Article>(); var userProvider = ObjectFactoryBase.Resolve <IUserProvider>(); int userId = userProvider.GetUserId(); string userName = userProvider.GetUserName(); HttpContextUserProvider.ForcedUserId = userId; Parallel.ForEach(parts, new ParallelOptions { MaxDegreeOfParallelism = 12 }, () => { HttpContextUserProvider.ForcedUserId = userId; return(new TLocal { ProductService = ObjectFactoryBase.Resolve <IProductService>(), QPNotificationService = ObjectFactoryBase.Resolve <IQPNotificationService>(), }); }, (x, ps, tl) => { try { int n = 0; Article[] ps1 = null; Article[] ps2 = null; while (true) { // три попытки обработать продукт try { var idsToPublish = new HashSet <int>(); var idsToRemove = new HashSet <int>(); var prods = tl.ProductService.GetProductsByIds(288, x.ToArray(), false); // проверим, что продукты не надо публиковать или архивировать foreach (var product in prods) { if (product.Archived || product.Visible == false) { // архивные или невидимые продукты следует удалить с витрин idsToRemove.Add(product.Id); continue; } if (!product.IsPublished || PublishAction.GetAllArticlesToCheck(product).Where(p => !p.IsPublished).Any()) { // эти продукты имеют неопубликованные или расщепленные статьи productsToPublish.Add(product); idsToPublish.Add(product.Id); } } foreach (var item in x.Except(prods.Select(y => y.Id)).Except(idsToPublish)) { missing.Add(item); } // удалим требующие публикации или удаления продукты prods = prods.Where(p => !idsToPublish.Contains(p.Id) || idsToRemove.Contains(p.Id)).ToArray(); // так как мы не отправляем продукты с неопубликовнными изменениями, то stage-версия продукта опубликована. // используем один продукт для формирования двух xml ps1 = ArticleFilter.LiveFilter.Filter(prods).ToArray(); ps2 = ArticleFilter.DefaultFilter.Filter(prods).ToArray(); foreach (var item in idsToRemove) { invisibleOrArchived.Add(item); } break; } catch (Exception ex) { //защита от временных сбойев sql Thread.Sleep(50); n++; if (n >= 3) { errors.Add(ex); foreach (var item in x) { failed.Add(item); } return(tl); } } } var tasks = ps1 .Section(Math.Min(bundleSize, 5)) .Select(z => tl.QPNotificationService.SendProductsAsync(z.ToArray(), false, userName, userId, false, false)) .Union (ps2 .Section(Math.Min(bundleSize, 5)) .Select(z => tl.QPNotificationService.SendProductsAsync(z.ToArray(), true, userName, userId, false, false)) ).ToList(); Task.WhenAll(tasks).Wait(); return(tl); } catch (Exception ex) { foreach (var item in x) { failed.Add(item); } errors.Add(ex); } HttpContextUserProvider.ForcedUserId = 0; return(tl); }, tt => { }); var productsToRemove = missing .Union(invisibleOrArchived) .Distinct() .ToArray(); if (productsToRemove.Length > 0) { // проверяем, какие из проблемных продуктов присутствуют на витрине productsToRemove = ObjectFactoryBase.Resolve <IConsumerMonitoringService>().FindExistingProducts(productsToRemove); if (productsToRemove.Length > 0) { // эти продукты отсутствуют в DPC или не видны, но остались на витрине // их надо удалить с витрин var service = ObjectFactoryBase.Resolve <IQPNotificationService>(); Task.WhenAll(productsToRemove .Section(20).Select(s => service.DeleteProductsAsync(s.Select(id => new Article() { Id = id }).ToArray(), userName, userId, false))) .Wait(); } } HttpContextUserProvider.ForcedUserId = 0; var products = productsToPublish.ToArray(); return(new Result { Failed = failed.ToArray(), NotFound = missing.Except(productsToRemove).ToArray(), Removed = productsToRemove.Distinct().ToArray(), NeedPublishing = products, Errors = errors.ToArray() }); }
public override void Initialize(AnalysisContext analysisContext) { analysisContext.EnableConcurrentExecution(); analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze); analysisContext.RegisterCompilationStartAction(startContext => { var instantiatedTypes = new ConcurrentBag <INamedTypeSymbol>(); var internalTypes = new ConcurrentBag <INamedTypeSymbol>(); Compilation compilation = startContext.Compilation; // If the assembly being built by this compilation exposes its internals to // any other assembly, don't report any "uninstantiated internal class" errors. // If we were to report an error for an internal type that is not instantiated // by this assembly, and then it turned out that the friend assembly did // instantiate the type, that would be a false positive. We've decided it's // better to have false negatives (which would happen if the type were *not* // instantiated by any friend assembly, but we didn't report the issue) than // to have false positives. INamedTypeSymbol internalsVisibleToAttributeSymbol = compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.InternalsVisibleToAttribute"); if (AssemblyExposesInternals(compilation, internalsVisibleToAttributeSymbol)) { return; } INamedTypeSymbol systemAttributeSymbol = compilation.GetTypeByMetadataName("System.Attribute"); INamedTypeSymbol iConfigurationSectionHandlerSymbol = compilation.GetTypeByMetadataName("System.Configuration.IConfigurationSectionHandler"); INamedTypeSymbol configurationSectionSymbol = compilation.GetTypeByMetadataName("System.Configuration.ConfigurationSection"); INamedTypeSymbol safeHandleSymbol = compilation.GetTypeByMetadataName("System.Runtime.InteropServices.SafeHandle"); INamedTypeSymbol traceListenerSymbol = compilation.GetTypeByMetadataName("System.Diagnostics.TraceListener"); INamedTypeSymbol mef1ExportAttributeSymbol = compilation.GetTypeByMetadataName("System.ComponentModel.Composition.ExportAttribute"); INamedTypeSymbol mef2ExportAttributeSymbol = compilation.GetTypeByMetadataName("System.Composition.ExportAttribute"); startContext.RegisterOperationAction(context => { IObjectCreationExpression expr = (IObjectCreationExpression)context.Operation; var namedType = expr.Type as INamedTypeSymbol; if (namedType != null) { instantiatedTypes.Add(namedType); } }, OperationKind.ObjectCreationExpression); startContext.RegisterSymbolAction(context => { INamedTypeSymbol type = (INamedTypeSymbol)context.Symbol; if (type.GetResultantVisibility() != SymbolVisibility.Public && !IsOkToBeUnused(type, compilation, systemAttributeSymbol, iConfigurationSectionHandlerSymbol, configurationSectionSymbol, safeHandleSymbol, traceListenerSymbol, mef1ExportAttributeSymbol, mef2ExportAttributeSymbol)) { internalTypes.Add(type); } }, SymbolKind.NamedType); startContext.RegisterCompilationEndAction(context => { IEnumerable <INamedTypeSymbol> uninstantiatedInternalTypes = internalTypes .Except(instantiatedTypes) .Where(type => !HasInstantiatedNestedType(type, instantiatedTypes)); foreach (INamedTypeSymbol type in uninstantiatedInternalTypes) { context.ReportDiagnostic(type.CreateDiagnostic(Rule, type.FormatMemberName())); } }); }); }
public async Task <IEnumerable <AnalysisResult> > AnalyzeScopeAsync(IProgress <int> progress) { var analysisResults = new ConcurrentBag <AnalysisResult>(); var potentialDuplicates = new ConcurrentBag <AnalysisResult>(); SyntaxTree syntaxTree = null; SemanticModel semanticModel = null; SingleSyntaxTreeAnalysisContext analysisContext = null; var analyzeSyntaxTreeActions = AnalyzeSingleSyntaxTreeAndCollectResultsActions // We intentionally access the modified closure here (syntaxTree, semanticModel, analysisContext), // because we want to avoid creation of a huge number of temporary Action objects. // ReSharper disable AccessToModifiedClosure .Select(action => new Action(() => action(syntaxTree, semanticModel, analysisContext, analysisResults, potentialDuplicates))) // ReSharper restore AccessToModifiedClosure .ToArray(); // Same here. We want to have just a single Action object created and called many times. // We intentionally do not want to use a local function here. Although its usage would be // semantically nicer and create exactly the same closure as the below Action, the fact that // we need to convert that local function to Action in the Task.Run() call means we would // end up in creating an additional Action object for every pass in the loop, and that's // exactly what we want to avoid. // ReSharper disable once ConvertToLocalFunction Action analyzeSyntaxTreeInParallel = () => Parallel.Invoke(analyzeSyntaxTreeActions); // WARNING: Keep the progress counter in sync with the logic behind the calculation of the maximum progress! int progressCounter = 0; foreach (var document in GetDocumentsToAnalyze()) { analysisContext = new SingleSyntaxTreeAnalysisContext(document); syntaxTree = await document.GetSyntaxTreeAsync().ConfigureAwait(false); if (!syntaxTree.BeginsWithAutoGeneratedComment()) { semanticModel = await document.GetSemanticModelAsync(); // Each of the actions (analysis) will operate on the same (current) syntaxTree and semanticModel. await Task.Run(analyzeSyntaxTreeInParallel); } progress.Report(++progressCounter); } // TODO-IG: Fully refactor Analysis/Scope/Analyzer/Context/Result etc. // and remove this terrible temporary workaround. var duplicatesToRemove = FindDuplicatesToRemove(); return(analysisResults.Except(duplicatesToRemove)); IReadOnlyCollection <AnalysisResult> FindDuplicatesToRemove() { return(potentialDuplicates // We consider the result to be a duplicate if have the same // suggestion on the same node several times. // The AnalysisResult does not contain node (at the moment, // who knows what the upcoming refactoring will bring us ;-)) // so we will see if the file name and the position are the same. .GroupBy(result => new { result.Suggestion, result.FilePath, result.Position }) .Where(group => group.Count() > 1) // Just leave the first one so far and mark the rest as those to be removed. // This is all a temporary workaround after all :-) .SelectMany(group => group.Skip(1)) .ToList()); } }
public static void RemoveItem <T>(this ConcurrentBag <T> bag, T item) { bag = new ConcurrentBag <T>(bag.Except(new[] { item })); }
/// <summary> /// Post process the types: /// - If UserType has static members in more than one module, split it into multiple user types. /// - Find parent type/namespace. /// </summary> /// <param name="userTypes">The list of user types.</param> /// <param name="symbolNamespaces">The symbol namespaces.</param> /// <returns>Newly generated user types.</returns> internal IEnumerable <UserType> ProcessTypes(IEnumerable <UserType> userTypes, Dictionary <Symbol, string> symbolNamespaces) { ConcurrentBag <UserType> newTypes = new ConcurrentBag <UserType>(); // Split user types that have static members in more than one module Parallel.ForEach(Partitioner.Create(userTypes), (userType) => { if (!userType.ExportStaticFields) { return; } Symbol[] symbols = GlobalCache.GetSymbolStaticFieldsSymbols(userType.Symbol).ToArray(); if (symbols.Length == 1) { return; } bool foundSameNamespace = false; foreach (var symbol in symbols) { string nameSpace = symbol.Module.Namespace; if (userType.Namespace != nameSpace) { newTypes.Add(new UserType(symbol, null, nameSpace) { ExportDynamicFields = false }); } else { foundSameNamespace = true; } } userType.ExportStaticFields = foundSameNamespace; }); // Find parent type/namespace Dictionary <string, UserType> namespaceTypes = new Dictionary <string, UserType>(); foreach (UserType userType in userTypes) { Symbol symbol = userType.Symbol; if (symbol.Tag != CodeTypeTag.Class && symbol.Tag != CodeTypeTag.Structure && symbol.Tag != CodeTypeTag.Union && symbol.Tag != CodeTypeTag.Enum) { continue; } string symbolName = symbol.Name; List <string> namespaces = symbol.Namespaces; if (namespaces.Count == 1) { // Class is not defined in namespace nor in type. continue; } StringBuilder currentNamespaceSB = new StringBuilder(); UserType previousNamespaceUserType = null; for (int i = 0; i < namespaces.Count - 1; i++) { if (i > 0) { currentNamespaceSB.Append("::"); } currentNamespaceSB.Append(namespaces[i]); string currentNamespace = currentNamespaceSB.ToString(); UserType namespaceUserType; if (!namespaceTypes.TryGetValue(currentNamespace, out namespaceUserType)) { namespaceUserType = GlobalCache.GetUserType(currentNamespace, symbol.Module); } // Put type under exported template type (TODO: Remove this when template types start checking subtypes) var templateType = namespaceUserType as TemplateUserType; if (templateType != null) { namespaceUserType = templateType.TemplateType; } if (namespaceUserType == null) { namespaceUserType = new NamespaceUserType(new string[] { namespaces[i] }, previousNamespaceUserType == null ? symbolNamespaces[symbol] : null); if (previousNamespaceUserType != null) { namespaceUserType.UpdateDeclaredInType(previousNamespaceUserType); } namespaceTypes.Add(currentNamespace, namespaceUserType); newTypes.Add(namespaceUserType); } previousNamespaceUserType = namespaceUserType; } userType.UpdateDeclaredInType(previousNamespaceUserType); } // Update Class Name if it has duplicate with the namespace it is declared in foreach (UserType userType in newTypes.Concat(userTypes)) { userType.ClassName = userType.OriginalClassName; if (userType.DeclaredInType != null && userType.OriginalClassName == userType.DeclaredInType.ClassName) { userType.ClassName += "_"; } TemplateUserType templateUserType = userType as TemplateUserType; if (templateUserType != null) { foreach (UserType specializedUserType in templateUserType.SpecializedTypes) { specializedUserType.ClassName = userType.ClassName; } } } // Remove duplicate types from exported template types (TODO: Remove this when template types start checking subtypes) foreach (UserType userType in userTypes) { TemplateUserType templateType = userType as TemplateUserType; if (templateType == null) { continue; } HashSet <string> uniqueTypes = new HashSet <string>(); foreach (var innerType in templateType.InnerTypes.ToArray()) { string className; if (!(innerType is NamespaceUserType)) { className = innerType.ClassName; } else { className = innerType.Namespace; } if (uniqueTypes.Contains(className)) { templateType.InnerTypes.Remove(innerType); } else { uniqueTypes.Add(className); } } } // Find all derived classes foreach (UserType userType in userTypes) { // We are doing this only for UDTs if (userType is EnumUserType || userType is GlobalsUserType || userType is NamespaceUserType) { continue; } // For template user types, we want to remember all specializations TemplateUserType templateUserType = userType as TemplateUserType; if (templateUserType != null) { foreach (UserType specializedUserType in templateUserType.SpecializedTypes) { AddDerivedClassToBaseClasses(specializedUserType); } } else { AddDerivedClassToBaseClasses(userType); } } // Merge namespaces when possible foreach (UserType userType in newTypes) { NamespaceUserType nameSpace = userType as NamespaceUserType; if (nameSpace == null) { continue; } nameSpace.MergeIfPossible(); } // Remove empty namespaces after merge List <UserType> removedUserTypes = new List <UserType>(); foreach (UserType userType in newTypes) { NamespaceUserType nameSpace = userType as NamespaceUserType; if (nameSpace == null) { continue; } if (nameSpace.InnerTypes.Count == 0) { removedUserTypes.Add(nameSpace); } } return(newTypes.Except(removedUserTypes)); }
public void ShouldReturnEquivalentBagToNumberArray() { int[] numbers = new int[] { 1, 2, 3, 4, 3, 6, 4, 8, 17, 42, 6 }; ConcurrentBag<int> expected = new ConcurrentBag<int>(numbers); ConcurrentBag<int> actual = new ConcurrentBag<int>(); UniqueRandomNumberGenerator g = new UniqueRandomNumberGenerator(numbers); while (g.RemainingNumbersCount > 0) { int number = g.NewRandomNumber(); actual.Add(number); } CollectionAssert.IsEmpty( actual.Except(expected), "The bag of random numbers differs from the bag corresponding to the initial array."); }
public void FillProduct() { if (isLoggingDebug) { Debug.WriteLine(string.Concat(debugPrefix, "MultiThreading:", isMultithreaded.ToString(), "Starting Creating ", numberOfProductToGenerate, " Random Products from data list...")); } if (isMultithreaded == false) { for (int num = 1; num < numberOfProductToGenerate + 1; num++) { ProductCreation(num); } } else if (isMultithreaded) { #region multithreading var threadNum = new ProductNumThreadSafe(); var enQueueTask = Task.Run(() => { var numTest = 0; while (numTest < numberOfProductToGenerate) { _queueToExecute.Enqueue(() => { var retValue = ProductCreation(threadNum.GetNextNumber()); return(retValue); }); numTest++; } }); var deQueueTask = Task.Run(() => { while (_queueToExecute.Count > 0) { Func <bool> toProcess; if (_executingTasks.Count < _concurrentExecution && _queueToExecute.TryDequeue(out toProcess)) { var runTask = Task.Run(toProcess); runTask.ContinueWith(x => { if (x.IsFaulted) { Debug.WriteLine(string.Format("ERROR Thread: {0}", x.Exception)); } }); _executingTasks.Add(runTask); } var completedTask = _executingTasks.Where(t => t.Status == TaskStatus.RanToCompletion || t.Status == TaskStatus.Faulted); if (completedTask.Any()) { _executingTasks = new ConcurrentBag <Task>(_executingTasks.Except(completedTask)); } } }); Task.WaitAll(new[] { enQueueTask, deQueueTask }); #endregion } }
/// <summary> /// Post process the types: /// - If UserType has static members in more than one module, split it into multiple user types. /// - Find parent type/namespace. /// </summary> /// <param name="userTypes">The list of user types.</param> /// <param name="symbolNamespaces">The symbol namespaces.</param> /// <returns>Newly generated user types.</returns> internal IEnumerable<UserType> ProcessTypes(IEnumerable<UserType> userTypes, Dictionary<Symbol, string> symbolNamespaces) { ConcurrentBag<UserType> newTypes = new ConcurrentBag<UserType>(); // Split user types that have static members in more than one module Parallel.ForEach(Partitioner.Create(userTypes), (userType) => { if (!userType.ExportStaticFields) return; Symbol[] symbols = GlobalCache.GetSymbolStaticFieldsSymbols(userType.Symbol).ToArray(); if (symbols.Length == 1) return; bool foundSameNamespace = false; foreach (var symbol in symbols) { string nameSpace = symbol.Module.Namespace; if (userType.Namespace != nameSpace) newTypes.Add(new UserType(symbol, null, nameSpace) { ExportDynamicFields = false }); else foundSameNamespace = true; } userType.ExportStaticFields = foundSameNamespace; }); // Find parent type/namespace Dictionary<string, UserType> namespaceTypes = new Dictionary<string, UserType>(); foreach (UserType userType in userTypes) { Symbol symbol = userType.Symbol; if (symbol.Tag != SymTagEnum.SymTagUDT && symbol.Tag != SymTagEnum.SymTagEnum) continue; string symbolName = symbol.Name; List<string> namespaces = symbol.Namespaces; if (namespaces.Count == 1) { // Class is not defined in namespace nor in type. continue; } StringBuilder currentNamespaceSB = new StringBuilder(); UserType previousNamespaceUserType = null; for (int i = 0; i < namespaces.Count - 1; i++) { if (i > 0) currentNamespaceSB.Append("::"); currentNamespaceSB.Append(namespaces[i]); string currentNamespace = currentNamespaceSB.ToString(); UserType namespaceUserType; if (!namespaceTypes.TryGetValue(currentNamespace, out namespaceUserType)) namespaceUserType = GlobalCache.GetUserType(currentNamespace, symbol.Module); // Put type under exported template type (TODO: Remove this when template types start checking subtypes) var templateType = namespaceUserType as TemplateUserType; if (templateType != null) namespaceUserType = templateType.TemplateType; if (namespaceUserType == null) { namespaceUserType = new NamespaceUserType(new string[] { namespaces[i] }, previousNamespaceUserType == null ? symbolNamespaces[symbol] : null); if (previousNamespaceUserType != null) namespaceUserType.UpdateDeclaredInType(previousNamespaceUserType); namespaceTypes.Add(currentNamespace, namespaceUserType); newTypes.Add(namespaceUserType); } previousNamespaceUserType = namespaceUserType; } userType.UpdateDeclaredInType(previousNamespaceUserType); } // Update Class Name if it has duplicate with the namespace it is declared in foreach (UserType userType in newTypes.Concat(userTypes)) { userType.ClassName = userType.OriginalClassName; if (userType.DeclaredInType != null && userType.OriginalClassName == userType.DeclaredInType.ClassName) { userType.ClassName += "_"; } TemplateUserType templateUserType = userType as TemplateUserType; if (templateUserType != null) { foreach (UserType specializedUserType in templateUserType.SpecializedTypes) { specializedUserType.ClassName = userType.ClassName; } } } // Remove duplicate types from exported template types (TODO: Remove this when template types start checking subtypes) foreach (UserType userType in userTypes) { TemplateUserType templateType = userType as TemplateUserType; if (templateType == null) continue; HashSet<string> uniqueTypes = new HashSet<string>(); foreach (var innerType in templateType.InnerTypes.ToArray()) { string className; if (!(innerType is NamespaceUserType)) className = innerType.ClassName; else className = innerType.Namespace; if (uniqueTypes.Contains(className)) templateType.InnerTypes.Remove(innerType); else uniqueTypes.Add(className); } } // Find all derived classes foreach (UserType userType in userTypes) { // We are doing this only for UDTs if (userType is EnumUserType || userType is GlobalsUserType || userType is NamespaceUserType) continue; // For template user types, we want to remember all specializations TemplateUserType templateUserType = userType as TemplateUserType; if (templateUserType != null) { foreach (UserType specializedUserType in templateUserType.SpecializedTypes) { AddDerivedClassToBaseClasses(specializedUserType); } } else { AddDerivedClassToBaseClasses(userType); } } // Merge namespaces when possible foreach (UserType userType in newTypes) { NamespaceUserType nameSpace = userType as NamespaceUserType; if (nameSpace == null) { continue; } nameSpace.MergeIfPossible(); } // Remove empty namespaces after merge List<UserType> removedUserTypes = new List<UserType>(); foreach (UserType userType in newTypes) { NamespaceUserType nameSpace = userType as NamespaceUserType; if (nameSpace == null) { continue; } if (nameSpace.InnerTypes.Count == 0) { removedUserTypes.Add(nameSpace); } } return newTypes.Except(removedUserTypes); }
public static ConcurrentBag <T> Without <T>(this ConcurrentBag <T> bag, Func <T, bool> func) { return(new ConcurrentBag <T>(bag.Except(bag.Where(func)))); }
public void Remove(Func <object, ChoTypeConverterFormatSpec, CultureInfo, Type> fta) { if (fta == null) { return; } _fieldTypeAssessors = new ConcurrentBag <Func <object, ChoTypeConverterFormatSpec, CultureInfo, Type> >(_fieldTypeAssessors.Except(new[] { fta })); }