public void ThrowNoConstructorFound()
{
Assert.Throws <NoSuitableConstructorFoundException>(delegate
{
DependencyInjectionService.Resolve <INotRegisteredDependencyService>();
});
}
public void ReturnSameSingletonInstance()
{
var instance1 = DependencyInjectionService.Resolve <ISingletonService>();
var instance2 = DependencyInjectionService.Resolve <ISingletonService>();
Assert.AreEqual(instance1.Guid.ToString(), instance2.Guid.ToString());
}
public void ThrowNotRegistereDependencyException()
{
Assert.Throws <NotRegisteredDependencyException>(delegate
{
DependencyInjectionService.Resolve <INotRegisteredService>();
});
}
public void ReturnDifferentTranscientInstance()
{
var instance1 = DependencyInjectionService.Resolve <ILambdaService>();
var instance2 = DependencyInjectionService.Resolve <ILambdaService>();
Assert.AreNotEqual(instance1.Guid.ToString(), instance2.Guid.ToString());
}
static async Task Main(string[] args)
{
Console.Write("\nEnter AWS Access Key ID:");
var accessKeyId = Console.ReadLine();
Console.Write("\nEnter AWS Secret Key:");
var secretKey = Console.ReadLine();
Console.Write("\nEnter queue messageBody:");
var messageBody = Console.ReadLine();
try
{
var serviceProvider = new DependencyInjectionService().BuildServices(accessKeyId, secretKey);
var configuration = serviceProvider.GetRequiredService <IConfiguration>();
var queueUrl = configuration["QueueUrl"];
var sendMessagerequest = new SendMessageRequest
{
QueueUrl = queueUrl,
MessageBody = $"{{'prop-1':'{messageBody}'}}"
};
var sqsClient = serviceProvider.GetRequiredService <IAmazonSQS>();
await sqsClient.SendMessageAsync(sendMessagerequest);
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
Console.ReadLine();
}
public Startup(IConfiguration configuration)
{
_configuration = configuration;
_dependencyInjectionService = new DependencyInjectionService();
_jwtSetups = new JwtSetups();
_swaggerSetups = new SwaggerSetups();
}
static void Main(string[] args)
{
var container = DependencyInjectionService.SetupContainer();
var settings = container.GetInstance <IConfigurationService>().GetSettings();
DependencyInjectionService.ConfigureLoggingService(container.GetInstance <ILoggingService>(), container.GetInstance <IFileSystemService>(), settings);
var cts = new CancellationTokenSource();
//Task.Run( () =>
//{
// container.GetInstance<IProcessWatcherService>().StartWatchingProcesses(settings.ObservedApplications, cts.Token);
//}, cts.Token);
Task.Run(async() =>
{
await container.GetInstance <IUpdateService>().CheckLatestVersion();
});
cts.Cancel();
cts.Dispose();
Console.WriteLine("press any key to close");
Console.ReadKey();
}
public void ThrowImplementationNotInstanciableException()
{
Assert.Throws <ImplementationNotInstanciableException>(delegate
{
DependencyInjectionService.Resolve <INotInstanciableService>();
});
}
static async Task Main(string[] args)
{
Console.Write("\nEnter AWS Access Key ID:");
var accessKeyId = Console.ReadLine();
Console.Write("\nEnter AWS Secret Key:");
var secretKey = Console.ReadLine();
var serviceProvider = new DependencyInjectionService().BuildServices(accessKeyId, secretKey);
var configuration = serviceProvider.GetRequiredService <IConfiguration>();
try
{
var sqsClient = serviceProvider.GetRequiredService <IAmazonSQS>();
var receiveMessageRequest = new ReceiveMessageRequest
{
QueueUrl = configuration["QueueUrl"]
};
var receiveMessageResponse = await sqsClient.ReceiveMessageAsync(receiveMessageRequest);
foreach (var message in receiveMessageResponse.Messages)
{
Console.WriteLine(message.Body);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
Console.ReadLine();
}
public DependencyInjectionService_ResolveShould()
{
DependencyInjectionService.Singleton <ISingletonService, SingletonService>();
DependencyInjectionService.Register <IWithDependenciesService, WithDependenciesService>();
DependencyInjectionService.Register <IFooService, FooService>();
DependencyInjectionService.Register <INotRegisteredDependencyService, NotRegisteredDependencyService>();
DependencyInjectionService.Register <INotInstanciableService, NotInstanciableService>();
}
public void NotThrowAlreadyRegisteredDependencyException()
{
Assert.DoesNotThrow(delegate
{
DependencyInjectionService.Register <IGenericService <long>, GenericService <long> >();
DependencyInjectionService.Register <IGenericService <int>, GenericService <int> >();
});
}
static void Main(string[] args)
{
InitServices();
DependencyInjectionService.Resolve <II18nService>().SetCulture(new System.Globalization.CultureInfo("en"));
DependencyInjectionService.Resolve <IProgramService>().Run();
}
public ServerChatServiceTests()
{
var serviceCollection = new ServiceCollection();
serviceProvider = DependencyInjectionService.ConfigureServicesTransient(serviceCollection);
serverChatService = serviceProvider.GetService <IServerChatService>();
serverChatService.StartServer();
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
DependencyInjectionService.Inicializa(Container.GetContainer());
}
public static void StartInitExtension()
{
if (IsInit)
{
return;
}
IsInit = true;
DependencyInjectionService.AddService <IStepBuilder, StepBuilder>();
DependencyInjectionService.AddService <IDoFlowBuilder, DoFlowBuilder>();
DependencyInjectionService.AddService <IStepParallel, StepParallelWhenAll>();
DependencyInjectionService.AddService <IStepParallelAny, StepParallelWhenAny>();
}
public override void OnFrameworkInitializationCompleted()
{
base.OnFrameworkInitializationCompleted();
if (!(ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop))
{
return;
}
dependencyInjectionService = new DependencyInjectionService();
dependencyInjectionService.GetInstance <ApplicationUpdateConfigService>().Execute();
dependencyInjectionService.GetInstance <IModulesInitializationService>().Execute();
desktop.MainWindow = new MainWindow
{
DataContext = dependencyInjectionService.GetInstance <MainWindowViewModel>(),
};
}
private object Construct(TranscientDependencyData dependencyData)
{
var parameters = dependencyData.ConstructorInfo.GetParameters();
List <object> constructorParameters = new List <object>();
try
{
foreach (var parameter in parameters)
{
var paramType = parameter.ParameterType;
constructorParameters.Add(DependencyInjectionService.Resolve(paramType));
}
return(Activator.CreateInstance(dependencyData.ImplementationType, constructorParameters.ToArray()));
}
catch (NotRegisteredDependencyException)
{
return(null);
}
}
private ConstructorInfo TryGetFirstEligibleConstructor(TranscientDependencyData dependencyData)
{
foreach (var constructor in dependencyData.ImplementationType.GetConstructors())
{
var eligible = true;
foreach (var parameter in constructor.GetParameters())
{
if (!DependencyInjectionService.IsRegistered(parameter.ParameterType))
{
eligible = false;
break;
}
}
if (eligible)
{
return(constructor);
}
}
return(null);
}
public void ResolveDependencies()
{
var instance = DependencyInjectionService.Resolve <IWithDependenciesService>();
Assert.IsNotNull(instance.FooService);
}
public Startup(IConfiguration configuration)
{
_configuration = configuration;
_dependencyInjectionService = new DependencyInjectionService();
}
/// <summary>
/// Method responsible to add the DI in the project accessing the Dependency Injection Service
/// </summary>
/// <returns></returns>
private static ServiceProvider RegisterDependencyInjection()
{
var serviceCollection = new ServiceCollection();
return(DependencyInjectionService.ConfigureServices(serviceCollection));
}
public DependencyInjectionService_RegisterShould()
{
DependencyInjectionService.Register <ILambdaService, LambdaService>();
}
public void ThrowAlreadyRegisteredDependencyException()
{
Assert.Throws <AlreadyRegisteredDependencyException>(delegate { DependencyInjectionService.Register <ILambdaService, LambdaService>(); });
}
private static void InitServices()
{
DependencyInjectionService.Singleton <II18nService, InMemoryI18nService>();
DependencyInjectionService.Register <IProgramService, NumericalSequenceProgramService>();
DependencyInjectionService.Register <INumericalSequenceService, FibonacciService>();
}
public void ReturnImplementationInstance()
{
var instance = DependencyInjectionService.Resolve <ILambdaService>();
Assert.IsInstanceOf <LambdaService>(instance);
}
