static async Task Main(string[] args)
{
var host = new HostBuilder()
.ConfigureServices((context, services) =>
{
services.Configure <GrpcClientOptions>("grpc", i =>
{
i.Host = "localhost";
i.Port = 50001;
});
services.AddNGrpcClient();
services.AddNClientContract <IService>("grpc");
services.Configure <RabbitMQClientOptions>("mq", i => { i.CopyFrom(Helper.GetMQOptions()); });
services.AddNRabbitMQClient();
services.AddHostedService <H>();
})
.Build();
await host.RunAsync();
Console.WriteLine("end");
Console.Read();
}
private static async Task RunRabbitMQAsync()
{
var host = new HostBuilder()
.ConfigureServices((context, services) =>
{
//set single target by DI.
services.AddNetRpcRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNetRpcGrpcGateway <IService>(o =>
{
o.Host = "localhost";
o.Port = 50001;
});
services.AddNetRpcGrpcGateway <IService2>();
//set different target point.
//var p1 = NetRpcManager.CreateClientProxy<IService>(new Channel("localhost", 50001, ChannelCredentials.Insecure)).Proxy;
//var p2 = NetRpcManager.CreateClientProxy<IService2>(new Channel("localhost2", 50001, ChannelCredentials.Insecure)).Proxy;
//services.AddNetRpcContractSingleton(typeof(IService), p1);
//services.AddNetRpcContractSingleton(typeof(IService2), p2);
})
.Build();
await host.RunAsync();
}
static async Task Main(string[] args)
{
Console.WriteLine("---- MQ test ----");
var mqOptions = Helper.GetMQOptions();
_c1 = NManager.CreateClientProxy <IService>(mqOptions);
_c2 = NManager.CreateClientProxy <IService2>(mqOptions);
await TestAsync();
Console.WriteLine("---- Http test ----");
var httpOptions = new HttpClientOptions {
ApiUrl = "http://localhost:5000", SignalRHubUrl = "http://localhost:5000/callback"
};
_c1 = NetRpc.Http.Client.NManager.CreateClientProxy <IService>(httpOptions);
_c2 = NetRpc.Http.Client.NManager.CreateClientProxy <IService2>(httpOptions);
await TestAsync();
Console.WriteLine("---- Grpc test ----");
GrpcClientOptions grpcOpt = new GrpcClientOptions {
Host = "localhost", Port = 50000
};
_c1 = NetRpc.Grpc.NManager.CreateClientProxy <IService>(grpcOpt);
_c2 = NetRpc.Grpc.NManager.CreateClientProxy <IService2>(grpcOpt);
await TestAsync();
Console.WriteLine("---- end ----");
Console.Read();
}
private static async Task RabbitMQ()
{
//RabbitMQ
Console.WriteLine("\r\n--------------- Client RabbitMQ ---------------");
var services = new ServiceCollection();
services.AddNClientContract <IServiceAsync>();
services.AddNClientContract <IService>();
services.AddNRabbitMQClient(o => o.CopyFrom(Helper.GetMQOptions()));
var sp = services.BuildServiceProvider();
_clientProxy = sp.GetService <IClientProxy <IService> >();
_clientProxy.Connected += (_, _) => Console.WriteLine("[event] Connected");
_clientProxy.DisConnected += (_, _) => Console.WriteLine("[event] DisConnected");
_clientProxy.ExceptionInvoked += (_, _) => Console.WriteLine("[event] ExceptionInvoked");
//Heartbeat
_clientProxy.HeartbeatAsync += (s, e) =>
{
Console.WriteLine("[event] Heartbeat");
((IService)((IClientProxy)s).Proxy).Hearbeat();
return(Task.CompletedTask);
};
//clientProxy.StartHeartbeat(true);
_proxy = _clientProxy.Proxy;
_proxyAsync = sp.GetService <IClientProxy <IServiceAsync> >() !.Proxy;
RunTest();
await RunTestAsync();
}
private static async Task Main(string[] args)
{
ServiceProvider sp;
var services = new ServiceCollection();
services.AddNClientContract <IServiceAsync>();
services.AddNRabbitMQClient(o => o.CopyFrom(Helper.GetMQOptions()));
sp = services.BuildServiceProvider();
var proxy = sp.GetService <IServiceAsync>();
for (var i = 0; i < 10; i++)
{
var i1 = i;
Task.Run(async() =>
{
Console.WriteLine($"Send {i1}");
await proxy.CallAsync(async p => Console.WriteLine(p), i1.ToString());
});
}
//for (int i = 0; i < 10; i++)
//{
// using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
// await proxy.PostAsync(i.ToString(), stream);
// Console.WriteLine($"post {i}");
//}
Console.WriteLine("Send end");
Console.Read();
}
private static async Task Main(string[] args)
{
var h = Host.CreateDefaultBuilder(null)
.ConfigureWebHostDefaults(builder =>
{
builder.ConfigureKestrel((context, options) =>
{
options.ListenAnyIP(5101);
options.ListenAnyIP(50001, listenOptions => listenOptions.Protocols = HttpProtocols.Http2);
})
.ConfigureServices(services =>
{
services.AddCors();
services.AddSignalR();
services.AddNSwagger();
services.AddNHttpService();
services.AddNGrpcService();
services.AddNRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNServiceContract <IService, Service>(ServiceLifetime.Scoped);
services.Configure <GrpcClientOptions>("grpc1", i => { i.Url = "http://localhost:50002"; });
services.Configure <GrpcClientOptions>("grpc2", i => { i.Url = "http://localhost:50003"; });
services.AddNGrpcClient(null, null, ServiceLifetime.Scoped);
services.Configure <ServiceSwaggerOptions>(i => i.HostPath = "http://localhost:5101/swagger");
services.Configure <ClientSwaggerOptions>("grpc1", i => i.HostPath = "http://localhost:5102/swagger");
services.Configure <ClientSwaggerOptions>("grpc2", i => i.HostPath = "http://localhost:5103/swagger");
services.AddNJaeger(i =>
{
i.Host = "m.k8s.yx.com";
i.Port = 36831;
i.ServiceName = "Service";
}, i => { i.LogActionInfoMaxLength = 1000; });
})
.Configure(app =>
{
app.UseCors(set =>
{
set.SetIsOriginAllowed(origin => true)
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials();
});
app.UseRouting();
app.UseEndpoints(endpoints => { endpoints.MapHub <CallbackHub>("/callback"); });
app.UseNSwagger();
app.UseNHttp();
app.UseNGrpc();
})
.ConfigureLogging(logging => { logging.AddConsole(); });
}).Build();
await h.RunAsync();
}
static async Task Main(string[] args)
{
var host = NManager.CreateHost(Helper.GetMQOptions(),
null,
new ContractParam <IServiceAsync, ServiceAsync>());
Console.WriteLine("Service Opened.");
await host.RunAsync();
Console.Read();
}
static async Task RunAsync()
{
var h = new HostBuilder()
.ConfigureServices((context, services) =>
{
services.AddNRabbitMQService(i => { i.CopyFrom(Helper.GetMQOptions()); });
services.AddNGrpcService(i => i.AddPort("0.0.0.0", 50001));
services.AddNServiceContract <IService, Service>();
})
.Build();
await h.RunAsync();
}
private static async Task Main(string[] args)
{
var mpHost = new HostBuilder()
.ConfigureServices((_, services) =>
{
services.AddNRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNServiceContract <IServiceAsync, ServiceAsync>();
})
.Build();
Console.WriteLine("Service Opened.");
await mpHost.RunAsync();
}
private static async Task RabbitMQ()
{
//RabbitMQ
Console.WriteLine("\r\n--------------- Client RabbitMQ ---------------");
var services = new ServiceCollection();
services.AddNClientContract <IServiceAsync>();
services.AddNClientContract <IService2Async>();
services.AddNRabbitMQClient(o => o.CopyFrom(Helper.GetMQOptions()));
var sp = services.BuildServiceProvider();
_c1 = sp.GetService <IClientProxy <IServiceAsync> >();
_c2 = sp.GetService <IClientProxy <IService2Async> >();
await TestAsync();
}
private static async Task Main(string[] args)
{
var h = new HostBuilder()
.ConfigureServices((context, services) =>
{
services.AddOptions();
services.AddHostedService <MyHost>();
services.Configure <RabbitMQClientOptions>("mq", i => i.CopyFrom(Helper.GetMQOptions()));
services.Configure <GrpcClientOptions>("grpc", i => { i.Url = "http://localhost:50001"; });
services.AddNRabbitMQClient();
services.AddNGrpcClient();
})
.ConfigureLogging((context, builder) => { builder.AddConsole(); })
.Build();
await h.RunAsync();
}
static async Task Main(string[] args)
{
//rabbitMq
var mOpt = new MiddlewareOptions();
mOpt.UseMiddleware <TestGlobalExceptionMiddleware>();
var mqHost = NetRpcManager.CreateHost(Helper.GetMQOptions(),
mOpt, new Contract <IService, Service>(), new Contract <IServiceAsync, ServiceAsync>());
mqHost.RunAsync();
//grpc
var grpcHost = NetRpc.Grpc.NetRpcManager.CreateHost(Helper.GetGrpcServiceOptions(),
null, new Contract <IService, Service>(), new Contract <IServiceAsync, ServiceAsync>());
grpcHost.RunAsync();
Console.Read();
}
static async Task Main(string[] args)
{
//RabbitMQ
Console.WriteLine("--- Client RabbitMQ ---");
var mqF = new RabbitMQClientConnectionFactoryOptions(Helper.GetMQOptions(), NullLoggerFactory.Instance);
_clientProxy = NManager.CreateClientProxy <IService>(mqF);
_clientProxy.Connected += (s, e) => Console.WriteLine("[event] Connected");
_clientProxy.DisConnected += (s, e) => Console.WriteLine("[event] DisConnected");
_clientProxy.ExceptionInvoked += (s, e) => Console.WriteLine("[event] ExceptionInvoked");
//Heartbeat
_clientProxy.HeartbeatAsync += (s, e) =>
{
Console.WriteLine("[event] Heartbeat");
((IService)((IClientProxy)s).Proxy).Hearbeat();
return(Task.CompletedTask);
};
//clientProxy.StartHeartbeat(true);
_proxy = _clientProxy.Proxy;
_proxyAsync = NManager.CreateClientProxy <IServiceAsync>(mqF).Proxy;
RunTest();
await RunTestAsync();
//Grpc
Console.WriteLine("\r\n--- Client Grpc ---");
var grpcF = new GrpcClientConnectionFactoryOptions(
new GrpcClientOptions {
Host = "localhost", Port = 50001
});
_clientProxy = NetRpc.Grpc.NManager.CreateClientProxy <IService>(grpcF);
_proxy = _clientProxy.Proxy;
_proxyAsync = NetRpc.Grpc.NManager.CreateClientProxy <IServiceAsync>(grpcF).Proxy;
RunTest();
await RunTestAsync();
Console.WriteLine("Test end.");
Console.Read();
}
static async Task Main(string[] args)
{
var proxy = NManager.CreateClientProxy <IServiceAsync>(Helper.GetMQOptions()).Proxy;
for (var i = 0; i < 10; i++)
{
var i1 = i;
Task.Run(async() =>
{
Console.WriteLine($"Send {i1}");
await proxy.CallAsync(async p => Console.WriteLine(p), i1.ToString());
});
}
//for (int i = 0; i < 10; i++)
//{
// using (var stream = File.Open(Helper.GetTestFilePath(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
// await proxy.PostAsync(i.ToString(), stream);
// Console.WriteLine($"post {i}");
//}
Console.WriteLine("Send end");
Console.Read();
}
private static async Task Main(string[] args)
{
//rabbitMQ
var mpHost = new HostBuilder()
.ConfigureServices((_, services) =>
{
services.AddNRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNServiceContract <IServiceAsync, ServiceAsync>();
services.AddNServiceContract <IService, Service>();
})
.Build();
mpHost.RunAsync();
//grpc
var grpcHost = Host.CreateDefaultBuilder()
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.ConfigureKestrel((_, options) =>
{
options.ListenAnyIP(50001, listenOptions => listenOptions.Protocols = HttpProtocols.Http2);
})
.ConfigureServices((_, services) =>
{
services.AddNGrpcService();
services.AddNServiceContract <IServiceAsync, ServiceAsync>();
services.AddNServiceContract <IService, Service>();
}).Configure(app => { app.UseNGrpc(); });
}).Build();
grpcHost.RunAsync();
//http
var httpHost = Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(builder =>
{
builder.ConfigureKestrel((_, options) =>
{
options.Limits.MaxRequestBodySize = 10737418240; //10G
options.ListenAnyIP(50002);
})
.ConfigureServices(services =>
{
services.AddCors();
services.AddSignalR();
services.AddNHttpService();
services.AddNServiceContract <IServiceAsync, ServiceAsync>();
services.AddNServiceContract <IService, Service>();
})
.Configure(app =>
{
app.UseCors(set =>
{
set.SetIsOriginAllowed(_ => true)
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials();
});
app.UseRouting();
app.UseEndpoints(endpoints => { endpoints.MapHub <CallbackHub>("/callback"); });
app.UseNHttp();
});
}).Build();
httpHost.RunAsync();
Console.Read();
}
static async Task Main(string[] args)
{
var h = WebHost.CreateDefaultBuilder(null)
//.UseDefaultServiceProvider(i =>i.ValidateScopes = false)
.ConfigureKestrel(options => { options.ListenAnyIP(5001); })
.ConfigureServices(services =>
{
services.AddCors();
services.AddSignalR();
services.AddNetRpcSwagger();
services.AddNetRpcHttpService();
services.AddNetRpcRabbitMQService(i => i.CopyFrom(Helper.GetMQOptions()));
services.AddNetRpcServiceContract <IService, Service>(ServiceLifetime.Scoped);
services.Configure <GrpcClientOptions>("grpc1", i =>
{
i.Host = "localhost";
i.Port = 50002;
});
services.Configure <GrpcClientOptions>("grpc2", i =>
{
i.Host = "localhost";
i.Port = 50003;
});
services.AddNetRpcGrpcClient(null, null, ServiceLifetime.Scoped);
services.Configure <ServiceSwaggerOptions>(i => i.HostPath = "http://localhost:5001/swagger");
services.Configure <ClientSwaggerOptions>("grpc1", i => i.HostPath = "http://localhost:5002/swagger");
services.Configure <ClientSwaggerOptions>("grpc2", i => i.HostPath = "http://localhost:5003/swagger");
services.AddNetRpcJaeger(i =>
{
i.Host = "jaeger.yx.com";
i.Port = 6831;
i.ServiceName = "Service";
}, i =>
{
i.LogActionInfoMaxLength = 1000;
});
})
.Configure(app =>
{
app.UseCors(set =>
{
set.SetIsOriginAllowed(origin => true)
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials();
});
app.UseSignalR(routes => { routes.MapHub <CallbackHub>("/callback"); });
app.UseNetRpcSwagger();
app.UseNetRpcHttp();
})
.ConfigureLogging(logging =>
{
logging.AddConsole();
})
.Build();
await h.RunAsync();
}
