private static void Main(string[] args)
{
string mqHost = ConfigurationManager.AppSettings["RabbitMQHost"];
using (IBus bus = RabbitHutch.CreateBus(mqHost, reg => reg.Register <IEasyNetQLogger>(log => new NullLogger())))
{
Console.WriteLine("请输入发送的消息：");
while (true)
{
string orderName = Console.ReadLine();
bus.Publish(new DtoOrder111
{
Id = 100,
Name = orderName
});
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Preparing to write to queue Producer 2!");
var bus = RabbitHutch.CreateBus("host=localhost");
for (int i = 0; i < 100; i++)
{
var message = new MessageSample
{
Id = i + 1,
Category = "Producer2",
Content = $"Conteudo 2{i}"
};
bus.Publish(message, message.Category);
}
}
static void Publish()
{
var rand = new Random();
var bus = RabbitHutch.CreateBus("host=localhost");
while (true)
{
var message = new MyMessage
{
Name = $"User-{rand.Next(1, 200)}",
ShoeSize = rand.Next(1, 50),
Address = $"{rand.Next(1, 200) }Next Lane"
};
bus.Publish(message);
Console.WriteLine($"Published Message for{message.Name}");
Thread.Sleep(1000);
}
}
static void Main(string[] args)
{
var bus = RabbitHutch.CreateBus("host=localhost");
bus.Respond <TestRequestMessage, TestResponseMessage>(HandleRequest);
bus.RespondAsync <TestAsyncRequestMessage, TestAsyncResponseMessage>(HandleAsyncRequest);
Console.WriteLine("Waiting to service requests");
Console.WriteLine("Ctrl-C to exit");
Console.CancelKeyPress += (source, cancelKeyPressArgs) =>
{
bus.Dispose();
Console.WriteLine("Shut down complete");
};
Thread.Sleep(Timeout.Infinite);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddDbContext <UsersContext>(options => options.UseLazyLoadingProxies()
.UseSqlServer(Configuration.GetConnectionString("local")));
services.AddSingleton(RabbitHutch.CreateBus($"host={Configuration.GetSection("RabbitMqHost").Value}"));
services.AddTransient(typeof(IRepository <>), typeof(Repository <>));
services.AddTransient <IUnitOfWork, UnitOfWork>();
services.AddTransient <IUsersService, UsersService>();
services.AddTransient <IBansService, BansService>();
services.AddTransient <IFriendsService, FriendsService>();
services.AddTransient <ISubscriptionsService, SubscriptionsService>();
services.ConfigureAuthentication(Configuration);
services.ConfigureAutoMapper();
services.AddSwaggerDocumentation();
services.AddSingleton <ServiceBusListener>();
}
private static void Init(string connectionString)
{
if (isInitialized == null)
{
lock (initLock)
{
if (isInitialized == null)
{
_bus = RabbitHutch.CreateBus(connectionString,
services => services.Register <ITypeNameSerializer, TypeNameSerializer>()
.Register <IConventions, MyConventions>());
isInitialized = "";
}
}
}
}
static void Main(string[] args)
{
var bus = RabbitHutch.CreateBus("host=localhost");
while (true)
{
var msg = Console.ReadLine();
var message = new CardPaymentRequestMessage
{
Amount = DateTime.Now.Hour,
CardHolderName = msg,
CardNumber = DateTime.Now.Year.ToString(),
ExpiryDate = DateTime.Now.Month.ToString()
};
var response = bus.Request <CardPaymentRequestMessage, CardPaymentResponseMessage>(message);
Console.WriteLine(response.AuthCode);
}
}
internal static IServiceCollection AddServiceLayer(this IServiceCollection services, IConfiguration configuration)
{
var rabbitString = $"host={configuration["RabbitMQ:HostName"]};";
rabbitString += "virtualHost=" + (configuration["RabbitMQ:VirtualHost"] ?? "/") + ";";
rabbitString += $"username={configuration["RabbitMQ:User"]};";
rabbitString += $"password={configuration["RabbitMQ:Password"]}";
services
.AddSingleton <IBus>(RabbitHutch.CreateBus(rabbitString))
.AddSingleton <IPatientPublisher, PatientPublisher>()
.AddTransient <IGenderService, GenderService>()
.AddTransient <IReligionService, ReligionService>()
.AddTransient <IAllergyService, AllergyService>()
.AddTransient <IPatientService, Services.PatientService>();
return(services);
}
private static void Main(string[] args)
{
string mqHost = ConfigurationManager.AppSettings["RabbitMQHost"];
using (IBus bus = RabbitHutch.CreateBus(mqHost, reg => reg.Register <IEasyNetQLogger>(log => new NullLogger())))
{
Console.WriteLine("请输入发送的主题:shanghai.beijing或lasa.beijing或shanghai.chongqing等.");
while (true)
{
string topic = Console.ReadLine();
bus.Publish(new DtoOrderTopic
{
Id = 100,
Name = "主题为" + topic + "的消息"
}, topic);
}
}
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="SequenceAmount">Количество одновременно расчитываемых последовательностей</param>
/// <param name="webAPIString">Адрес хоста web-службы</param>
/// <param name="rabbitService">Адрес RabbitMQ службы</param>
public FibonacciPool(int SequenceAmount, string webAPIString, string rabbitService)
{
_webApiLink = webAPIString;
_rabbitServiceURL = rabbitService;
// Подписываемся на rabbitMQ
_bus = RabbitHutch.CreateBus(_rabbitServiceURL);
_bus.Subscribe <Tuple <string, int> >(Guid.NewGuid().ToString(), OnResponse);
// Создаём словарь последовательностей
for (int i = 0; i < SequenceAmount; i++)
{
string currentGuid = Guid.NewGuid().ToString();
_sequences[currentGuid] = new FibonacciSequence();
keys.Add(currentGuid);
}
QueryTask = new Task(() => Query(cancellationToken.Token));
}
public void Init()
{
#region EasyNQ Connection
//var bus = RabbitHutch.CreateBus("host=" + _hostName + ":" + _portNumber + ";username="******";password="******"");
bus = RabbitHutch.CreateBus("host=" + _hostName);
#endregion
bus.Respond <MyRequest, MyResponse>(_request => new MyResponse {
Text = "Server responding to " + _request.Text
});
//bus.RespondAsync<MyRequest, MyResponse>(request =>
// Task.Factory.StartNew(() =>
// {
// Response(request)
// }
//);
}
private void Connect()
{
if (IsConnected)
{
return;
}
var policy = Policy
.Handle <EasyNetQException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(3, retryAttempt =>
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
policy.Execute(() => {
_bus = RabbitHutch.CreateBus(_connectionString);
Console.WriteLine($"Intentando");
});
}
public void TestQueueWay3()
{
IAdvancedBus bus = RabbitHutch.CreateBus(ConfigurationAppSetting.RabbitMQHost, reg => reg.Register <IEasyNetQLogger>(log => new Log4NetLogger())).Advanced;
IExchange ex = bus.ExchangeDeclare("JinRi.Notify.Test.TestQueueWay3Ex", "direct");
IQueue qu1 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay3Queue1");
IQueue qu2 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay3Queue2");
IQueue qu3 = bus.QueueDeclare("JinRi.Notify.Test.TestQueueWay3Queue3");
IBinding bi1 = bus.Bind(ex, qu1, "0");
IBinding bi2 = bus.Bind(ex, qu2, "1");
IBinding bi3 = bus.Bind(ex, qu3, "2");
for (int i = 0; i < 100; i++)
{
int md = i % 3;
bus.Publish <string>(ex, md.ToString(), false, false, new Message <string>(i.ToString()));
}
Thread.Sleep(5000);
}
private void TryConnect()
{
if (IsConnected)
{
return;
}
var policy = Policy.Handle <EasyNetQException>()
.Or <BrokerUnreachableException>()
.WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
policy.Execute(() =>
{
_bus = RabbitHutch.CreateBus(connectionString: _connectionString);
_advancedBus = _bus.Advanced;
_advancedBus.Disconnected += OnDisconnect;
});
}
public ActionResult AddNewOrder([FromBody] DTOs.Order newOrder)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var orderId = Guid.NewGuid();
newOrder.Id = orderId;
newOrder.Created = DateTime.UtcNow;
try
{
Datastore.TryAdd(orderId, newOrder);
}
catch (Exception e)
{
string message = "We could not add the new order.";
Log.Error(message + $" Reason: {0}", e);
throw new OrderServiceException(message);
}
// TODO: Retry & exception handling
using (var bus = RabbitHutch.CreateBus(_settings.RabbitMqConnectionString))
{
var identity = User.Identity as ClaimsIdentity;
var subjectId = identity?.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
var message = new NewOrderMessage
{
UserId = subjectId,
Order = Mapper.Map <Order>(newOrder)
};
// TODO: Exception handling
bus.Publish(message);
_orderHubContext.Clients.Group(message.UserId).SendAsync("orderCreated");
}
return(Ok());
}
static void Main(string[] args)
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
//.AddJsonFile($"appsettings.{env.EnvironmentName}.json", true, true);
Configuration = builder.Build();
var services = new ServiceCollection();
services.AddSingleton <IConfigurationRoot>(Configuration);
services.AddSingleton(new LoggerFactory()
.AddConsole()
.AddDebug());
services.AddLogging();
// app settings
services.Configure <AppSettings>(Configuration.GetSection("AppSettings"));
var provider = services.BuildServiceProvider();
var connection = new ConnectionConfiguration();
connection.Port = 5672;
connection.UserName = "******";
connection.Password = "******";
connection.Hosts = new List <HostConfiguration> {
new HostConfiguration()
{
Host = @"rabbitmq", Port = 5672
}
};
connection.ConnectIntervalAttempt = TimeSpan.FromSeconds(4);
connection.RequestedHeartbeat = 6;
connection.Timeout = 60;
var _bus = RabbitHutch.CreateBus(connection, ser => ser.Register <IEasyNetQLogger>(logger => new DoNothingLogger()));
var subscriber = new AutoSubscriber(_bus, "#");
subscriber.Subscribe(Assembly.GetExecutingAssembly());
Console.WriteLine("Notifications EventHandler Listening");
string typed = Console.ReadLine();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
string connectionRabbitMQ = Configuration.GetConnectionString("Config");
services.AddSingleton(RabbitHutch.CreateBus(connectionRabbitMQ).Advanced);
services.AddScoped <IPublisher, Publisher.Publisher>();
services.AddTransient <CancelReservationJob>();
services.AddTransient <RemoveReservationJob>();
services.Configure <QuartzOptions>(Configuration.GetSection("Quartz"));
services.AddQuartz(q =>
{
q.UseMicrosoftDependencyInjectionScopedJobFactory();
var jobKey = new JobKey("awesome job", "awesome group");
q.ScheduleJob <CancelReservationJob>(t => t
.WithIdentity("Simple Trigger")
.StartNow()
.WithCronSchedule("* * * * * ?")
.WithDescription("my awesome simple trigger")
);
q.ScheduleJob <RemoveReservationJob>(t => t
.WithIdentity("Simple Trigger")
.StartNow()
.WithCronSchedule("* * * * * ?")
.WithDescription("my awesome simple trigger")
);
});
// Quartz.Extensions.Hosting hosting
services.AddQuartzServer(options =>
{
// when shutting down we want jobs to complete gracefully
options.WaitForJobsToComplete = true;
});
services.AddControllers();
}
public IEnumerable <Author> GetAuthorsSecret()
{
IEnumerable <Author> Authors = _context.Authors;
var Bus = RabbitHutch.CreateBus("host=localhost");
ConcurrentStack <RabbitBookAuthor> BookAuthorCollection = new ConcurrentStack <RabbitBookAuthor>();
Bus.Receive <RabbitBookAuthor>("BookAuthor", msg =>
{
BookAuthorCollection.Push(msg);
});
Thread.Sleep(5000);
foreach (RabbitBookAuthor a in BookAuthorCollection)
{
Author c = new Author()
{
AuthorName = a.AuthorName, AuthorRating = a.AuthorRating
};
_context.Authors.Add(c);
}
_context.SaveChanges();
foreach (RabbitBookAuthor a in BookAuthorCollection)
{
int c_id = 0;
foreach (Author c in _context.Authors)
{
if (a.AuthorName == c.AuthorName)
{
c_id = c.ID;
}
}
Book ar = new Book()
{
BookName = a.BookName, PageCount = a.BookPageCount, AuthorID = c_id
};
_context.Books.Add(ar);
}
_context.SaveChanges();
return(Authors);
}
public static void Main(string[] args)
{
if (args.Length < 1)
{
Console.Error.WriteLine("Usage: {0} [type]", Environment.GetCommandLineArgs()[0]);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadLine();
Environment.ExitCode = 1;
return;
}
try
{
try
{
Console.ForegroundColor = (ConsoleColor)Enum.Parse(typeof(ConsoleColor), args[0], true);
}
catch { }
Console.Error.WriteLine("Consumer listening...");
Console.Error.WriteLine("Type={0}", args[0]);
var rountingKey = args[0];
var advancedBus = RabbitHutch.CreateBus(AppKeys.Get(Constants.RabbitMqConnectionString)).Advanced;
var exchange = advancedBus.ExchangeDeclare(AppKeys.Get(Constants.RabbitMqExchangeName), ExchangeType.Direct);
var queue = advancedBus.QueueDeclare(string.Format("FirstScreen.Queue.{0}", rountingKey));
advancedBus.Bind(exchange, queue, rountingKey);
advancedBus.Consume(queue, (body, properties, info) => Task.Factory.StartNew(() =>
{
var message = Encoding.UTF8.GetString(body);
Console.WriteLine("{0}", message);
}));
}
catch (Exception ex)
{
Console.WriteLine("Error...");
Console.WriteLine(ex.Message);
Console.WriteLine(" Press [enter] to exit.");
Console.ReadKey();
Environment.ExitCode = 1;
return;
}
}
static void TestSSL()
{
var connection = new ConnectionConfiguration();
connection.Port = 5673;
connection.UserName = "******";
connection.Password = "******";
connection.Product = "SSLTest";
var host1 = new HostConfiguration();
host1.Host = "192.168.0.169";
host1.Port = 5673;
host1.Ssl.Enabled = true;
host1.Ssl.ServerName = "www.shiyx.top";
host1.Ssl.CertPath = @"E:\git\RabbitMqDemo\server.pfx";
host1.Ssl.CertPassphrase = "123123";
host1.Ssl.AcceptablePolicyErrors = SslPolicyErrors.RemoteCertificateNameMismatch |
SslPolicyErrors.RemoteCertificateChainErrors;
//var host2 = new HostConfiguration();
//host2.Host = "192.168.0.115";
//host2.Port = 5673;
//host2.Ssl.Enabled = true;
//host2.Ssl.ServerName = "www.shiyx.top";
//host2.Ssl.CertPath = @"E:\git\RabbitMqDemo\server.pfx";
//host2.Ssl.CertPassphrase = "123123";
connection.Hosts = new List <HostConfiguration> {
host1
};
connection.Validate();
var bus = RabbitHutch.CreateBus(connection, services => services.Register <ILogProvider>(ConsoleLogProvider.Instance));
var message = new TextMessage {
MessageRouter = "api.notice.zhangsan", MessageBody = "Hello Rabbit"
};
bus.Publish(message, x => x.WithTopic(message.MessageRouter));
Console.WriteLine("发送成功");
}
public IEnumerable <City> GetCitiesSecret()
{
IEnumerable <City> cities = _context.Cities;
var Bus = RabbitHutch.CreateBus("host=localhost");
ConcurrentStack <RabbitArenaCity> arenacityCollection = new ConcurrentStack <RabbitArenaCity>();
Bus.Receive <RabbitArenaCity>("arenacity", msg =>
{
arenacityCollection.Push(msg);
});
Thread.Sleep(5000);
foreach (RabbitArenaCity a in arenacityCollection)
{
City c = new City()
{
CityName = a.CityName, CityPopulation = a.CityPopulation
};
_context.Cities.Add(c);
}
_context.SaveChanges();
foreach (RabbitArenaCity a in arenacityCollection)
{
int c_id = 0;
foreach (City c in _context.Cities)
{
if (a.CityName == c.CityName)
{
c_id = c.ID;
}
}
Arena ar = new Arena()
{
ArenaName = a.ArenaName, Capacity = a.ArenaCapacity, CityID = c_id
};
_context.Arenas.Add(ar);
}
_context.SaveChanges();
return(cities);
}
public static async Task Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Information()
.WriteTo.Console()
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
try
{
var builder = new HostBuilder()
.ConfigureHostConfiguration(configHost =>
{
configHost.AddEnvironmentVariables();
configHost.AddCommandLine(args);
})
.ConfigureAppConfiguration((hostingContext, config) =>
{
config.AddJsonFile($"appsettings.json");
config.AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true);
})
.ConfigureServices((hostContext, services) =>
{
services.AddSingleton <IBus>(f => RabbitHutch.CreateBus(hostContext.Configuration.GetSection("RabbitMQ")["Host"]));
services.AddSingleton(new MongoClient(hostContext.Configuration.GetSection("MongoDB")["Host"]));
services.AddSingleton <IHostedService, CheckNewScheduleBackgroundService>();
services.AddSingleton <IMonthHelpers, MonthHelpers>();
})
.ConfigureLogging((hostContext, logging) =>
{
logging.AddSerilog();
})
.Build();
await builder.RunAsync();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host CheckNewSchedule terminated unexpectedly.");
}
finally
{
Log.CloseAndFlush();
}
}
public async Task <IActionResult> Create(CategoryGroups categoryGroups)
{
// Check the State Model Binding
if (ModelState.IsValid)
{
// Strings für TypeOfCategoryGroup schreiben
if (categoryGroups.TypeOfCategoryGroup.Equals("0"))
{
categoryGroups.TypeOfCategoryGroup = "Product";
}
else
{
categoryGroups.TypeOfCategoryGroup = "Service";
}
_colibriDbContext.Add(categoryGroups);
await _colibriDbContext.SaveChangesAsync();
// Publish the Created Category
using (var bus = RabbitHutch.CreateBus("host=localhost"))
{
//bus.Publish(categoryGroups, "create_category_groups");
//await bus.PublishAsync("create_category_groups").ContinueWith(task =>
// {
// if (task.IsCompleted && !task.IsFaulted)
// {
// Console.WriteLine("Task Completed");
// Console.ReadLine();
// }
// });
await bus.SendAsync("create_category_groups", categoryGroups);
}
// avoid Refreshing the POST Operation -> Redirect
return(RedirectToAction(nameof(Index)));
//return RedirectToAction("Index", "CategoryGroups", new { area = "Admin" });
}
else
{
// one can simply return to the Form View again for Correction
return(View(categoryGroups));
}
}
static async Task Main(string[] args)
{
Console.WriteLine("Starting");
var RabbitMqUserName = "******";
var RabbitMqPassword = "******";
using (var bus = RabbitHutch.CreateBus($"host=rabbitmq;username={RabbitMqUserName};password={RabbitMqPassword}"))
{
int I = 1;
while (true)
{
var PubSubMsg = new PubSubMessage($"Pub/Sub message {I}");
var QueueMsg = new QueueMessage($"Queue message {I}");
try
{
bus.PubSub.Publish(PubSubMsg);
Console.WriteLine($"Published message: '{PubSubMsg.Text}'");
}
catch
{
Console.WriteLine($"Erro publishing message: '{PubSubMsg.Text}'");
}
try
{
bus.PubSub.Publish(QueueMsg);
Console.WriteLine($"Published message: '{QueueMsg.Text}'");
}
catch
{
Console.WriteLine($"Erro publishing message: '{QueueMsg.Text}'");
}
await Task.Delay(500);
I++;
}
}
}
public static async Task Main(string[] args)
{
Configuration = await GetInitializedConfig();
Log.Logger = await InitializeLogs();
Log.Information("Logs inicializados...");
Log.Information("Inicializando App");
// var bus = RabbitHutch.CreateBus($"host={Configuration["RABBIT:HOST"]}", services => services.Register(c => new MyConventions()));
var bus = RabbitHutch.CreateBus($"host={Configuration["RABBIT:HOST"]}");
bus.Advanced.Container.Resolve <IConventions>().ErrorQueueNamingConvention = (con) => "MyErrorQueueNaming";
InitializeApp(bus);
Console.Read();
}
private ItemResponse ListenToRetailerResponse(string customerID)
{
ItemResponse response = null;
using (var bus = RabbitHutch.CreateBus("host=localhost"))
{
// Declare an exchange:
var exchange = bus.Advanced.ExchangeDeclare("Customers", ExchangeType.Topic);
// Declare a queue
var queue = bus.Advanced.QueueDeclare("Customer" + customerID, false, true, false, true);
// Bind queue to exchange (the routing key is ignored by a fanout exchange):
bus.Advanced.Bind(exchange, queue, customerID);
// Synchronous consumer:
bus.Advanced.Consume <ItemResponse>(queue, (message, info) =>
response = message.Body);
Thread.Sleep(TimeSpan.FromSeconds(1));
}
return(response);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddRouting(options => options.LowercaseUrls = true);
services.AddControllersWithViews();
var db = new InMemoryCarDatabase("JsonData");
services.AddSingleton <ICarDatabase>(db);
var bus = RabbitHutch.CreateBus(AMQP);
services.AddSingleton <IBus>(bus);
services.AddSingleton <AutobarnSchema>();
services
.AddGraphQL(options => options.EnableMetrics = false)
.AddSystemTextJson();
services.AddSignalR();
}
public static void Main(string[] args)
{
IBus bus = RabbitHutch.CreateBus(ConfigurationManager.AppSettings["easynetq"]);
HostFactory.Run(x =>
{
x.Service <FileIndexerService>(s =>
{
s.ConstructUsing(name => new FileIndexerService(bus));
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc => tc.Stop());
});
x.RunAsLocalSystem();
x.SetDescription("Manage files indexing.");
x.SetDisplayName("FileIndexer");
x.SetServiceName("FileIndexer");
});
}
protected override void ConfigureServices(
IServiceCollection serviceCollection)
{
// Add singleton of IBus for EasyNetQ.
serviceCollection.AddSingleton <IBus>(
RabbitHutch.CreateBus($"host={this.configuration["RabbitMQ:Host"]}"));
// Dictionary for contianing broadcast for local order request.
serviceCollection.AddSingleton <IDictionary <string,
Retailer.Messages.OrderRequest> >(new Dictionary <string, Retailer.Messages.OrderRequest>());
// Dictionary for containing broadcast order request to all warehouses.
serviceCollection
.AddSingleton <IDictionary <string,
Aggregate <Retailer.Messages.OrderRequest, Warehouse.Messages.OrderResponse> > >(new Dictionary <string,
Aggregate <Retailer.Messages.OrderRequest, Warehouse.Messages.OrderResponse> >());
serviceCollection.AddMediatR(typeof(RetailerClient));
}
//conectar no rabbitHuct
private void TryConnect()
{
if (IsConnected)
{
return;
}
var policy = Policy.Handle <EasyNetQException>()
.Or <BrokerUnreachableException>() //não ta disponivel a conexão
.WaitAndRetry(3, retryAttempt => // tentar 3 tentivasas
TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
policy.Execute(() =>
{
_bus = RabbitHutch.CreateBus(_connectionString);
_advancedBus = _bus.Advanced; //isso aqui vai instancia
_advancedBus.Disconnected += OnDisconnect; //libera alguns itens, get de fila e etc
});
}