public IGraphHandler CreateNewDocument(string packageId)
{
var graphHandler = m_InstanceCreator.CreateInstance <IGraphHandler>(new[] { new ConstructorArgument("packageId", packageId) });
Documents.Add(graphHandler);
return(graphHandler);
}
public IResolutionEngine GetResolutionEngine(string package)
{
if (File.Exists(package))
{
var extension = Path.GetExtension(package);
if (!string.IsNullOrEmpty(extension))
{
if (extension.EndsWith(".sln", StringComparison.CurrentCultureIgnoreCase))
{
return(m_InstanceCreator.CreateInstance <ISolutionResolutionEngine>(new ConstructorArgument[] { }));
}
return(m_InstanceCreator.CreateInstance <IProjectResolutionEngine>(new ConstructorArgument[] { }));
}
return(null);
}
return(m_InstanceCreator.CreateInstance <INuGetResolutionEngine>(new ConstructorArgument[] { }));
}
public object GetInstance(NancyContainer container, IInstanceCreator creator)
{
if (creator.Instance == null)
{
creator.Instance = creator.CreateInstance(container);
}
return creator.Instance;
}
private T ValidateInstCreator <T>(IInstanceCreator instCreator)
{
var obj = instCreator.CreateInstance(new TestInjectionResolver());
Assert.IsNotNull(obj);
Assert.IsTrue(obj is T);
return((T)obj);
}
public void CreateInstance_returns_exception_for_failing_method( )
{
IInstanceCreator creator = InstanceCreator.ForType <FailingClass>( );
object result = creator.CreateInstance( );
var actual = Assert.IsType <Exception>(result);
Assert.Equal(typeof(FailingClass).FullName, actual.Message);
}
/// <summary>
/// Gets the instance from the Session, if available, otherwise creates a new
/// instance and stores in the Session.
/// </summary>
/// <param name="creator">The creator (registration) to create a new instance.</param>
/// <returns>The instance.</returns>
public object GetInstance(IInstanceCreator creator)
{
object instance = Session[creator.Key];
if (instance == null)
{
instance = creator.CreateInstance(ContainerCaching.InstanceNotCachedInContainer);
Session[creator.Key] = instance;
}
return(instance);
}
public void ProvideInstance(IService service)
{
if (AutoValueChecker.Check(service))
{
service.Data.Instance = InstanceCreator.CreateInstance(service.Registration.TargetType);
}
else if (!AutoValueChecker.Check(service))
{
service.Data.Instance = null;
}
}
/// <summary>
/// Gets the instance from cache, if available, otherwise creates a new
/// instance and caches it.
/// </summary>
/// <param name="creator">The creator (registration) to create a new instance.</param>
/// <returns>The instance.</returns>
public object GetInstance(IInstanceCreator creator)
{
Cache cache = HttpRuntime.Cache;
object instance = cache[creator.Key];
if (instance == null)
{
instance = creator.CreateInstance(ContainerCaching.InstanceNotCachedInContainer);
cache.Insert(creator.Key, instance, _dependencies, _absoluteExpiration,
_slidingExpiration, _priority, _onRemoveCallback);
}
return(instance);
}
ICreatesWebDriver GetFactory(Type type)
{
object factory;
try
{
factory = instanceCreator.CreateInstance(type);
}
catch (Exception)
{
// If there was a problem creating the factory just squelch the error and return null for no factory.
return(null);
}
return(factory as ICreatesWebDriver);
}
/// <summary>
/// Gets an instance from the thread local storage, or creates a new instance if not found.
/// </summary>
/// <param name="creator">The IInstanceCreate to use to get the Key and create new if required.</param>
/// <returns>The instance.</returns>
public object GetInstance(IInstanceCreator creator)
{
object instance = null;
// if it is a new thread then the localStorage needs to be initialized;
if (localStorage == null)
{
localStorage = new Dictionary <string, object>();
}
if (!localStorage.TryGetValue(creator.Key, out instance))
{
instance = creator.CreateInstance(ContainerCaching.InstanceNotCachedInContainer);
localStorage[creator.Key] = instance;
}
return(instance);
}
public void Initialize()
{
foreach (var plcSetting in setting.PlcSettings)
{
if (!plcSetting.IsMock)
{
var plc = instanceCreator.CreateInstance <BeckhoffPlc>(new[]
{ new ConstructorArgument("settings", plcSetting) });
if (plc.Initialize())
{
plcs.Add(plcSetting.Name, plc);
}
else
{
Logger?.LogWarning("Unable to initialize Beckhoff: '{plcSetting}'", plcSetting);
}
}
else
{
plcs.Add(plcSetting.Name, new MockPlc());
}
}
}
public IServiceFactory ProvideServiceFactory(Type @class)
{
return((IServiceFactory)InstanceCreator.CreateInstance(@class));
}
/// <summary>
/// Gets a new instance.
/// </summary>
/// <param name="creator">The creator (registration) that can create an instance</param>
/// <returns>The new instance.</returns>
public object GetInstance(IInstanceCreator creator)
{
return(creator.CreateInstance(ContainerCaching.InstanceNotCachedInContainer));
}
/// <summary>
/// Resolves the object held by the container
/// </summary>
/// <param name="resolver">Injection resolver to acquire parameters</param>
/// <returns>Resolved instance of the object</returns>
/// <exception cref="CommonIoCException">Can be raised when injections not found</exception>
public sealed override object GetInstance(IInjectionResolver resolver)
{
return(_createInstanceObj.CreateInstance(resolver));
}
public static IMetadataReader GetReader(string rawFilePath)
{
return(ReaderCreator.CreateInstance(rawFilePath));
}
/// <summary>
/// Resolves the object held by the container
/// </summary>
/// <param name="resolver">Injection resolver to acquire parameters</param>
/// <returns>Resolved instance of the object</returns>
/// <exception cref="CommonIoCException">Can be raised when injections not found</exception>
public sealed override object GetInstance(IInjectionResolver resolver)
{
TurboContract.Requires(resolver != null, conditionString: "resolver != null");
return(_createInstanceObj.CreateInstance(resolver));
}
object IInstanceCreator.CreateInstance( )
{
IInstanceCreator innerCreator = this.innerCreator_;
return(innerCreator.CreateInstance( ));
}
public object GetInstance(NancyContainer container, IInstanceCreator creator)
{
return creator.CreateInstance(container);
}