public override void Prepare()
{
this.container = new IoC();
this.container.Map<ISingleton, Singleton>().ToSingletonScope();
this.container.Map<ITransient, Transient>();
this.container.Map<ICombined, Combined>();
}
public override void Prepare()
{
this.container = new IoC();
this.RegisterDummies();
this.RegisterStandard();
this.RegisterComplex();
}
public static IoC CreateEnvironment()
{
var ioc = new IoC();
ioc.BindAzureReposInMemForTests();
ioc.BinMockAzureTests();
ioc.BindLykkeWalletServices();
ioc.BindMockServices();
return ioc;
}
public static void BindTraderPortalServices(IoC ioc)
{
ioc.RegisterSingleTone<SrvBalanceAccess>();
ioc.RegisterSingleTone<SrvOrdersRegistrator>();
ioc.RegisterSingleTone<SrvOrdersExecutor>();
ioc.SelfBond<IOrderExecuter, SrvOrdersExecutor>();
ioc.RegisterSingleTone<SrvLimitOrderBookGenerator>();
}
public static IoC Create()
{
var ioc = new IoC();
var log = new LogToConsole();
ioc.Register<ILog>(log);
AzureRepoBinder.BindAzureReposInMem(ioc);
SrvBinder.BindTraderPortalServices(ioc);
return ioc;
}
public void IocUnitOfWorkDataStoreTest()
{
//EXAMPLE: Shows how to setup an entity database connection.
EntityConnectionContainer container = MockEntityUtility.RetrieveConnectionContainer();
using (IoC ioc = new IoC(modules: new EntityDataModule(container)))
using (var unitOfWork = ioc.Resolve<IUnitOfWork>())
{
var count = unitOfWork.Repository<User>().Queryable.Count();
unitOfWork.Repository<User>().Add(new User { Name = "TestName", Created = DateTime.Now });
unitOfWork.Save();
Assert.IsTrue(count < unitOfWork.Repository<User>().Queryable.Count());
}
}
/// <summary>
/// Creates the kernel that will manage your application.
/// </summary>
/// <returns>The created kernel.</returns>
private static IKernel CreateKernel()
{
var ioc = new IoC();
var kernel = ioc.Kernel;
try
{
kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel);
kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>();
NinjectWebCommon.RegisterServices(kernel);
return kernel;
}
catch
{
kernel.Dispose();
throw;
}
}
public static IoC Create()
{
var ioc = new IoC();
var log = new LogToConsole();
ioc.Register<ILog>(log);
ioc.BindAzureReposInMem();
SrvBinder.BindTraderPortalServices(ioc);
ioc.RegisterSingleTone<OrderBookChangesRegistrator>();
ioc.SelfBond<IOrderBookChangesConsumer, OrderBookChangesRegistrator>();
ioc.RegisterSingleTone<AssetPairBestPricesChangesRegistrator>();
ioc.SelfBond<IAssetPairBestPriceNotifier, AssetPairBestPricesChangesRegistrator>();
return ioc;
}
public static void BindTraderPortalServices(IoC ioc)
{
ioc.RegisterSingleTone<SrvClientManager>();
ioc.RegisterSingleTone<SrvBalanceAccess>();
ioc.RegisterSingleTone<SrvOrdersRegistrator>();
ioc.RegisterSingleTone<SrvOrdersExecutor>();
ioc.SelfBond<IOrderExecuter, SrvOrdersExecutor>();
ioc.RegisterSingleTone<SrvLimitOrderBookGenerator>();
ioc.RegisterSingleTone<AssetPairsBestRateCache>();
ioc.RegisterSingleTone<SrvAssetPairBestPriceBroadcaster>();
ioc.RegisterSingleTone<AssetDictionary>();
ioc.SelfBond<IAssetsDictionary, AssetDictionary>();
ioc.SelfBond<IStarter, AssetDictionary>();
ioc.RegisterSingleTone<AssetPairsDictionary>();
ioc.SelfBond<IAssetPairsDictionary, AssetPairsDictionary>();
ioc.SelfBond<IStarter, AssetPairsDictionary>();
}
public void TestArrayParams()
{
var ioC = new IoC();
ioC.Register<IInter1,Cl1>();
ioC.Register<IInter2, Cl2>();
ioC.Register<IInter2, Cl3>();
ioC.Register<Srv>();
var srv = ioC.GetObject<Srv>();
Assert.IsTrue(srv.Param1 != null);
Assert.IsTrue(srv.Param1 is Cl1);
Assert.AreEqual(2, srv.Param2.Length);
}
public void IocUnitOfWorkMockedTest()
{
//EXAMPLE: Shows how to set up a Mocked Repository
//Set up facked repository
var mockedUnitOfWork = new MockUnitOfWork();
mockedUnitOfWork.Repository<Tuple<int, string>>().Add(new Tuple<int, string>(1, "First"));
mockedUnitOfWork.Repository<Tuple<int, string>>().Add(new Tuple<int, string>(2, string.Empty));
mockedUnitOfWork.Repository<Tuple<int, string>>().Add(new Tuple<int, string>(3, "Third"));
//Call into IoC for IUnitOfWork and validate items came back.
using (IoC ioc = new IoC(modules: new MockUnitOfWorkModule(mockedUnitOfWork)))
using (var unitOfWork = ioc.Resolve<IUnitOfWork>())
{
var repository = unitOfWork.Repository<Tuple<int, string>>();
var items = repository
.Queryable
.Where(i => !string.IsNullOrEmpty(i.Item2))
.ToList();
Assert.IsTrue(items.Any());
}
}
public Default()
{
Presenter = IoC.Resolve <IToolPathGeneratorPresenter>();
Presenter.View = this;
Presenter.InitView();
}
public when_getting_types_from_container()
{
ioc = new IoC();
}
public void GoBack()
{
var model = IoC.Get <LoginPageViewModel>();
EventAggregator.PublishOnUIThread(new ShowViewModelMessage(model));
}
public WorkspaceViewModel(IEventDispatcher eventDispatcher, IDialogService dialogService)
{
_eventDispatcher = eventDispatcher;
_dialogService = dialogService;
_sgpSerializer = IoC.GetInstance <SgpSerializer>();
}
public static void Start() {
IContainer container = IoC.Initialize();
StructureMapDependencyScope = new StructureMapDependencyScope(container);
DependencyResolver.SetResolver(StructureMapDependencyScope);
DynamicModuleUtility.RegisterModule(typeof(StructureMapScopeModule));
}
public void OnReturnRequested()
{
Context.TransitionTo(new MainMenuState(Context, MessengerHub, Logger, IoC.Resolve <IRubiksCubeFactory>()));
}
public HttpResponseMessage convertToHTML(DataAPI portal)
{
Company _currentCompany = ((EInvoiceContext)FXContext.Current).CurrentCompany;
int comID = _currentCompany.id;
if (_currentCompany == null)
{
return new HttpResponseMessage()
{
Content = new StringContent("ERR:1-Unauthorized")
}
}
;
string invPattern = null, invSerial = null;
getPublishInvoice(portal.pattern, _currentCompany.id, out invPattern, out invSerial);
if (string.IsNullOrWhiteSpace(invPattern))
{
return new HttpResponseMessage()
{
Content = new StringContent("ERR:20")
}
}
;
IInvoiceService _iInvoicSrv = InvServiceFactory.GetService(invPattern, comID);
IInvoice currentInv = InvServiceFactory.NewInstance(invPattern, comID);
if (portal.invNo > 0)
{
currentInv = _iInvoicSrv.GetByNo(comID, invPattern, invSerial, portal.invNo);
}
else
{
currentInv = _iInvoicSrv.GetByFkey(comID, portal.fkey);
}
if (null == currentInv)
{
return(new HttpResponseMessage()
{
Content = new StringContent("ERR:2")
}); //khong ton tai hoa don
}
//lay html
IRepositoryINV _repository = IoC.Resolve <IRepositoryINV>();
byte[] invdata = _repository.GetData(currentInv);
string err = "";
string rv = _iInvoicSrv.ConvertForStore(currentInv, "", out err);
if (!string.IsNullOrWhiteSpace(err))
{
log.Error(err);
return(new HttpResponseMessage()
{
Content = new StringContent("ERR:" + err)
});
}
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(rv);
return(new HttpResponseMessage()
{
Content = new StringContent(System.Convert.ToBase64String(plainTextBytes))
});
}
public UserHandler()
{
IoC.Inject(this);
}
public void Edit()
{
_eventAggregator.Subscribe(this);
_windowManager.ShowDialog(IoC.Get <EditViewModel>());
}
public CommandMenuItemDefinition(MenuItemGroupDefinition group, int sortOrder)
: base(group, sortOrder)
{
_commandDefinition = IoC.Get <ICommandService>().GetCommandDefinition(typeof(TCommandDefinition));
_keyGesture = IoC.Get <ICommandKeyGestureService>().GetPrimaryKeyGesture(_commandDefinition);
}
protected async override void OnStartup(StartupEventArgs e)
{
IAppIoCContainerBuilderFactory appIoCContainerBuilderFactory = new AppIoCContainerBuilderFactory();
IoC.Configure(appIoCContainerBuilderFactory);
}
public void Setup()
{
ioc = new IoC();
}
protected virtual Type FindImplementationType(IoC.ResolveData data)
{
return(IoC.FindImplementationType(data));
}
/// <summary>
/// Method used as a helper when performing quick actions based on placing parts
/// </summary>
/// <param name="componentID"></param>
private void PlacePartHelper(ComponentIDEnumeration componentID) => AppViewModel.Singleton.DesignVM.ComponentToAdd =
IoC.Resolve <IComponentFactory>().GetDeclaration(componentID);
public SendMailController()
{
_SendmailSvc = IoC.Resolve <ISendEmailService>();
}
public CompanyInfoService(IDbFactory dbFactory) : base(dbFactory)
{
_log = IoC.Resolve <IErrorService>();
}
public RoleOrganizer()
: this(new SmDependencyResolver(IoC.Initialize()).GetService <IRolesService>())
{
}
public EditorViewModel(EditorModel model) : base(model)
{
disposables = new CompositeDisposable();
highlightingData = new ObservableCollection <OffsetSyntaxHighlightingData>();
BeforeTextChangedCommand = ReactiveCommand.Create();
disposables.Add(BeforeTextChangedCommand.Subscribe(model.OnBeforeTextChanged));
TextChangedCommand = ReactiveCommand.Create();
disposables.Add(TextChangedCommand.Subscribe(model.OnTextChanged));
SaveCommand = ReactiveCommand.Create();
disposables.Add(SaveCommand.Subscribe(param => Save()));
disposables.Add(CloseCommand.Subscribe(_ =>
{
Model.ProjectFile.FileModifiedExternally -= ProjectFile_FileModifiedExternally;
Model.Editor.CaretChangedByPointerClick -= Editor_CaretChangedByPointerClick;
Save();
Model.ShutdownBackgroundWorkers();
Model.UnRegisterLanguageService();
intellisenseManager?.Dispose();
intellisenseManager = null;
Diagnostics?.Clear();
ShellViewModel.Instance.InvalidateErrors();
Model.Dispose();
Intellisense.Dispose();
disposables.Dispose();
Model.TextDocument = null;
}));
AddWatchCommand = ReactiveCommand.Create();
disposables.Add(AddWatchCommand.Subscribe(_ => { IoC.Get <IWatchList>()?.AddWatch(WordAtCaret); }));
tabCharacter = " ";
model.DocumentLoaded += (sender, e) =>
{
model.ProjectFile.FileModifiedExternally -= ProjectFile_FileModifiedExternally;
Model.Editor.CaretChangedByPointerClick -= Editor_CaretChangedByPointerClick;
foreach (var bgRenderer in languageServiceBackgroundRenderers)
{
BackgroundRenderers.Remove(bgRenderer);
}
languageServiceBackgroundRenderers.Clear();
foreach (var transformer in languageServiceDocumentLineTransformers)
{
DocumentLineTransformers.Remove(transformer);
}
languageServiceDocumentLineTransformers.Clear();
if (model.LanguageService != null)
{
languageServiceBackgroundRenderers.AddRange(model.LanguageService.GetBackgroundRenderers(model.ProjectFile));
foreach (var bgRenderer in languageServiceBackgroundRenderers)
{
BackgroundRenderers.Add(bgRenderer);
}
languageServiceDocumentLineTransformers.AddRange(
model.LanguageService.GetDocumentLineTransformers(model.ProjectFile));
foreach (var textTransformer in languageServiceDocumentLineTransformers)
{
DocumentLineTransformers.Add(textTransformer);
}
intellisenseManager = new IntellisenseManager(Model.Editor, Intellisense, Intellisense.CompletionAssistant, model.LanguageService, model.ProjectFile);
EventHandler <KeyEventArgs> tunneledKeyUpHandler = (send, ee) =>
{
if (caretIndex > 0)
{
intellisenseManager.OnKeyUp(ee, CaretIndex, CaretTextLocation.Line, CaretTextLocation.Column);
}
};
EventHandler <KeyEventArgs> tunneledKeyDownHandler = (send, ee) =>
{
if (caretIndex > 0)
{
intellisenseManager.OnKeyDown(ee, CaretIndex, CaretTextLocation.Line, CaretTextLocation.Column);
}
};
EventHandler <TextInputEventArgs> tunneledTextInputHandler = (send, ee) =>
{
if (caretIndex > 0)
{
intellisenseManager.OnTextInput(ee, CaretIndex, CaretTextLocation.Line, CaretTextLocation.Column);
}
};
Model.Editor.CaretChangedByPointerClick += Editor_CaretChangedByPointerClick;
disposables.Add(Model.Editor.AddHandler(InputElement.KeyDownEvent, tunneledKeyDownHandler, RoutingStrategies.Tunnel));
disposables.Add(Model.Editor.AddHandler(InputElement.KeyUpEvent, tunneledKeyUpHandler, RoutingStrategies.Tunnel));
disposables.Add(Model.Editor.AddHandler(InputElement.TextInputEvent, tunneledTextInputHandler, RoutingStrategies.Bubble));
}
model.CodeAnalysisCompleted += (s, ee) =>
{
Diagnostics = model.CodeAnalysisResults.Diagnostics;
HighlightingData =
new ObservableCollection <OffsetSyntaxHighlightingData>(model.CodeAnalysisResults.SyntaxHighlightingData);
IndexItems = new ObservableCollection <IndexEntry>(model.CodeAnalysisResults.IndexItems);
selectedIndexEntry = IndexItems.FirstOrDefault();
this.RaisePropertyChanged(nameof(SelectedIndexEntry));
ShellViewModel.Instance.InvalidateErrors();
};
model.ProjectFile.FileModifiedExternally += ProjectFile_FileModifiedExternally;
TextDocument = model.TextDocument;
Title = Model.ProjectFile.Name;
};
model.TextChanged += (sender, e) =>
{
if (ShellViewModel.Instance.DocumentTabs.TemporaryDocument == this)
{
Dock = Dock.Left;
ShellViewModel.Instance.DocumentTabs.TemporaryDocument = null;
}
IsDirty = model.IsDirty;
};
intellisense = new IntellisenseViewModel(model, this);
documentLineTransformers = new ObservableCollection <IDocumentLineTransformer>();
backgroundRenderers = new ObservableCollection <IBackgroundRenderer>();
backgroundRenderers.Add(new SelectedLineBackgroundRenderer());
DebugLineHighlighter = new SelectedDebugLineBackgroundRenderer();
backgroundRenderers.Add(DebugLineHighlighter);
backgroundRenderers.Add(new ColumnLimitBackgroundRenderer());
wordAtCaretHighlighter = new SelectedWordBackgroundRenderer();
backgroundRenderers.Add(wordAtCaretHighlighter);
backgroundRenderers.Add(new SelectionBackgroundRenderer());
margins = new ObservableCollection <TextViewMargin>();
Dock = Dock.Right;
}
public ShellViewModel(IEventAggregator events)
{
ActivateItemAsync(IoC.Get <LoginViewModel>(), new CancellationToken());
events.SubscribeOnPublishedThread(this);
}
public void ShowTool <TTool>()
where TTool : ITool
{
ShowTool(IoC.Get <TTool>());
}
public static PropertyDescriptor[] GetDescriptor(DataSourceNames name)
{
return IoC.GetService<IConfiguration>()
.GetSection("mappings")
.Get<Dictionary<DataSourceNames, PropertyDescriptor[]>>()[name];
}
public static void StartTraderPortalServices(IoC ioc)
{
}
public static string GetWatchingFolder()
{
return IoC.GetService<IConfiguration>()
.GetValue<string>("watchingFolder");
}
public MainContentUserControl()
{
InitializeComponent();
DataContext = IoC.CreateInstance <MainContentUserControlViewModel>();
}
// GET: LikeDemo
public ActionResult Index()
{
var pSrv = IoC.Resolve <IProductService>();
return(View(pSrv.GetAll()));
}
public BasePage() : base()
{
this.ViewModel = IoC.Get <VM>();
}
public static void Register(UnityContainer container)
{
container.RegisterSingleton <TelegramBotManager>();
container.RegisterFactory <ITelegramBotManager>(c => IoC.Get <TelegramBotManager>());
container.RegisterSingleton <ActionManager>();
container.RegisterFactory <Func <SingleBot, TelegramUserContext> >(c => (Func <SingleBot, TelegramUserContext>)(bot =>
{
var context = new TelegramUserContext(IoC.Get <ILog>())
{
Bot = bot,
};
context.ContentManager = IoC.Get <ContentManager>();
context.Visitor = new TelegramBotMapVisitor(IoC.Get <ILog>(), context.ContentManager, IoC.Get <ActionManager>(), context);
context.Maestro = new TelegramBotMaestro(IoC.Get <ILog>(), context);
return(context);
}));
//container.RegisterSingleton<ContentManager>();
}
public void AddItem()
{
_addMenuItemViewModel = IoC.Get <IAddMenuItemViewModel>();
_addMenuItemViewModel.Clear();
ActivateItem(_addMenuItemViewModel);
}
protected override void Context()
{
sut = new Converter562To601(IoC.Resolve <Converter56To601>(), IoC.Resolve <IRenalAgingCalculationMethodUpdater>());
_userSettings = A.Fake <IUserSettings>();
_userSettings.AbsTol = ConverterConstants.OLD_DEFAULT_ABS_TOL;
_userSettings.RelTol = ConverterConstants.OLD_DEFAULT_REL_TOL;
}
public override void Dispose()
{
// Allow the container and everything it references to be disposed.
this.container = null;
}
/// <summary>
/// The create.
/// </summary>
/// <param name="browser">
/// The browser.
/// </param>
/// <returns>
/// The <see cref="CefGlueClientParams"/>.
/// </returns>
public static CefGlueClientParams Create(CefGlueBrowser browser)
{
var clientParams = new CefGlueClientParams {
Browser = browser
};
try
{
foreach (var enumKey in CefCustomHandlerFakeTypes.GetAllCustomHandlerKeys())
{
object instance = null;
var service = CefCustomHandlerFakeTypes.GetHandlerType(enumKey);
var keyStr = enumKey.EnumToString();
try
{
if (IoC.IsRegistered(service, keyStr))
{
instance = IoC.GetInstance(service, keyStr);
}
}
catch (Exception exception)
{
Log.Error(exception);
}
switch (enumKey)
{
case CefHandlerKey.LifeSpanHandler:
if (instance is CefLifeSpanHandler spanHandler)
{
clientParams.LifeSpanHandler = spanHandler;
}
else
{
clientParams.LifeSpanHandler = new CefGlueLifeSpanHandler();
}
break;
case CefHandlerKey.LoadHandler:
if (instance is CefLoadHandler loadHandler)
{
clientParams.LoadHandler = loadHandler;
}
else
{
clientParams.LoadHandler = new CefGlueLoadHandler();
}
break;
case CefHandlerKey.RequestHandler:
if (instance is CefRequestHandler requestHandler)
{
clientParams.RequestHandler = requestHandler;
}
else
{
clientParams.RequestHandler = new CefGlueRequestHandler();
}
break;
case CefHandlerKey.DisplayHandler:
if (instance is CefDisplayHandler displayHandler)
{
clientParams.DisplayHandler = displayHandler;
}
else
{
clientParams.DisplayHandler = new CefGlueDisplayHandler();
}
break;
case CefHandlerKey.ContextMenuHandler:
if (instance is CefContextMenuHandler menuHandler)
{
clientParams.ContextMenuHandler = menuHandler;
}
else
{
clientParams.ContextMenuHandler = new CefGlueContextMenuHandler();
}
break;
case CefHandlerKey.FocusHandler:
if (instance is CefFocusHandler focusHandler)
{
clientParams.FocusHandler = focusHandler;
}
break;
case CefHandlerKey.KeyboardHandler:
if (instance is CefKeyboardHandler keyboardHandler)
{
clientParams.KeyboardHandler = keyboardHandler;
}
break;
case CefHandlerKey.JsDialogHandler:
if (instance is CefJSDialogHandler jsDialogHandler)
{
clientParams.JsDialogHandler = jsDialogHandler;
}
break;
case CefHandlerKey.DialogHandler:
if (instance is CefDialogHandler dialogHandler)
{
clientParams.DialogHandler = dialogHandler;
}
break;
case CefHandlerKey.DragHandler:
if (instance is CefDragHandler dragHandler)
{
clientParams.DragHandler = dragHandler;
}
break;
case CefHandlerKey.DownloadHandler:
if (instance is CefDownloadHandler downloadHandler)
{
clientParams.DownloadHandler = downloadHandler;
}
break;
case CefHandlerKey.FindHandler:
if (instance is CefFindHandler handler)
{
clientParams.FindHandler = handler;
}
break;
}
}
}
catch (Exception exception)
{
Log.Error(exception);
}
return(clientParams);
}
public AutoMockingBuilderStrategy(Mocking mocking, IoC ioc)
{
this.mocking = mocking;
this.ioc = ioc;
}
public AutoMockingContainerExtension(IoC ioc, Mocking mocking)
{
this.ioc = ioc;
this.mocking = mocking;
}
public void Select()
{
IoC.Get <IShell>().Select(this);
}
public async Task <bool> UpdateToolTipAsync(int offset)
{
if (offset != -1 && ShellViewModel.Instance.CurrentPerspective == Perspective.Editor)
{
var matching = Model.CodeAnalysisResults?.Diagnostics.FindSegmentsContaining(offset).FirstOrDefault();
if (matching != null)
{
ToolTip = new ErrorProbeViewModel(matching);
return(true);
}
}
if (offset != -1 && ShellViewModel.Instance.CurrentPerspective == Perspective.Editor && Model.LanguageService != null)
{
var symbol = await Model.LanguageService.GetSymbolAsync(Model.ProjectFile, EditorModel.UnsavedFiles.ToList(), offset);
if (symbol != null)
{
switch (symbol.Kind)
{
case CursorKind.CompoundStatement:
case CursorKind.NoDeclarationFound:
case CursorKind.NotImplemented:
case CursorKind.FirstDeclaration:
case CursorKind.InitListExpression:
case CursorKind.IntegerLiteral:
case CursorKind.ReturnStatement:
break;
default:
ToolTip = new SymbolViewModel(symbol);
return(true);
}
}
}
if (offset != -1 && ShellViewModel.Instance.CurrentPerspective == Perspective.Debug)
{
var expression = GetWordAtOffset(offset);
if (expression != string.Empty)
{
var debugManager = IoC.Get <IDebugManager>();
var evaluatedExpression = await debugManager.ProbeExpressionAsync(expression);
if (evaluatedExpression != null)
{
var newToolTip = new DebugHoverProbeViewModel();
newToolTip.AddExistingWatch(evaluatedExpression);
ToolTip = newToolTip;
return(true);
}
}
}
return(false);
}
public UnityDependencyResolver()
{
var inversaoControle = new IoC();
container = inversaoControle.Container;
}
public void DisplayActionTab()
{
IoC.Get <IShell>().AddOrSelectDocument(this);
}
