public static void PlasmaRegisterType(this IMetaWriter writer, Type type)
{
if (PlasmaContainer.IsValidImplementationType(type))
{
writer.WriteLine("// " + type.CSharpTypeIdentifier());
_context.Types.Add(type);
}
}
public void Should_pre_initialize_provider_using_app_config()
{
Assert.Inconclusive();
// Setup
var sut = new PlasmaContainer();
// Execute
var two = sut.Get <ITwo>();
// Verify
Assert.IsInstanceOfType(two.OneA, typeof(One1));
Assert.IsInstanceOfType(two.OneB, typeof(One2));
}
public void Should_initialize_with_two_different_generic_impls()
{
var pros = PlasmaContainer.GetPlumbingProperties(typeof(GenericPerformer));
Assert.AreEqual(2, pros.Count());
var test = _sut.Get <GenericPerformer>();
Assert.IsNotNull(test);
Assert.IsNotNull(test.Sdao1);
Assert.IsNotNull(test.Sdao2);
Assert.IsNotNull(test.Sdao3_);
}
/// <summary>
/// Analyze type and yield all required type requests that are supposed to be directed to container
/// </summary>
public override IEnumerable <Type> GetRequestsCore(Type type)
{
var plumbingPros = PlasmaContainer.GetPlumbingProperties(type).ToArray();
if (plumbingPros.Length > 0)
{
_result[type] = true;
foreach (var pi in plumbingPros)
{
_mining.GetArgument(pi);
}
}
else
{
_result[type] = false;
}
return(Enumerable.Empty <Type>()); // requests from miner
}
/// <summary>
/// Generate code necessary to prepare registers for working with types collected
/// </summary>
public override void Write(IMetaWriter writer)
{
foreach (var type in _result)
{
if (type.Value)
{
var plumbingPros = PlasmaContainer.GetPlumbingProperties(type.Key).ToArray();
var plumbingc = "";
foreach (var pi in plumbingPros)
{
plumbingc += string.Format("\tx.{0} = {1};\r\n", pi.Name, _mining.GetArgument(pi));
}
// todo remove extra cast in plumber
// todo remove dependancy on 'c'
writer.WriteLine(@"{2}.Register<{0}>((c, x)=>{{
{1}}});", type.Key, plumbingc, typeof(TypeAutoPlumberRegister));
}
else
{
writer.WriteLine("{1}.RegisterNone(typeof({0}));", type.Key, typeof(TypeAutoPlumberRegister));
}
}
}
public static object Object(Type type)
{
object value;
if (_dic.TryGetValue(type, out value))
{
_accessed.Add(type);
return(value);
}
if (type.IsGenericType)
{
var gtd = type.GetGenericTypeDefinition();
Func <Type[], object> fact;
if (_dicGeneric.TryGetValue(gtd, out fact))
{
_accessed.Add(gtd);
value = fact(type.GetGenericArguments());
Register(type, value);
return(value);
}
}
throw new PlasmaException("Null object is not registered for: " + PlasmaContainer.GetTypeName(type));
}
public void MyTestMethod()
{
var ps = PlasmaContainer.GetPlumbingProperties(typeof(MyServiceWithAutomaticSetterOnlyInjection));
Assert.AreEqual(1, ps.Count());
}
/// <summary>
/// Finally write all code
/// End your file with that line
/// </summary>
public static void PlasmaGenerate(this IMetaWriter writer)
{
#region PREPARE
_writerTmp = writer;
var ctx = new PlasmaContainer();
// AssemblyAnalyzeCache.LoadAll(writer);
AssemblyAnalyzeCache.AnalyzeImpls();
// a set of types that is going to be asked from container
var requests = new HashSet <Type>(_context.Types);
var requestsProcessed = new HashSet <Type>();
var faceImpls = ctx.Get <FaceImplStrategy>();
var factory = ctx.Get <FactoryStrategy>();
var plumbing = ctx.Get <PlumbingStrategy>();
var miner = ctx.Get <StaticMining>();
miner.RequestByType += Miner_RequestByType;
writer.WriteLine("// Analyze...");
while (requests.Count > 0)
{
_requestsFromMiner.Clear(); // not necessary - just to simplify debugging
var fromFace = faceImpls.GetRequests(requests).ToArray();
var fromFact = factory.GetRequests(requests).ToArray();
var fromPlumb = plumbing.GetRequests(requests).ToArray();
foreach (var request in requests)
{
requestsProcessed.Add(request);
}
// new requests
requests = new HashSet <Type>(fromFace.Concat(fromFact).Concat(fromPlumb).Concat(_requestsFromMiner).Except(requestsProcessed));
writer.WriteLine("// New requests: {0}", string.Join(", ", requests.Select(x => x.CSharpTypeIdentifier())));
}
miner.RequestByType -= Miner_RequestByType;
writer.WriteLine("// Analyze completed");
#endregion
#region Proxy
if (_enableProxy)
{
foreach (var type in _context.Types.Where(x => x.IsInterface))
{
_proxyGenerator.Generate(writer, type);
// GenerateStub(writer, type);
}
}
#endregion
#region Null
if (_enableNullObject)
{
var req = _context.Types.Where(x => x.IsInterface);
do
{
foreach (var type in req.ToArray())
{
try
{
writer.Transactional(w => _nullGenerator.Generate(writer, type));
}
catch (Exception ex)
{
writer.WriteLine("#warning " + ex.Message);
writer.WriteLine("/*");
writer.WriteLine(ExceptionAnalyzer.ExceptionDetails(ex));
writer.WriteLine("*/");
}
}
req = _nullGenerator.RequestedObjects.Except(_nullGenerator.NullObjects).ToArray();
_nullGenerator.RequestedObjects.Clear();
} while (req.Any());
}
#endregion
writer.WriteLine(@"
public static partial class PlasmaRegistration
{{
static volatile bool _executed;
public static void Run({1}? reflectionPermission = null)
{{
if (_executed)
{{
return;
}}
_executed = true;
{0}.DefaultReflectionPermission = reflectionPermission ?? {1}.Throw;
", typeof(PlasmaContainer), typeof(ReflectionPermission));
writer.WriteLine(); // ignore tabs
#region Factory
writer.WriteLine();
writer.WriteLine("// Factory ");
factory.Write(writer);
#endregion
#region face impl
writer.WriteLine();
writer.WriteLine("// Iface impl");
faceImpls.Write(writer);
#endregion
#region plumbers
writer.WriteLine();
writer.WriteLine("// Plumbers (Property injectors)");
plumbing.Write(writer);
#endregion
#region null object register
if (_enableNullObject)
{
foreach (var type in _nullGenerator.NullObjects.Concat(_nullGenerator.ExplicitRequests).Distinct())
{
if (type.IsGenericType && type.IsGenericTypeDefinition)
{
writer.WriteLine(@"Null.RegisterGeneric(typeof({0}), t =>
typeof ({1}).MakeGenericType(t).GetField(""Instance"").GetValue(null));" , type.CSharpTypeIdentifier(_omitTypeDef), _nullGenerator.GetTypeName(type).FullNameGenericNoT);
//typeof (NullEnumerable<>).MakeGenericType(t).GetField("Instance").GetValue(null));
}
else
{
writer.WriteLine("Null.Register<{0}>({1}.Instance);", type, _nullGenerator.GetTypeName(type).FullNameGeneric);
}
}
}
#endregion
writer.WriteLine(@"
}
}
");
}
