public void Publish <T>(T message, string exchangeName, string exchangeType, string routeKey) where T : class { if (message == null) { return; } var channel = _objectPool.Get(); try { channel.ExchangeDeclare(exchangeName, exchangeType, true, false, null); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish(exchangeName, routeKey, properties, sendBytes); } catch (Exception ex) { throw ex; } finally { _objectPool.Return(channel); } }
public void OnResourceExecuting(ResourceExecutingContext context) { #region list方案未通过 ///////////////////list方案--未通过 //var name = context.RouteData.Values["action"].ToString(); //var c = defaultObjectsList.Where(u => u.Get().id == name).FirstOrDefault(); //DefaultObjectPool<Dome> resulCabak = null; //foreach (var item in defaultObjectsList) //{ // var d = item; // var namec = item.Get().id; // if (item.Get().id == name) // { // resulCabak = item; // } //} //if (resulCabak != null) //{ // var cResult = resulCabak.Get(); // context.Result = cResult.view; // c.Return(cResult); //} #endregion #region 单独实现-通过 ////////////////////////////////单独实现-通过 //单个页面测试 //var Result = defaultPoolWithDemoPolicy.Get(); //if (Result.id == context.RouteData.Values["action"].ToString()) //{ // context.Result = Result.view; // defaultPoolWithDemoPolicy.Return(Result); //} #endregion /////////////////////////////////继续扩展完善 Dome Result = null; for (int i = 0; i < 3; i++) { Result = defaultPoolWithDemoPolicy.Get(); if (Result != null) { if (Result.id == context.RouteData.Values["action"].ToString()) { context.Result = Result.view; defaultPoolWithDemoPolicy.Return(Result); break; } else { //defaultPoolWithDemoPolicy.Return(Result); } } } }
public void Test2() { var demoPolicy = new DemoPooledObjectPolicy(); var defaultPoolWithDemoPolicy = new DefaultObjectPool <Demo>(demoPolicy, 1); //获取一个对象 var item1 = defaultPoolWithDemoPolicy.Get(); //获取一个对象 var item2 = defaultPoolWithDemoPolicy.Get(); Assert.True(item1 != item2); }
public void PoolTest() { var p = new DefaultObjectPool <TClass>(new DefaultPooledObjectPolicy <TClass>()); var a = p.Get(); var b = p.Get(); Console.WriteLine(a.Number); Console.WriteLine(b.Number); p.Return(a); var c = p.Get(); Console.WriteLine(c.Number); }
public void DefaultObjectPoolWithDefaultPolicy_GetAnd_ReturnObject_SameInstance() { // Arrange var pool = new DefaultObjectPool <object>(new DefaultPooledObjectPolicy <object>()); var obj1 = pool.Get(); pool.Return(obj1); // Act var obj2 = pool.Get(); // Assert Assert.Same(obj1, obj2); }
public void DefaultObjectPool_GetAndReturnObject_SameInstance() { // Arrange var pool = new DefaultObjectPool <List <int> >(new ListPolicy()); var list1 = pool.Get(); pool.Return(list1); // Act var list2 = pool.Get(); // Assert Assert.Same(list1, list2); }
public void DefaultObjectPool_Return_RejectedByPolicy() { // Arrange var pool = new DefaultObjectPool <List <int> >(new ListPolicy()); var list1 = pool.Get(); list1.Capacity = 20; // Act pool.Return(list1); var list2 = pool.Get(); // Assert Assert.NotSame(list1, list2); }
public void Publish(AppointmentConfirmedEvent eventToPublish) { Guard.Against.Null(eventToPublish, nameof(eventToPublish)); var channel = _objectPool.Get(); object message = (object)eventToPublish; try { string exchangeName = MessagingConstants.Exchanges.FRONTDESK_VETCLINICPUBLIC_EXCHANGE; channel.ExchangeDeclare(exchangeName, "direct", true, false, null); var sendBytes = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish( exchange: exchangeName, routingKey: "appointment-confirmation", basicProperties: properties, body: sendBytes); } finally { _objectPool.Return(channel); } }
static string GenerateQualifiedText(IEnumerable <IIdentity> value) { // ReSharper disable once PossibleMultipleEnumeration if (!value.Any()) { return(string.Empty); } var bld = StringBuilderPool.Get(); try { foreach (var elem in value) { bld.Append(elem.Name); bld.Append(Encode((byte)elem.Category)); bld.Append(Encode((byte)elem.Scope)); bld.Append('.'); } return(bld.Extract(..^ 1).ToString()); } finally { StringBuilderPool.Return(bld); } }
public Task Publish(EventItem eventItem) { _ = eventItem ?? throw new ArgumentNullException(nameof(eventItem)); if (eventItem.Data == null) { return(Task.CompletedTask); } var channel = _objectPool.Get(); try { channel.ExchangeDeclare(eventItem.Exchange, eventItem.EventType); if (eventItem.EventType == EventType.Queue) { // 声明queue,防止还没有Consumer的时候消息丢失 channel.QueueDeclareAndBind(eventItem.Exchange); } var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish(eventItem.Exchange, eventItem.Exchange, properties, eventItem.Data); return(Task.CompletedTask); } finally { _objectPool.Return(channel); } }
public void Open() { _channel = _objectPool.Get(); _replyQueueName = _channel.QueueDeclare().QueueName; _consumer = new EventingBasicConsumer(_channel); _props = _channel.CreateBasicProperties(); var correlationId = Guid.NewGuid().ToString(); _props.CorrelationId = correlationId; _props.ReplyTo = _replyQueueName; _signal = new ManualResetEvent(false); _consumer.Received += (model, ea) => { var body = ea.Body; var response = Encoding.UTF8.GetString(body); if (ea.BasicProperties.CorrelationId == correlationId) { _signal.Set(); _respQueue.Add(response); } }; }
public ConsumeRabbitMQHostedService(IPooledObjectPolicy <IModel> objectPolicy, IConfiguration Configuration) { this.Configuration = Configuration; string exchangeName = "exchange"; _objectPool = new DefaultObjectPool <IModel>(objectPolicy, Environment.ProcessorCount * 1); RabbitManager = new RabbitManager(objectPolicy); _channel = _objectPool.Get(); _channel.ExchangeDeclare(exchangeName, ExchangeType.Topic, true, false); _channel.QueueDeclare(StaticParams.ModuleName, true, false, false, null); List <Type> handlerTypes = typeof(ConsumeRabbitMQHostedService).Assembly.GetTypes() .Where(x => typeof(Handler).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract) .ToList(); foreach (Type type in handlerTypes) { Handler handler = (Handler)Activator.CreateInstance(type); Handlers.Add(handler); } foreach (IHandler handler in Handlers) { handler.QueueBind(_channel, StaticParams.ModuleName, exchangeName); } _channel.BasicQos(0, 1, false); }
public virtual void PushMessage(Message message, QueueConfiguration queueConfiguration) { string msgJson = JsonConvert.SerializeObject(message); var body = Encoding.UTF8.GetBytes(msgJson); var channel = _RabbitMQPersistent.Get(); try { IBasicProperties properties = channel.CreateBasicProperties(); var headers = new Dictionary <string, object>(); properties.Persistent = true; properties.DeliveryMode = 2; headers.Add("x-delay", queueConfiguration.Dealy); properties.Headers = headers; channel.BasicPublish(exchange: queueConfiguration.ExhangeName, routingKey: queueConfiguration.QueueName, basicProperties: properties, body: body); _logger.LogPublishing(message); } finally { _RabbitMQPersistent.Return(channel); } }
public void Publish <T>( T message, string exchangeName, string exchangeType, string routeKey) { if (message == null) { return; } //We create an object pool in the constructor. Before publishing //messages to RabbitMQ, we should get a channel from the object pool, //then construct the payload. var channel = _objectPool.Get(); try { channel.ExchangeDeclare(exchangeName, exchangeType, true, false, null); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish(exchangeName, routeKey, properties, sendBytes); } catch (Exception ex) { throw ex; } finally { //publishing, we should return this channel object //to the object pool whether the publish succeeds or fails. _objectPool.Return(channel); } }
public void Send <T>(T message, string exchangeName, string exchangeType, string routeKey) where T : class { if (message == null) { return; } var channel = _objectPool.Get(); try { channel.ExchangeDeclare(exchangeName, exchangeType, true, false); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish(exchangeName, routeKey, properties, sendBytes); } catch (Exception ex) { _logger.LogWarning($"Can not send a message to converter service: {ex.Message}"); } finally { _objectPool.Return(channel); } }
public void Publish(IApplicationEvent applicationEvent) { Guard.Against.Null(applicationEvent, nameof(applicationEvent)); var channel = _objectPool.Get(); object message = (object)applicationEvent; try { string exchangeName = MessagingConstants.Exchanges.FRONTDESK_CLINICMANAGEMENT_EXCHANGE; channel.ExchangeDeclare(exchangeName, "direct", true, false, null); var sendBytes = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish( exchange: exchangeName, routingKey: "entity-changes", basicProperties: properties, body: sendBytes); } catch (Exception) { throw; } finally { _objectPool.Return(channel); } }
public void Receive(string queueName) { var channel = _objectPool.Get(); var consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { try { var body = ea.Body.ToArray(); var message = Encoding.UTF8.GetString(body); var order = System.Text.Json.JsonSerializer.Deserialize <Order>(message); Console.WriteLine($"Order: {order.OrderNumber}|{order.ItemName}|{order.Price:N2}"); channel.BasicAck(ea.DeliveryTag, false); } catch (Exception ex) { channel.BasicNack(ea.DeliveryTag, false, true); throw ex; } finally { _objectPool.Return(channel); } }; channel.BasicConsume(queue: "orderQueue", autoAck: false, consumer: consumer); }
public void Publish <T>(T message, string routeKey, Action <IBasicProperties> configureProperties) where T : class { if (message == null) { throw new RabbitEmptyMessageException("Message is null"); } var channel = _objectPool.Get(); try { if (string.IsNullOrEmpty(_exchangeType) || string.IsNullOrEmpty(_exchnageName)) { throw new RabbitEmptyExchangeSettingsException("You didn't set exchange settings. Before you call Publish() or Call(), you should set exchange settings by SetExchnage() method"); } channel.ExchangeDeclare(_exchnageName, _exchangeType, _isDurable, _autoDelete); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var props = channel.CreateBasicProperties(); configureProperties.Invoke(props); channel.BasicPublish(_exchnageName, routeKey, props, sendBytes); } catch (Exception ex) { throw ex; } finally { _objectPool.Return(channel); } }
public void PublishList <T>(List <EventMessage <T> > message, GenericEnum routeKey) where T : DataEntity { if (!StaticParams.EnableExternalService) { return; } if (message == null) { return; } var channel = _objectPool.Get(); try { channel.ExchangeDeclare("exchange", ExchangeType.Topic, true, false, null); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish("exchange", routeKey.Code, properties, sendBytes); } catch (Exception ex) { throw ex; } finally { _objectPool.Return(channel); } }
public async Task Publish(IEvent @event) { if (@event == null) { return; } var channel = _objectPool.Get(); var exchangeName = @event.GetType().FullName; try { channel.ExchangeDeclare(exchangeName, ExchangeType.Fanout); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(@event)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; await Task.Run(() => { channel.BasicPublish(exchangeName, "", properties, sendBytes); }); } catch (Exception) { //TODO: Loguear el error pero no bloquear la operación } finally { _objectPool.Return(channel); } }
public void Publish <T>(T message, string routeKey) where T : class { if (message == null) { return; } var channel = _objectPool.Get(); try { channel.QueueDeclare(routeKey, durable: false, exclusive: false, autoDelete: false, arguments: null); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish("", routeKey, properties, sendBytes); } catch (Exception ex) { throw ex; } finally { _objectPool.Return(channel); } }
public void Publish <T>(T message) where T : class { if (message == null) { return; } var channel = _objectPool.Get(); try { _logger.LogInfo("Publishing message to RabbitMQ"); var sendBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)); var properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.BasicPublish(_rabbitExchangeOptions.Exchange, _rabbitExchangeOptions.RoutingKey, properties, sendBytes); } catch (Exception ex) { _logger.LogInfo("Publishing message to RabbitMQ failed"); throw new RabbitMqException("Service_bus_publish_failed. Exception message: " + ex.Message); } finally { _objectPool.Return(channel); } }
public void Test3() { var demoPolicy = new DemoPooledObjectPolicy(); var defaultPoolWithDemoPolicy = new DefaultObjectPool <Demo>(demoPolicy, 1); //获取一个对象 var item1 = defaultPoolWithDemoPolicy.Get(); //将对象扔回池中 defaultPoolWithDemoPolicy.Return(item1); //获取一个对象 var item2 = defaultPoolWithDemoPolicy.Get(); //获取一个对象 var item3 = defaultPoolWithDemoPolicy.Get(); Assert.True((item1 == item2) && (item3 != item2)); }
public ListenToServiceWorker(ILogger <ListenToServiceWorker> logger , IRedisSaveDataStrategy redis , ISqlServerSaveDataStrategy sqlServer, IOptions <SiteSettings> siteSettings, IServiceScopeFactory serviceScopeFactory , IPooledObjectPolicy <IModel> objectPolicy ) : base(serviceScopeFactory) { Databases = new List <ISaveDataStrategy>(); Databases.AddRange(new ISaveDataStrategy[] { sqlServer, redis }); _siteSettings = siteSettings.Value; _logger = logger; _queueName = _siteSettings.RabbitMQSettings.QueueName; _objectPool = new DefaultObjectPool <IModel>(objectPolicy, Environment.ProcessorCount * 2); channel = _objectPool.Get(); Log.Write(_logger, "Listen To RabbitMQ"); channel.QueueDeclare(queue: _queueName, durable: false, exclusive: false, autoDelete: false, arguments: null); consumer = new AsyncEventingBasicConsumer(channel); }
public void Handle(Action <T> action) { var t = DefaultObjectPool.Get(); try { action.Invoke(t); } catch { throw; } finally { DefaultObjectPool.Return(t); } }
public static void Initialize() { //Initialize pool eagerly var likes = Enumerable.Range(1, MaximumRetained).Select(x => likesPool.Get()).ToArray(); foreach (var list in likes) { likesPool.Return(list); } var stubs = Enumerable.Range(1, MaximumRetained).Select(x => _accountStubPool.Get()).ToArray(); foreach (var stub in stubs) { _accountStubPool.Return(stub); } }
public void Do(Action <IModel> action) { var channel = _objectPool.Get(); try { action(channel); } catch (Exception ex) { throw ex; } finally { _objectPool.Return(channel); } }
private void registerWeatherForecastConsumers() { var channel = _objectPool.Get(); channel.QueueBind(queue: "web-api", exchange: "web-api.service", routingKey: "webapi.weatherforecast.get"); var consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { var body = ea.Body; WeatherForecast wf = JsonConvert.DeserializeObject <WeatherForecast>(Encoding.UTF8.GetString(body.ToArray())); _logger.LogInformation($"############# Received {wf.ToString()}"); }; channel.BasicConsume(queue: "web-api", autoAck: true, consumer: consumer); }
public PooledProducer GetProducer() { var result = producerObjectPool.Get(); if (result.Pool == default) { result.Pool = producerObjectPool; } return(result); }
public ModelWrapper PullModel() { var result = pool.Get(); if (result.Pool is null) { result.Pool = pool; } return(result); }