private T CreateInternal <T>(Type controllerType, HttpContext requestContextHttpContext)
{
IDependencyResolver resolver;
{
if (requestContextHttpContext.Items.Contains("resolver"))
{
resolver = requestContextHttpContext.Items["resolver"] as IDependencyResolver ??
Resolver.CreateScopedResolver();
}
else
{
resolver = Resolver.CreateScopedResolver();
}
}
if (!(requestContextHttpContext.Items["resolver"] is IDependencyResolver))
{
HttpContext.Current.Items.Add("resolver", resolver);
}
var context = resolver.GetService <HttpContextAccessor>();
context.SetContext(requestContextHttpContext);
OnCreatingController?.Invoke(resolver, context, controllerType);
var controller = (T)controllerType.Activate(Scope.Context, resolver);
OnControllerCreated?.Invoke(resolver, context, controller);
return(controller);
}
public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)
{
var controller = (IHttpController)controllerType.Activate(Scope.PerRequest);
InitalizeController(request, controller);
return(controller);
}
IController IControllerActivator.Create(RequestContext requestContext, Type controllerType)
{
var controller = (IController)controllerType.Activate(Scope.PerRequest);
InitializeController(requestContext, controller);
return(controller);
}
public void Activate()
{
if (IsActive)
{
return;
}
Type.Activate(this);
if (OnActivate != null)
{
OnActivate(this);
}
frames = 0;
time = 0f;
}
public void CreateDummyTypeConstructorTest()
{
Type type = TypeHelper.CreateDummyType("Test2", typeof(TestClass), true);
var defaultConstructorInstance = (TestClass)type.Activate(null);
Assert.AreEqual(defaultConstructorInstance.value, "Default Constructor");
var customConstructorInstance1 = (TestClass)type.Activate(null, "Custom constructor");
Assert.AreEqual(customConstructorInstance1.value, "Custom constructor");
var customConstructorInstance2 = (TestClass)type.Activate(null, 11, "test");
Assert.AreEqual(customConstructorInstance2.value, "11test");
var methods = type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static);
Assert.AreEqual(3, methods.Length);
var ctor1 = (TestClass)methods[0].Invoke(null, BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.NonPublic, null, new object[0], null);
var ctor2 = (TestClass)methods[1].Invoke(null, BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { "Custom constructor" }, null);
var ctor3 = (TestClass)methods[2].Invoke(null, BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.NonPublic, null, new object[] { 11, "test" }, null);
Assert.AreEqual(ctor1.value, defaultConstructorInstance.value);
Assert.AreEqual(ctor2.value, customConstructorInstance1.value);
Assert.AreEqual(ctor3.value, customConstructorInstance2.value);
}
/// <inheritdoc/>
protected override TAssociate CreateAssociate <TKey, TAssociate>(out Type foundFor)
{
TAssociate associate = base.CreateAssociate <TKey, TAssociate>(out foundFor);
if (associate != null)
{
return(associate);
}
// Ok, null, but probably just because type cast has failed;
// let's try to wrap it. TKey is type for which we're getting
// the comparer.
IAdvancedComparerBase comparer = base.CreateAssociate <TKey, IAdvancedComparerBase>(out foundFor);
if (foundFor == null)
{
CoreLog.Warning(Strings.LogCantFindAssociateFor,
TypeSuffixes.ToDelimitedString(" \\ "),
typeof(TAssociate).GetShortName(),
typeof(TKey).GetShortName());
return(null);
}
if (foundFor == typeof(TKey))
{
return((TAssociate)comparer);
}
Type baseComparerWrapperType = typeof(BaseComparerWrapper <,>);
associate =
baseComparerWrapperType.Activate(new Type[] { typeof(TKey), foundFor }, ConstructorParams) as
TAssociate;
if (associate != null)
{
CoreLog.Warning(Strings.LogGenericAssociateIsUsedFor,
baseComparerWrapperType.GetShortName(),
typeof(TKey).GetShortName(),
foundFor.GetShortName(),
typeof(TKey).GetShortName());
return(associate);
}
else
{
CoreLog.Warning(Strings.LogGenericAssociateCreationHasFailedFor,
baseComparerWrapperType.GetShortName(),
typeof(TKey).GetShortName(),
foundFor.GetShortName(),
typeof(TKey).GetShortName());
return(null);
}
}
public IAdvancedConverter <TTo, TFrom> CreateBackwardConverter <TTo>()
{
Type fromType = typeof(TFrom);
Type toType = typeof(TTo);
if (fromType.IsAssignableFrom(toType))
{
Type[] genericArguments = new Type[] { toType, fromType };
Type genericType = typeof(ObjectToBaseAdvancedConverter <,>);
return(genericType.Activate(genericArguments, provider) as IAdvancedConverter <TTo, TFrom>);
}
else if (toType.IsAssignableFrom(fromType))
{
Type[] genericArguments = new Type[] { toType, fromType };
Type genericType = typeof(ObjectToDescendantAdvancedConverter <,>);
return(genericType.Activate(genericArguments, provider) as IAdvancedConverter <TTo, TFrom>);
}
return(null);
}
private static IdentityConfiguration ConfigureWithExternalModules()
{
var identitySettings = FederatedAuthentication.FederationConfiguration.IdentityConfiguration;
identitySettings.SaveBootstrapContext = true;
identitySettings.AudienceRestriction.AudienceMode = AudienceUriMode.Always;
if (AuthorizationManager != null)
{
identitySettings.ClaimsAuthenticationManager = AuthorizationManager.Activate <ClaimsAuthenticationManager>();
Logging.DebugMessage("AuthenticationManager obtained");
}
if (CahceModule.IsInstance())
{
identitySettings.Caches.SessionSecurityTokenCache = CahceModule.Activate <SessionSecurityTokenCache>();
Logging.DebugMessage("SessionSecurityTokenCache obtained");
}
Logging.DebugMessage("Identity settings obtained. External components added.");
return(identitySettings);
}
public object GetInstance(InstanceContext instanceContext, Message message)
{
return(ServiceType.Activate(Scope.PerRequest));
}
public IController Create(RequestContext requestContext, Type controllerType)
{
return((IController)controllerType.Activate());
}
