public IAdorneredTooltipsManager Create(AdornerLayer adornerLayer)
{
Argument.IsNotNull(() => adornerLayer);
var hintsAdornerLayer = _serviceLocator.ResolveTypeUsingParameters <IAdornerLayer>(new object[] { adornerLayer });
var adorneredHintFactory = _serviceLocator.ResolveType <IAdorneredTooltipFactory>();
var adorneredHintsCollection = _serviceLocator.ResolveTypeUsingParameters <IAdorneredTooltipFactory>(new object[] { adorneredHintFactory });
var adornerGenerator = _serviceLocator.ResolveType <IAdornerTooltipGenerator>();
var hintsProvider = _serviceLocator.ResolveType <IHintsProvider>();
return(_typeFactory.CreateInstanceWithParameters <AdorneredTooltipsManager>(adornerGenerator, hintsProvider, hintsAdornerLayer, adorneredHintsCollection));
}
/// <summary>
/// Gets the repository that is created specificially for this unit of work.
/// <para />
/// Note that the following conditions must be met: <br />
/// <list type="number">
/// <item>
/// <description>
/// The container must be registered in the <see cref="ServiceLocator" /> as <see cref="RegistrationType.Transient" /> type. If the
/// repository is declared as non-transient, it will be instantiated as new instance anyway.
/// </description>
/// </item>
/// <item>
/// <description>
/// The repository must have a constructor accepting a <see cref="DbContext" /> instance.
/// </description>
/// </item>
/// </list>
/// </summary>
/// <typeparam name="TEntityRepository">The type of the entity repository.</typeparam>
/// <returns>The entity repository.</returns>
/// <exception cref="NotSupportedException">The specified repository type cannot be found.</exception>
public virtual TEntityRepository GetRepository <TEntityRepository>()
where TEntityRepository : IEntityRepository
{
var registrationInfo = _serviceLocator.GetRegistrationInfo(typeof(TEntityRepository));
if (registrationInfo == null)
{
throw Log.ErrorAndCreateException <NotSupportedException>("The specified repository type '{0}' cannot be found. Make sure it is registered in the ServiceLocator.", typeof(TEntityRepository).FullName);
}
var repository = _typeFactory.CreateInstanceWithParameters(registrationInfo.ImplementingType, DbContext);
return((TEntityRepository)repository);
}
/// <summary>
/// Registers the convention.
/// </summary>
public void RegisterConvention <TRegistrationConvention>(RegistrationType registrationType = RegistrationType.Singleton)
where TRegistrationConvention : IRegistrationConvention
{
var registrationConvention = _typeFactory.CreateInstanceWithParameters <TRegistrationConvention>(_serviceLocator, registrationType);
if (_registeredConventions.Contains(registrationConvention))
{
return;
}
Log.Debug("Registering '{0}' on cached conventions", typeof(TRegistrationConvention).Name);
_registeredConventions.Add(registrationConvention);
ApplyConventions();
}
protected override async Task InitializeAsync()
{
try
{
if (IsActive && _initialSearchParams is not null)
{
// Set page initial search params as Settings parameters
// Only on first loaded page
Settings.IsPreReleaseIncluded = _initialSearchParams.IsPrereleaseIncluded;
Settings.SearchString = _initialSearchParams.SearchString;
Settings.IsRecommendedOnly = _initialSearchParams.IsRecommendedOnly;
}
// Execution delay
SingleDelayTimer.Elapsed += OnTimerElapsed;
SingleDelayTimer.AutoReset = false;
SingleDelayTimer.SynchronizingObject = _typeFactory.CreateInstanceWithParameters <ISynchronizeInvoke>(
_dispatcherProviderService.GetCurrentDispatcher());
PackageItems = new FastObservableCollection <NuGetPackage>();
PackageItems.CollectionChanged += OnPackageItemsCollectionChanged;
_packageOperationContextService.OperationContextDisposing += OnOperationContextDisposing;
IsFirstLoaded = false;
var pageSize = _nuGetConfigurationService.GetPackageQuerySize();
if (Settings.ObservedFeed is not null && !string.IsNullOrEmpty(Settings.ObservedFeed.Source))
{
var currentFeed = Settings.ObservedFeed;
PageInfo = new PageContinuation(pageSize, Settings.ObservedFeed.GetPackageSource());
var searchParams = new PackageSearchParameters(Settings.IsPreReleaseIncluded, Settings.SearchString, Settings.IsRecommendedOnly);
await VerifySourceAndLoadPackagesAsync(PageInfo, currentFeed, searchParams, pageSize);
}
else
{
Log.Info("None of the source feeds configured");
}
}
/// <summary>
/// Creates a new view model.
/// </summary>
/// <param name="viewModelType">Type of the view model that needs to be created.</param>
/// <param name="dataContext">The data context of the view model.</param>
/// <returns>The newly created <see cref="IViewModel"/> or <c>null</c> if no view model could be created.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="viewModelType"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The <paramref name="viewModelType"/> does not implement the <see cref="IViewModel"/> interface.</exception>
public virtual IViewModel CreateViewModel(Type viewModelType, object dataContext)
{
Argument.IsNotNull("viewModelType", viewModelType);
Argument.ImplementsInterface("viewModelType", viewModelType, typeof(IViewModel));
IViewModel viewModel = null;
// Only try to construct the view model when the injection object is not null, otherwise every
// view model can be constructed with a nullable object. If a user wants a view model to be constructed
// without any datacontext or injection, he/she should use an empty default constructor which will only
// be used when injection is not possible
if (dataContext != null)
{
viewModel = _typeFactory.CreateInstanceWithParameters(viewModelType, dataContext) as IViewModel;
if (viewModel != null)
{
Log.Debug("Constructed view model '{0}' using injection of data context '{1}'", viewModelType.FullName, ObjectToStringHelper.ToTypeString(dataContext));
return(viewModel);
}
}
// Try to construct view model using dependency injection
viewModel = _typeFactory.CreateInstance(viewModelType) as IViewModel;
if (viewModel != null)
{
Log.Debug("Constructed view model '{0}' using dependency injection or empty constructor", viewModelType.FullName);
return(viewModel);
}
// Last resort: Activator
viewModel = _typeFactory.CreateInstanceUsingActivator(viewModelType) as IViewModel;
if (viewModel != null)
{
Log.Debug("Constructed view model '{0}' using Activator.CreateInstance", viewModelType.FullName);
}
else
{
Log.Debug("Could not construct view model '{0}' using injection of data context '{1}' or Activator.CreateInstance",
viewModelType.FullName, ObjectToStringHelper.ToTypeString(dataContext));
}
return(viewModel);
}
/// <summary>
/// Creates a proxy instance of the specified proxy type using the specified constructor arguments.
/// </summary>
/// <typeparam name="TProxy">The type of the proxy.</typeparam>
/// <param name="parameters">The parameters.</param>
/// <param name="interceptor">The interceptor.</param>
/// <param name="interfaces">The interfaces.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">The <paramref name="parameters"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="interceptor"/> is <c>null</c>.</exception>
public TProxy Create <TProxy>(object[] parameters, IInterceptor interceptor, params Type[] interfaces)
where TProxy : class
{
Argument.IsNotNullOrEmptyArray("parameters", parameters);
Argument.IsNotNull(() => interceptor);
var proxyType = typeof(TProxy);
var proxy = (TProxy)_typeFactory.CreateInstanceWithParameters(proxyType, parameters);
var interceptorAdapter = new InterceptorAdapter(interceptor, proxy);
return
((TProxy)
_proxyGenerator.CreateClassProxy(proxyType, interfaces, ProxyGenerationOptions.Default,
parameters,
new Castle.DynamicProxy.IInterceptor[]
{
interceptorAdapter
}));
}
/// <summary>
/// Creates an instance of the specified type using the specified parameters as injection values.
/// </summary>
/// <typeparam name="T">The type to instantiate.</typeparam>
/// <param name="typeFactory">The type factory.</param>
/// <param name="parameters">The parameters to inject.</param>
/// <returns>The instantiated type using dependency injection.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="typeFactory"/> is <c>null</c>.</exception>
public static T CreateInstanceWithParameters <T>(this ITypeFactory typeFactory, params object[] parameters)
{
Argument.IsNotNull("typeFactory", typeFactory);
return((T)typeFactory.CreateInstanceWithParameters(typeof(T), parameters));
}