public BindingWorkflow(IHost host, ConnectionInformation connectionInformation, ProjectInformation project)
        {
            if (host == null)
            {
                throw new ArgumentNullException(nameof(host));
            }

            if (connectionInformation == null)
            {
                throw new ArgumentNullException(nameof(connectionInformation));
            }

            if (project == null)
            {
                throw new ArgumentNullException(nameof(project));
            }

            this.host = host;
            this.connectionInformation = connectionInformation;
            this.project = project;
            this.projectSystem = this.host.GetService<IProjectSystemHelper>();
            this.projectSystem.AssertLocalServiceIsNotNull();

            this.solutionBindingOperation = new SolutionBindingOperation(
                    this.host,
                    this.connectionInformation,
                    this.project.Key);
        }

        public CredentialStore(IPersister persister, IHost host)
        {
            _persister = persister;
            _host = host;

            DefaultRoles = new[] {"Everyone", "Members", "Editors", "Administrators"};
        }

		public Navigator(IPersister persister, IHost host, VirtualNodeFactory nodes, ContentSource sources)
		{
			this.persister = persister;
			this.host = host;
			this.virtualNodes = nodes;
			this.sources = sources;
		}

        public DiagnosticController(IContentItemRepository repository, IHost host, IDefinitionManager definitions,
            ILinkGenerator linkGenerator, IUrlParser parser, DatabaseSection config, IFlushable flushable, IReplicationStorage repstore, 
            IFileSystemFactory fileSystemFactory)
        {
            _repository = repository;
            _host = host;
            _definitions = definitions;
            _linkGenerator = linkGenerator;
            _parser = parser;
            _flushable = flushable;
            _tablePrefix = config.TablePrefix;

            _repstore = repstore;

            if (_forceWriteLockManager != null) return;

            // Create Force Write Lock Manager
            var storageConfig = (FileSystemNamespace) Enum.Parse(typeof (FileSystemNamespace),
                ConfigurationManager.AppSettings["AzureReplicationStorageContainerName"] ??
                "ReplicationStorageDebug");

            var fileSystem = fileSystemFactory.Create(storageConfig);
            _forceWriteLockManager = new ReplicationForceWriteLockManager(fileSystem);
            _writeLockManager = new ReplicationWriteLockManager(fileSystem);
        }

 private void Given_Engine()
 {
     this.host = mr.Stub<IHost>();
     engine = new OllyLang();
     engine.Host = host;
     engine.Debugger = new Debugger(null);
 }

		public DefaultDirectorySelector(IHost host, EditSection config)
		{
			this.host = host;
			mode = config.DefaultDirectory.Mode;
			defaultFolderPath = config.DefaultDirectory.RootPath;
			uploadFolders = new List<string>(config.UploadFolders.Folders);
		}

        public bool SelectRootDirectory(IHost host, bool force)
        {
            string path = this.RootDirectory;
            string initDir;
            if (String.IsNullOrEmpty(path) || !Directory.Exists(path))
            {
                initDir = null;
            }
            else
            {
                initDir = path;
                if (!force && IsValidDir(initDir))
                {
                    return true;
                }
            }

            path = SimpleDialog.OpenFolder(initDir, "Please specify de4dot's root directory.");
            if (String.IsNullOrEmpty(path) || !Directory.Exists(path)) 
                return false;

            if (!IsValidDir(path)) 
                return false;

            this.RootDirectory = path;
            return true;
        }

 public void Edit(IHost host)
 {
     var editor = host.GetEditor<ClassDiagramEditor>(this, "Edit diagram");
     editor.DiagramNode = this;
     editor.LoadData();
     host.ShowEditor(editor);
 }

 internal SandboxedHost(IHost host, IObjectAccessor accessor, MicroScheduler scheduler)
 {
     m_host = host;
     m_accessor = accessor;
     m_graphics = new SandboxedGraphics(host.Graphics);
     m_scheduler = scheduler;
 }

        public void ViewTableContent(IHost host)
        {
            try
            {
                //var db = Parent as DataBaseElement;
                //IDbConnection connection = db.GetConnection();
                //IDbCommand command = connection.CreateCommand();
                //command.CommandText = string.Format("select * from [{0}]", Name);
                //connection.Open();
                //IDataReader reader = command.ExecuteReader();


                //var dt = new DataTable();
                //dt.Load(reader);

                //reader.Close();
                //connection.Close();
                //var editor = host.GetEditor<TableDataView>(this, "View Table");
                //editor.Data = dt;
                //host.ShowEditor(editor);
            }
            catch (Exception)
            {
                MessageBox.Show("An error occured");
            }
        }

 private HostManager(IHost host)
 {
     this.Host = host;
     this.Host.Start += this.HandleHostStart;
     this.Host.IncomingRequestReceived += this.HandleHostIncomingRequestReceived;
     this.Host.IncomingRequestProcessed += this.HandleIncomingRequestProcessed;
 }

 public FileUploadOrDownload(IHost host, Shell shellData, string sourceFilePath, string targetFilePath)
 {
     _host = host;
     _shellData = shellData;
     _sourceFilePath = sourceFilePath;
     _targetFilePath = targetFilePath;
 }

        public StringLiteral(IHost host, string value)
            : base(host)
        {
            base.Name = "string";

            if (IsWrappedInQuotes(value))
            {
                ValueType = ValueType.StringLiteral;
                //strip quotes

                int offset = StartsWith(value, '@') ? 2 : 1;
                value = new string(value.ToArray(), offset, value.Length - (offset + 1));
            }
            else if (value == "this")
            {
                ValueType = ValueType.Local;
            }
            else if (value == "null" || value == "true" || value == "false")
            {
                ValueType = ValueType.Keyword;
            }
            else
            {
                ValueType = ValueType.Property;
            }

            if (ValueType == ValueType.StringLiteral)
            {
                Values = Parse(value);
            }
        }

        public ActiveSolutionBoundTracker(IHost host, IActiveSolutionTracker activeSolutionTracker)
        {
            if (host == null)
            {
                throw new ArgumentNullException(nameof(host));
            }

            if (activeSolutionTracker == null)
            {
                throw new ArgumentNullException(nameof(activeSolutionTracker));
            }

            this.extensionHost = host;
            this.solutionTracker = activeSolutionTracker;

            this.solutionBindingInformationProvider = this.extensionHost.GetService<ISolutionBindingInformationProvider>();
            this.solutionBindingInformationProvider.AssertLocalServiceIsNotNull();

            this.errorListInfoBarController = this.extensionHost.GetService<IErrorListInfoBarController>();
            this.errorListInfoBarController.AssertLocalServiceIsNotNull();
            this.errorListInfoBarController.Refresh();

            // The user changed the binding through the Team Explorer
            this.extensionHost.VisualStateManager.BindingStateChanged += this.OnBindingStateChanged;

            // The solution changed inside the IDE
            this.solutionTracker.ActiveSolutionChanged += this.OnActiveSolutionChanged;

            this.IsActiveSolutionBound = this.solutionBindingInformationProvider.IsSolutionBound();
        }

 internal Statement(IHost host)
     : base(host)
 {
     Attributes = new AttributeList(host);
     Children = new StatementList(host);
     Parameters = new ParameterList(host);
 }

        public PanelDbManager(IHost host, PluginParameter data)
        {
			_host = host;
			_shellData = (Shell)data[0];
			_shellSqlConn = GetShellSqlConn();

			// init StrRes to translate string
			StrRes.SetHost(_host);
            Init();			

            //绑定事件
			_dbManager = new DbManager(_host, _shellData, _shellSqlConn.type);
			_dbManager.ConnectDbCompletedToDo += DbManagerConnectDbCompletedToDo;
			_dbManager.GetDbNameCompletedToDo += DbManagerGetDbNameCompletedToDo;
			_dbManager.GetDbTableNameCompletedToDo += DbManagerGetTableNameCompletedToDo;
			_dbManager.GetColumnTypeCompletedToDo += DbManagerGetColumnTypeCompletedToDo;
			_dbManager.ExecuteReaderCompletedToDo += DbManagerExecuteReaderCompletedToDo;
			_dbManager.ExecuteNonQueryCompletedToDo += DbManagerExecuteNonQueryCompletedToDo;

			RefreshServerStatus(false);


	        if (string.IsNullOrEmpty(_shellSqlConn.type) || string.IsNullOrEmpty(_shellSqlConn.conn))
	        {
		        MessageBox.Show("shell's sqlConnection is null or space");
	        }
	        else
	        {
				//连接数据库
				_dbManager.ConnectDb(_shellSqlConn.conn);
	        }
        }

 public DirectUrlInjector(IHost host, IUrlParser parser, IContentItemRepository repository, IDefinitionManager definitions)
 {
     this.host = host;
     this.parser = parser;
     this.repository = repository;
     this.definitions = definitions;
 }

 public MongoInstallationManager(MongoDatabaseProvider database, IHost host, IPersister persister, ConnectionMonitor connectionContext, Importer importer, IWebContext webContext, ContentActivator activator)
     : base(connectionContext, importer, webContext, persister, activator)
 {
     this.database = database;
     this.host = host;
     this.persister = persister;
 }

 HostManager(IHost host)
 {
     Host = host;
     Host.Start += HandleHostStart;
     Host.IncomingRequestReceived += HandleHostIncomingRequestReceived;
     Host.IncomingRequestProcessed += HandleIncomingRequestProcessed;
 }

 public DocumentView(IHost host, IRendererFactory rendererFactory, IDictionary<string, object> documentHost, Document document)
 {
     DocumentHost = documentHost;
     _host = host;
     _rendererFactory = rendererFactory;
     _document = document;
 }