public static void ServiceLocatorTest()
{
IServiceLocator locator = new ServiceLocator();
// only know about the interface
IServiceA myServiceA = locator.GetService <IServiceA>();
}
public UserBLL([DIPParameterShortName("mysql")] IUserDAL iuserDAL, IServiceA serviceA, [DIPParameterConstant] string name, [DIPParameterConstant] int value)
{
_iuserDAL = iuserDAL;
_serviceA = serviceA;
Name = name;
Value = value;
}
public IServiceB myServiceB(IServiceA svcA, [Inject("svcC")] IServiceC c)
{
Assert.IsNotNull(svcA);
Assert.IsNotNull(c);
return(obj);
}
private static void CustomFactories()
{
Console.WriteLine(nameof(CustomFactories));
IServiceB CreateServiceBFactory(IServiceProvider provider) =>
new ServiceB(provider.GetService <INumberService>());
ServiceProvider RegisterServices()
{
var numberService = new NumberService();
var services = new ServiceCollection();
services.AddSingleton <INumberService>(numberService); // add existing
services.AddTransient <IServiceB>(CreateServiceBFactory); // use a factory
services.AddSingleton <IServiceA, ServiceA>();
return(services.BuildServiceProvider());
}
using (ServiceProvider container = RegisterServices())
{
IServiceA a1 = container.GetService <IServiceA>();
IServiceA a2 = container.GetService <IServiceA>();
IServiceB b1 = container.GetService <IServiceB>();
IServiceB b2 = container.GetService <IServiceB>();
}
Console.WriteLine();
}
static void Main(string[] args)
{
// Strong Type Service Locator
ILoggingService loggingService = ServiceLocator.SetLocation(new LoggingService());
loggingService.ExecuteService();
ICalculationService calculationService = ServiceLocator.SetLocation(new CalculationService());
var array = new int[] { 14, 45, 43, 43, 3, 4, 1, 98, 39 };
var sum = calculationService.CalculateSumOfArray(array);
System.Console.WriteLine($"Sum: {sum}");
var str = "Hello this is Service Locator Disign Pattern example";
var reversedStr = calculationService.ReverseString(str);
System.Console.WriteLine($"Reversed string: {reversedStr}");
System.Console.WriteLine();
System.Console.WriteLine("----------------------------------------------------");
System.Console.WriteLine();
// Generic Type Service Locator
GenericServiceLocator genericServiceLocator = new GenericServiceLocator();
IServiceA aService = genericServiceLocator.GetService <IServiceA>();
aService.Execute();
IServiceB bService = genericServiceLocator.GetService <IServiceB>();
bService.Execute();
}
public Program(IServiceA serviceA, IServiceB serviceB, ICommonService commonService, ExecutionState state)
{
_serviceA = serviceA;
_serviceB = serviceB;
_state = state;
_state.ExecutionService = serviceA.CommonService;
}
public ControllerX(IServiceA serviceA, IServiceB serviceB, INumberService numberService)
{
_n = numberService.GetNumber();
Console.WriteLine($"ctor {nameof(ControllerX)}, {_n}");
_serviceA = serviceA;
_serviceB = serviceB;
}
private static void CustomerFactories()
{
Console.WriteLine(nameof(CustomerFactories));
IServiceB CreateServiceBFactory(IServiceProvider provider) =>
new ServiceB(provider.GetService <INumberService>());
ServiceProvider RegisterServices()
{
var numberService = new NumberService();
var services = new ServiceCollection();
//使用AddSingleton的重载版本，把一个已存在的实例传递给容器
//这种方式容器不会调用Dispose方法，需要手动调用
services.AddSingleton <INumberService>(numberService);
//不是从容器创建，而是使用工厂方法创建
//如果需要自定义的初始化或定义不受DI容器支持的构造函数，这是一个有用的选项
//通过IServiceProvider参数传递委托，并返回服务实例给AddTransient
services.AddTransient <IServiceB>(CreateServiceBFactory);
services.AddSingleton <IServiceA, ServiceA>();
return(services.BuildServiceProvider());
}
using (ServiceProvider container = RegisterServices())
{
IServiceA a1 = container.GetService <IServiceA>();
IServiceA a2 = container.GetService <IServiceA>();
IServiceB b1 = container.GetService <IServiceB>();
IServiceB b2 = container.GetService <IServiceB>();
}
Console.WriteLine();
}
public ServiceConsumer(
IServiceA serviceA,
IServiceB serviceB)
{
this.serviceA = serviceA;
this.serviceB = serviceB;
}
public HomeController(ILogger <HomeController> logger, IComponentContext componentContext)
{
_logger = logger;
_componentContext = componentContext;
_serviceA = _componentContext.ResolveNamed <IServiceA>("ServiceA");
_serviceUpdate = _componentContext.ResolveNamed <IServiceA>("ServiceUpdate");
}
public ServicesViewModel(BaseServices baseServices, IServiceA serviceA, IServiceB serviceB, IServiceC serviceC, IServiceD serviceD)
: base(baseServices)
{
ServiceAId = serviceA.Id;
ServiceBId = serviceB.Id;
ServiceCId = serviceC.Id;
ServiceDId = serviceD.Id;
}
public void GetServiceA()
{
var app = new AppSetup().Start(new APlusBAppModule());
var container = app.GetAppContainer <IComponentContainer>();
IServiceA serviceA = container.CreateComponent <IServiceA>();
Assert.IsInstanceOfType(serviceA, typeof(ServiceA));
}
public ClassA(IServiceA serviceA, IServiceB serviceB, SomeUnityComponent component)
{
this.serviceA = serviceA;
this.serviceB = serviceB;
this.component = component;
this.serviceAProperty = ServiceA.GoodLocalDefault;
}
public static IServiceA Connect(Object callbackObject)
{
string remoteAddress = GetAddress();
DuplexChannelFactory <IServiceA> pipeFactory = null;
NetNamedPipeBinding binding = ConnectionFactory.GetBinding();
serverMutex.WaitOne();
try
{
try
{
Console.WriteLine("Connecting to ServiceA @ " + remoteAddress);
pipeFactory = new DuplexChannelFactory <IServiceA>(
callbackObject,
binding,
new EndpointAddress(remoteAddress));
ServiceAConnection = pipeFactory.CreateChannel();
ServiceAConnection.RegisterClient();
}
catch (EndpointNotFoundException)
{
try
{
Console.WriteLine("Failed to connect to service. Lets try to start the executeable.");
if (ServerPath.Length == 0)
{
ServerPath = GetServerPath();
}
Process.Start(ServerPath);
Thread.Sleep(2000);
ServiceAConnection = pipeFactory.CreateChannel();
ServiceAConnection.RegisterClient();
}
catch (Exception e)
{
Console.WriteLine("");
}
}
catch (Exception ex)
{
Console.WriteLine("");
}
}
catch { }
finally
{
serverMutex.ReleaseMutex();
}
return(ServiceAConnection);
}
protected override void OnStarted()
{
_logger.LogInformation("OnStarted has been called. {id}", System.Threading.Thread.CurrentThread.ManagedThreadId);
using (var scope = _services.CreateScope())
{
IServiceA serviceA = scope.ServiceProvider.GetRequiredService <IServiceA>();
serviceA.Run();
}
}
private static void UsingScoped()
{
Console.WriteLine(nameof(UsingScoped));
ServiceProvider RegisterServices()
{
IServiceCollection services = new ServiceCollection();
services.AddSingleton <INumberService, NumberService>();
services.AddTransient <ControllerX>();
services.AddSingleton <IServiceB, ServiceB>();
services.AddScoped <IServiceA, ServiceA>();
services.AddTransient <IServiceC, ServiceC>();
return(services.BuildServiceProvider());
}
using (ServiceProvider container = RegisterServices())
{
using (IServiceScope scope1 = container.CreateScope())
{
IServiceA a1 = scope1.ServiceProvider.GetRequiredService <IServiceA>();
a1.A();
IServiceA a2 = scope1.ServiceProvider.GetRequiredService <IServiceA>();
a2.A();
IServiceB b1 = scope1.ServiceProvider.GetRequiredService <IServiceB>();
b1.B();
IServiceB b2 = scope1.ServiceProvider.GetRequiredService <IServiceB>();
b2.B();
IServiceC c1 = scope1.ServiceProvider.GetRequiredService <IServiceC>();
c1.C();
IServiceC c2 = scope1.ServiceProvider.GetRequiredService <IServiceC>();
c2.C();
}
Console.WriteLine("end of scope 1");
using (IServiceScope scope2 = container.CreateScope())
{
IServiceA a1 = scope2.ServiceProvider.GetRequiredService <IServiceA>();
a1.A();
IServiceA a2 = scope2.ServiceProvider.GetRequiredService <IServiceA>();
a2.A();
IServiceB b1 = scope2.ServiceProvider.GetRequiredService <IServiceB>();
b1.B();
IServiceB b2 = scope2.ServiceProvider.GetRequiredService <IServiceB>();
b2.B();
IServiceC c1 = scope2.ServiceProvider.GetRequiredService <IServiceC>();
c1.C();
IServiceC c2 = scope2.ServiceProvider.GetRequiredService <IServiceC>();
c2.C();
}
Console.WriteLine("end of scope 2");
}
}
static void Main()
{
IServiceLocator serviceLocator = new ServiceLocator();
IServiceA serviceA = serviceLocator.GetService <IServiceA>();
IServiceB serviceB = serviceLocator.GetService <IServiceB>();
IServiceC serviceC = serviceLocator.GetService <IServiceC>();
// Задержка.
Console.ReadKey();
}
public DefaultController(
IServiceA serviceA,
IBaseClient baseClient,
IEntypeRepository entypeRepository,
IAreaRepository areaRepository
)
{
_serviceA = serviceA;
_client = baseClient;
_entype = entypeRepository;
_area = areaRepository;
}
public void TestContainer()
{
object controller = _container["HomeController"];
Assert.IsTrue(controller.GetType() == typeof(HomeController));
controller = _container["AccountController"];
Assert.IsTrue(controller.GetType() == typeof(AccountController));
IServiceA serviceA = _container[typeof(IServiceA)] as IServiceA;
serviceA.MyMethodNotcached("Gilles");
}
public IActionResult Index2()
{
IServiceA serviceA = DependencyResolver.Current.GetService <IServiceA>();
IServiceB serviceB = DependencyResolver.Current.GetService <IServiceB>();
IServiceC serviceC = DependencyResolver.Current.GetService <IServiceC>();
ViewBag.ServiceA = serviceA.Run();
ViewBag.ServiceB = serviceB.Run();
ViewBag.ServiceC = serviceC.Run();
return(View("Index"));
}
public void TestCacheViaCode()
{
IServiceA serviceA = _container[typeof(IServiceA)] as IServiceA;
serviceA.MyMethod(2, 5.5M);
string consoleContents = _outWriter.GetStringBuilder().ToString();
serviceA.MyMethodNotcached("Gilles");
serviceA.MyMethod(2, 5.5M);
Assert.AreEqual(consoleContents, _outWriter.GetStringBuilder().ToString());
}
static void Main(string[] args)
{
ServiceLocator loc = new ServiceLocator();
IServiceA Aservice = loc.GetService <IServiceA>();
Aservice.Execute();
IServiceB Bservice = loc.GetService <IServiceB>();
Bservice.Execute();
Console.ReadLine();
}
private static void UsingScoped()
{
Console.WriteLine(nameof(UsingScoped));
ServiceProvider RegisterServices()
{
var services = new ServiceCollection();
services.AddSingleton <INumberService, NumberService>();
services.AddScoped <IServiceA, ServiceA>();
services.AddSingleton <IServiceB, ServiceB>();
services.AddTransient <IServiceC, ServiceC>();
return(services.BuildServiceProvider());
}
using (ServiceProvider container = RegisterServices())
{
//调用ServiceProvider的CreateScope()方法创建一个作用域
//返回实现接口IServiceScope的作用域对象，在其中可以访问属于这个作用域的ServiceProvider
using (IServiceScope scope1 = container.CreateScope())
{
//因为IServiceA注册为Scoped，所以在同一作用域下返回的实例时一样的
IServiceA a1 = scope1.ServiceProvider.GetService <IServiceA>();
a1.A(); //A, 1
IServiceA a2 = scope1.ServiceProvider.GetService <IServiceA>();
a2.A(); //A, 1
//scope末尾不会释放IServiceB因为IServiceB是注册为单例，需要在作用域的末尾也是存活的，在程序结束时才会释放
IServiceB b1 = scope1.ServiceProvider.GetService <IServiceB>();
b1.B();
IServiceC c1 = scope1.ServiceProvider.GetService <IServiceC>();
c1.C();
IServiceC c2 = scope1.ServiceProvider.GetService <IServiceC>();
c2.C();
}
Console.WriteLine("end of scope1");
using (IServiceScope scope2 = container.CreateScope())
{
IServiceA a3 = scope2.ServiceProvider.GetService <IServiceA>();
a3.A();
IServiceB b2 = scope2.ServiceProvider.GetService <IServiceB>();
b2.B();
IServiceC c3 = scope2.ServiceProvider.GetService <IServiceC>();
c3.C();
}
Console.WriteLine("end of scope2");
}
Console.WriteLine();
}
public ServiceCImpl(IServiceA serviceA, IServiceB serviceB)
{
if (serviceA == null)
{
throw new ArgumentNullException(nameof(serviceA));
}
if (serviceB == null)
{
throw new ArgumentNullException(nameof(serviceB));
}
_serviceA = serviceA;
_serviceB = serviceB;
}
public void Register_RegistersFunc()
{
Setup.CreateContainer();
Setup.Registry.Register <IServiceA, ServiceA>();
var factory = Setup.Container.Resolve <Func <IServiceA> >();
IServiceA service = null;
Assert.NotNull(factory);
var ex = Record.Exception(() => service = factory());
Assert.Null(ex);
Assert.NotNull(service);
Assert.IsType <ServiceA>(service);
Assert.NotSame(service, factory());
}
public void RegisterSingleton_RegistersLazy()
{
Setup.CreateContainer();
Setup.Registry.RegisterSingleton <IServiceA, ServiceA>();
var factory = Setup.Container.Resolve <Lazy <IServiceA> >();
IServiceA service = null;
Assert.NotNull(factory);
var ex = Record.Exception(() => service = factory.Value);
Assert.Null(ex);
Assert.NotNull(service);
Assert.IsType <ServiceA>(service);
Assert.Same(service, Setup.Container.Resolve <Lazy <IServiceA> >().Value);
}
public void TestFicoCache()
{
IServiceA serviceA = _container[typeof(IServiceA)] as IServiceA;
IServiceC serviceC = _container[typeof(IServiceC)] as IServiceC;
serviceA.MyMethod(2, 5.5M);
string consoleContents = _outWriter.GetStringBuilder().ToString();
serviceC.MyMethod(2, 5.5M);
ResetConsoleOut();
WaitOneMillisecond();
serviceA.MyMethod(2, 5.5M);
Assert.IsFalse(consoleContents == _outWriter.GetStringBuilder().ToString());
}
public Form1()
{
InitializeComponent();
ChannelFactory <IServiceA> factoryA = new ChannelFactory <IServiceA>("");
m_proxyA = factoryA.CreateChannel();
ChannelFactory <IAdmin> factoryAAdmin = new ChannelFactory <IAdmin>("TCP_IAdmin");
m_proxyAdminA = factoryAAdmin.CreateChannel();
ChannelFactory <IServiceB> factoryB = new ChannelFactory <IServiceB>("");
m_proxyB = factoryB.CreateChannel();
ChannelFactory <IAdmin> factoryBAdmin = new ChannelFactory <IAdmin>("IPC_IAdmin");
m_proxyAdminB = factoryBAdmin.CreateChannel();
}
static void Main(string[] args)
{
using (ServiceProvider container = RegisterServices())
{
for (int i = 0; i < 3; i++)
{
using (IServiceScope scope1 = container.CreateScope())
{
IServiceA a1 = scope1.ServiceProvider.GetService <IServiceA>();
a1.A();
IServiceA a2 = scope1.ServiceProvider.GetService <IServiceA>();
a2.A();
IServiceB b1 = scope1.ServiceProvider.GetService <IServiceB>();
b1.B();
}
Console.WriteLine($"End of scope {i}");
}
}
Console.Read();
}
protected AbstractTestComponent(IServiceA serviceA, IServiceB serviceB)
{
_serviceA = serviceA;
_serviceB = serviceB;
}
public ServiceB(IServiceA serviceA, ServiceC serviceC)
{
ServiceA = serviceA;
ServiceC = serviceC;
}
private void CreacteProxy()
{
//IServiceA和IServiceB对应的终结点只有1个，无需通过终结点的名称来区分
//**务必注意，这里ChannelFactory<TChannel>泛型类的构造函数必须填写参数;否则之后创建信道的时候，会提示地址不存在
ChannelFactory<IServiceA> factoryA = new ChannelFactory<IServiceA>(string.Empty);
ChannelFactory<IServiceB> factoryB = new ChannelFactory<IServiceB>(string.Empty);
//IAdmin有2个终结点，所以需要通过终结点的名字来区分
ChannelFactory<IAdmin> adminFactoryA = new ChannelFactory<IAdmin>("TCP_IAdmin");
ChannelFactory<IAdmin> adminFactoryB = new ChannelFactory<IAdmin>("IPC_IAdmin");
proxyA = factoryA.CreateChannel();
adminProxyA = adminFactoryA.CreateChannel();
proxyB = factoryB.CreateChannel();
adminProxyB = adminFactoryB.CreateChannel();
}
public TestComponent(IServiceA serviceA, IServiceB serviceB)
{
ServiceA = serviceA;
ServiceB = serviceB;
}
/*----------------------------------------------------------------------------------------*/
public void InjectServices(IServiceA serviceA, IServiceB serviceB)
{
ServiceA = serviceA;
ServiceB = serviceB;
}
public HomeController(IServiceA serviceA, IServiceB serviceB)
{
_serviceA = serviceA;
_serviceB = serviceB;
}
/*----------------------------------------------------------------------------------------*/
public void InjectServiceAndChild(IServiceA serviceA, IMock child)
{
ServiceA = serviceA;
Child = child;
}
public ClassA(IServiceA a, IServiceB b)
{
_serviceA = a;
_serviceB = b;
}
/*----------------------------------------------------------------------------------------*/
public PocoForConstructorAutoWiring(IServiceA serviceA)
{
ServiceA = serviceA;
}
public TestComponent(IServiceA serviceA, IServiceB serviceB)
{
this._serviceA = serviceA;
this._serviceB = serviceB;
}
public InjectionDemo(TextReader input, TextWriter output, IServiceA serviceA, IServiceB serviceB)
{
_serviceA = serviceA;
_serviceB = serviceB;
_output = output;
}
/*----------------------------------------------------------------------------------------*/
public PocoForConstructorAutoWiring(IServiceA serviceA, IServiceB serviceB)
{
ServiceA = serviceA;
ServiceB = serviceB;
}
public ServiceB(IServiceA serviceA, ServiceC serviceC) {
ServiceA = serviceA;
ServiceC = serviceC;
}
