static void Main(string[] args)
{
string directory = AppDomain.CurrentDomain.BaseDirectory;
IServiceContainer container = new ServiceContainer();
// Load CarLibrary3.dll; If you need load
// all the libaries in a directory, use "*.dll" instead
container.LoadFrom(directory, "CarLibrary3.dll");
// Configure the container inject instances
// into the Car class constructor
container.Inject<IVehicle>()
.Using(ioc => new Car(ioc.GetService<IEngine>(),
ioc.GetService<IPerson>()))
.OncePerRequest();
Person person = new Person();
person.Name = "Someone";
person.Age = 18;
container.AddService<IPerson>(person);
IVehicle vehicle = container.GetService<IVehicle>();
vehicle.Move();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
private static void Inject(string serviceName, Action<IGenerateFactory<ISampleService>> usingFactory,
Func<IUsingLambda<ISampleService>, IGenerateFactory<ISampleService>> doInject,
ServiceContainer container)
{
// HACK: Condense the fluent statements into a single,
// reusable line of code
usingFactory(doInject(container.Inject<ISampleService>(serviceName)));
}
public void ShouldAutoInjectMethod()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
var instance = new SampleClassWithInjectionMethod();
// Initialize the container
container.Inject<ISampleService>().Using<SampleClass>().OncePerRequest();
container.Inject<ISampleService>("MyService").Using(c => instance).OncePerRequest();
var result = container.GetService<ISampleService>("MyService");
Assert.AreSame(result, instance);
// On initialization, the instance.Property value
// should be a SampleClass type
Assert.IsNotNull(instance.Property);
Assert.IsInstanceOfType(typeof(SampleClass), instance.Property);
}
public void ShouldAutoInjectPropertyWithoutCustomAttribute()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
var instance = new SampleClassWithUnmarkedInjectionProperties();
// Initialize the container with the dummy service
container.Inject<ISampleService>().Using<SampleClass>().OncePerRequest();
container.Inject<ISampleService>("MyService").Using(c => instance).OncePerRequest();
// Enable automatic property injection for every property
container.SetCustomPropertyInjectionAttribute(null);
// Get the service instance
var result = container.GetService<ISampleService>("MyService");
Assert.AreSame(result, instance);
// Ensure that the injection occurred
Assert.IsNotNull(instance.SomeProperty);
Assert.IsInstanceOfType(typeof(SampleClass), instance.SomeProperty);
}
public void ContainerMustAllowSurrogatesForNonExistentServiceInstances()
{
var container = new ServiceContainer();
var mockService = new Mock<ISampleService>();
ISampleService surrogate = mockService.Object;
container.Inject<ISampleService>().Using((f, arguments) => surrogate).OncePerRequest();
var result = container.GetService<ISampleService>();
Assert.IsNotNull(result);
Assert.AreSame(surrogate, result);
}
static void Main(string[] args)
{
string directory = AppDomain.CurrentDomain.BaseDirectory;
IServiceContainer container = new ServiceContainer();
// Load CarLibrary3.dll; If you need load
// all the libaries in a directory, use "*.dll" instead
container.LoadFrom(directory, "CarLibrary3.dll");
// Inject the OldPerson type
container.Inject<IPerson>("OldPerson").Using<Person>();
container.Initialize<IPerson>("OldPerson")
.With(p =>
{
p.Age = 99;
p.Name = "OldPerson";
});
// Inject the YoungPerson type
container.Inject<IPerson>("YoungPerson").Using<Person>();
container.Initialize<IPerson>("YoungPerson")
.With(p =>
{
p.Age = 16;
p.Name = "YoungPerson";
});
// Inject the DeadEngine type
container.Inject<IEngine>("DeadEngine").Using<DeadEngine>()
.OncePerRequest();
// Inject the OldEngine type
container.Inject<IEngine>("OldEngine").Using<OldEngine>()
.OncePerRequest();
// Inject the BrokenVehicle type into the container
container.Inject<IVehicle>("BrokenVehicle")
.Using<Car>().OncePerRequest();
#region Broken Vehicle Configuration
AddVehicle(container, "BrokenVehicle", "DeadEngine", "YoungPerson");
#endregion
#region Old Vehicle Configuration
AddVehicle(container, "OldVehicle", "OldEngine", "OldPerson");
#endregion
// Inject the OldVehicle type into the container
container.Inject<IVehicle>("OldVehicle")
.Using<Car>().OncePerRequest();
Person person = new Person();
person.Name = "Someone";
person.Age = 18;
container.AddService<IPerson>(person);
var brokenVehicle = container.GetService<IVehicle>("BrokenVehicle");
var oldVehicle = container.GetService<IVehicle>("OldVehicle");
Console.Write("Broken Vehicle: ");
brokenVehicle.Move();
Console.Write("Old Vehicle: ");
oldVehicle.Move();
Console.WriteLine("Press ENTER to continue...");
Console.ReadLine();
}
public void ShouldAutoInjectServiceListIntoArrayDependency()
{
var container = new ServiceContainer();
container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
var instance = new SampleClassWithArrayPropertyDependency();
// Initialize the container
container.Inject<ISampleService>().Using<SampleClass>().OncePerRequest();
container.Inject<SampleClassWithArrayPropertyDependency>().Using(c => instance).OncePerRequest();
var result = container.GetService<SampleClassWithArrayPropertyDependency>();
Assert.IsNotNull(result);
Assert.IsNotNull(result.Property);
var serviceCount = result.Property.Count();
Assert.IsTrue(serviceCount > 0);
}
public ShareDataProviderTest()
{
_container = new ServiceContainer();
_container.Inject<DbProviderFactory>().Using(() => DbProviderFactories.GetFactory("System.Data.SQLite")).AsSingleton();
_container.AddService("ConnectionString", "Data Source=ShareDataProviderTest.db3");
_provider = new ShareDataProvider
{
ConnectionString =
_container.GetService<string>("ConnectionString"),
DbFactory = _container.GetService<DbProviderFactory>()
};
DbProviderFactory factory = _container.GetService<DbProviderFactory>();
using (DbConnection connection = factory.CreateConnection())
{
connection.ConnectionString = _container.GetService<string>("ConnectionString");
connection.Open();
using (DbTransaction transaction = connection.BeginTransaction())
{
using (DbCommand command = connection.CreateCommand())
{
command.CommandText = "DROP TABLE IF EXISTS SHARES";
command.ExecuteNonQuery();
}
using (DbCommand command = connection.CreateCommand())
{
command.CommandText =
@"CREATE TABLE SHARES (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
path TEXT NOT NULL
)";
command.ExecuteNonQuery();
command.CommandText = "INSERT INTO SHARES(id, name, path) VALUES(NULL, @name, @path)";
IDictionary<string, string> shares = new Dictionary<string, string>
{
{"shareA", "pathA"},
{"shareB", "pathB"}
};
foreach (var share in shares)
{
command.Parameters.Clear();
DbParameter parameter = _container.GetService<DbProviderFactory>().CreateParameter();
parameter.DbType = DbType.String;
parameter.ParameterName = "@name";
parameter.Value = share.Key;
command.Parameters.Add(parameter);
parameter = _container.GetService<DbProviderFactory>().CreateParameter();
parameter.DbType = DbType.String;
parameter.ParameterName = "@path";
parameter.Value = share.Value;
parameter.Value = share.Value;
command.Parameters.Add(parameter);
command.ExecuteNonQuery();
}
}
transaction.Commit();
}
}
}
