private static PropertyOrFieldServiceInfo GetImportedPropertiesAndFields(MemberInfo m, Request req)
{
var import = (ImportAttribute)m.GetAttributes(typeof(ImportAttribute)).FirstOrDefault();
return(import == null ? null : PropertyOrFieldServiceInfo.Of(m)
.WithDetails(ServiceDetails.Of(import.ContractType, import.ContractName)));
}
private static PropertyOrFieldServiceInfo GetImportedPropertiesAndFieldsOnly(MemberInfo member, Request request)
{
var attributes = member.GetAttributes().ToArray();
var details = attributes.Length == 0 ? null
: GetFirstImportDetailsOrNull(member.GetReturnTypeOrDefault(), attributes, request);
return(details == null ? null : PropertyOrFieldServiceInfo.Of(member).WithDetails(details, request));
}
private static PropertyOrFieldServiceInfo GetImportedProperties(MemberInfo m, Request req)
{
if (m.IsDefined(typeof(InjectAttribute), true))
{
return(PropertyOrFieldServiceInfo.Of(m)
.WithDetails(ServiceDetails.Of(ifUnresolved: IfUnresolved.ReturnDefault), req));
}
return(null);
}
/// <summary>Registers controllers types in container with InWebRequest reuse.</summary>
/// <param name="container">Container to register controllers to.</param>
/// <param name="controllerAssemblies">(optional) Uses <see cref="BuildManager.GetReferencedAssemblies"/> by default.</param>
public static void RegisterMvcControllers(this IContainer container, IEnumerable <Assembly> controllerAssemblies = null)
{
controllerAssemblies = controllerAssemblies ?? GetReferencedAssemblies();
container.RegisterMany(controllerAssemblies, type => type.IsAssignableTo(typeof(IController)),
Reuse.InWebRequest, PropertiesAndFields.All(false, false, false, withInfo: (m, r) =>
{
if (m.DeclaringType != typeof(Controller) && m.DeclaringType != typeof(ControllerBase))
{
return(PropertyOrFieldServiceInfo.Of(m).WithDetails(
ServiceDetails.Of(ifUnresolved: IfUnresolved.ReturnDefault), r));
}
return(null);
}));
}
public static PropertiesAndFieldsSelector AllPropertiesWithImportAttribute()
{
PropertyOrFieldServiceInfo info(MemberInfo m, Request r) => PropertyOrFieldServiceInfo.Of(m).WithDetails(ServiceDetails.Of(ifUnresolved: IfUnresolved.Throw));
return(req =>
{
var properties = req.ImplementationType.GetMembers(_ => _.DeclaredProperties, includeBase: true)
.Match(
p => CustomAttributeExtensions.GetCustomAttribute <ImportAttribute>((MemberInfo)p) != null &&
PropertiesAndFields.IsInjectable((PropertyInfo)p, withNonPublic: true, withPrimitive: false),
p => info(p, req));
return properties;
});
}
/// <summary>Registers controllers found in provided assemblies with <see cref="Reuse.InWebRequest"/>.</summary>
/// <param name="container">Container.</param>
/// <param name="config">Http configuration.</param>
/// <param name="assemblies">Assemblies to look for controllers.</param>
public static void RegisterWebApiControllers(this IContainer container, HttpConfiguration config,
IEnumerable <Assembly> assemblies = null)
{
var assembliesResolver = assemblies == null
? config.Services.GetAssembliesResolver()
: new GivenAssembliesResolver(assemblies.ToList());
var controllerTypeResolver = config.Services.GetHttpControllerTypeResolver();
var controllerTypes = controllerTypeResolver.GetControllerTypes(assembliesResolver);
container.RegisterMany(controllerTypes, Reuse.InWebRequest,
PropertiesAndFields.All(false, false, false, withInfo: (m, r) =>
{
if (m.DeclaringType != typeof(ApiController))
{
return(PropertyOrFieldServiceInfo.Of(m).WithDetails(
ServiceDetails.Of(ifUnresolved: IfUnresolved.Throw), r));
}
return(null);
}),
nonPublicServiceTypes: true);
}
public void Test_field_2()
{
var container = new Container(rules => rules
.With(propertiesAndFields: request =>
request.ImplementationType.GetMembers(t =>
t.DeclaredFields.Cast <MemberInfo>().Concat(
t.DeclaredProperties.Cast <MemberInfo>()))
.Select(member =>
{
var attr = member.GetCustomAttribute <ServiceKeyResolverAttribute>();
if (attr == null)
{
return(null);
}
var value = ConfigWrapper.GetValue(attr.Key);
return(PropertyOrFieldServiceInfo.Of(member).WithDetails(ServiceDetails.Of(value)));
})));
container.Register <IService, BlahService>();
var service = (BlahService)container.Resolve <IService>();
Assert.AreEqual("id: paths.baseUrl", service.BaseUrlField);
Assert.AreEqual("id: paths.baseUrl", service.BaseUrlProperty);
}
public void Specify_property_selector_with_custom_service_type_when_registering_service()
{
var container = new Container();
container.Register <SomeBlah>(made: Made.Of(propertiesAndFields:
r => r.ImplementationType.GetTypeInfo().DeclaredProperties.Select(p =>
p.Name.Equals("Uses") ? PropertyOrFieldServiceInfo.Of(p)
.WithDetails(ServiceDetails.Of(typeof(Service))) : null)));
container.Register <Service>();
var blah = container.Resolve <SomeBlah>();
Assert.That(blah.Uses, Is.InstanceOf <Service>());
}
