public Infrastructure.IMessageQueue GetOrAdd(object service, Infrastructure.ProcessingMode mode)
        {
            var key = new Tuple<object, ProcessingMode>(service, mode);

            var queue = _queues.GetOrAdd(key, CreateQueue(key));
            return queue;
        }

        public IEnumerable<Order> FindBy(Infrastructure.Query query)
        {
            IList<Order> orders = new List<Order>();

            using (SqlConnection conn = new SqlConnection(_connectionString)) 
            {
                SqlCommand cmd = conn.CreateCommand();
                query.TranslateInfo(cmd);
                conn.Open();

                using (SqlDataReader reader = cmd.ExecuteReader())
                {
                    while (reader.Read()) 
                    {
                        orders.Add(new Order() 
                        {
                            CustomerId = new Guid(reader["CustomerId"].ToString()),
                            OrderDate = DateTime.Parse(reader["OrderDate"].ToString()),
                            Id = new Guid(reader["Id"].ToString()),
                        });
                    }
                }
            }

            return orders;
        }

        public RESTScreenViewModel(Infrastructure infrastructure, CodeEditorViewModel requestBodyViewModel,
            CodeEditorViewModel resultViewModel)
        {
            Ensure.ArgumentNotNull(infrastructure, "infrastructure");

            ResultEditor = resultViewModel;
            RequestBodyEditor = requestBodyViewModel;

            _infrastructure = infrastructure;
            base.DisplayName = "REST";
            _eventAggregator = infrastructure.EventAggregator;

            Methods = new List<ComboBoxItemViewModel>
            {
                ComboBoxItemViewModel.FromString("GET"),
                ComboBoxItemViewModel.FromString("POST"),
                ComboBoxItemViewModel.FromString("PUT"),
                ComboBoxItemViewModel.FromString("DELETE"),
                ComboBoxItemViewModel.FromString("HEAD"),
                ComboBoxItemViewModel.FromString("OPTIONS"),
                ComboBoxItemViewModel.FromString("TRACE"),
                ComboBoxItemViewModel.FromString("PATCH"),
            };
            Method = "GET";
        }

        public ServicesManager(
            INutConfiguration configurationManager,
            Infrastructure.ConfigurationManagement.DbConfigurationSettings.Factory dbConfigurationSettingsFactory,
            IEventBus eventBus,
            IEnumerable<IReportPeriodically> pushServices,
            IEnumerable<IRemoteInvocationService> remoteInvokedServices,
            Services.IGlobalSettingsService globalSettings,
            Func<RegisteredPackagesPollingClient> packagesPollerFactory,
            Func<PollingClientCollection> pollingCollectionFactory,
            Repositories.IPackageRepository packageRepository,
            IHoardeManager hoardeManager)
        {
            _log = LogProvider.For<ServicesManager>();

            _configurationManager = configurationManager;
            _dbConfigurationSettingsFactory = dbConfigurationSettingsFactory;
            _eventBus = eventBus;
            _pushServices = pushServices;
            _remoteInvokedServices = remoteInvokedServices;
            _globalSettings = globalSettings;

            _packagesPollerFactory = packagesPollerFactory;
            _pollingCollectionFactory = pollingCollectionFactory;

            _packageRepository = packageRepository;

            _hoardeManager = hoardeManager;
        }

 protected override int PickOutputChannel(Infrastructure.ChannelMessageEventArgs e)
 {
     if (e.Message.Headers.ContainsKey("ProductType"))
         return (string)e.Message.Headers["ProductType"] == "Cars" ? 0 : 1;
     else
         return base.PickOutputChannel(e);
 }

        public MovieBookingService(Infrastructure.IBus bus)
        {
            this.bus = bus;

            this.cinemaList = new List<string>() { "Streatham", "Brixton", "West Norwood" };
            this.movieList = new List<string>() { "Captain America", "Thor", "The Hunger Games", "The Hunt for Red October" };
        }

 /// <summary>
 /// 保存设置到配置中
 /// </summary>
 /// <param name="info"></param>
 public void SaveSetting(Infrastructure.Crosscutting.Updater.UpdateInfo info)
 {
     info.DeleteFileLimits = this.deleteRules.Lines;
     info.DeleteMethod = (Infrastructure.Crosscutting.Updater.DeletePreviousProgramMethod)this.deletePreviousFileMode.SelectedIndex;
     info.RequiredMinVersion = this.requiredMinVersion.Text;
     info.PackagePassword = this.txtPackagePassword.Text;
 }

 /// <summary>
 /// 根据配置更新界面
 /// </summary>
 /// <param name="info"></param>
 public void UpdateInterface(Infrastructure.Crosscutting.Updater.UpdateInfo info)
 {
     this.deletePreviousFileMode.SelectedIndex = (int)info.DeleteMethod;
     this.deleteRules.Text = info.DeleteFileLimits.IsEmpty() ? "" : string.Join(Environment.NewLine, info.DeleteFileLimits);
     this.requiredMinVersion.Text = info.RequiredMinVersion;
     this.txtPackagePassword.Text = info.PackagePassword ?? "";
 }

        /// <summary>
        /// Initializes a new instance of an object.
        /// </summary>
        /// <param name="id">Grou Id.</param>
        /// <param name="name">Group name.</param>
        /// <param name="query">Current search query.</param>
        public SearchResultGroup(string id, string name, Infrastructure.Search.SearchQuery query)
        {
            this.Name = name;
            this.Excerpt = string.Empty;
            this.Url = url => { return url.Action("Index", "Home", new { q = query.WithoutCriterion("skip").WithoutCriterion("take").WithCriterion("in", id).ToString() }); };

            this.Results = new List<SearchResultBase>();
        }

        /// <summary>
        /// Creates a tab that will load the given tab data when opened.
        /// </summary>
        /// <param name="tabData">The tab data to be loaded.</param>
        public Tab(Infrastructure.Tab tabData)
            : this()
        {
            NavigateFirst = true;

            this.TabData = tabData;
            this.Title = tabData.Title;
        }

        void Instance_DownloadProgressChanged(object sender, Infrastructure.Crosscutting.Updater.Wrapper.RunworkEventArgs e)
        {
            pbProgress.Style = ProgressBarStyle.Blocks;
            pbProgress.Value = e.Progress.TaskPercentage;

            if (!string.IsNullOrEmpty(e.Progress.StateMessage)) lblProgressDesc.Text = e.Progress.StateMessage;
            else lblProgressDesc.Text = string.Format("{0}/{1}", ExtensionMethod.ToSizeDescription(e.Progress.TaskProgress), ExtensionMethod.ToSizeDescription(e.Progress.TaskCount));
        }

 public override FrameworkElement LoadXaml(IDeviceAgent devices, KioskState state, Infrastructure.ObjectModel.TransactionContextBase transactionContext)
 {
     FrameworkElement viewGrid = base.LoadXaml(devices, state, transactionContext);
     DProcessPayment doPayment = new DProcessPayment(this.DoPayment);
     Devices.GetCashAcceptor().NoteStackedEvent += OnNoteStackedEvent;
     doPayment.BeginInvoke(null, null);
     return viewGrid;
 }

 //IPeopleService _peopleService;
 public AddressBookViewModel(IPeopleRepository repository, Infrastructure.IView view)
 {
     //_peopleService = peopleService;
     //this.People = _peopleService.GetAll().ToList();
     var people = repository.GetAll().ToList();
     _people = people;
     View = view;
     View.ViewModel = this;
 }

 public DataViewerViewModel(Infrastructure infrastructure, TypesListViewModel typesListViewModel,
     PaggerViewModel paggerModel)
     : base(infrastructure)
 {
     _infrastructure = infrastructure;
     TypesList = typesListViewModel;
     base.DisplayName = "Data Viewer";
     PaggerModel = paggerModel;
     paggerModel.OnPageChanged = View;
 }

 public SinaController(Infrastructure.Crosscutting.Authorize.IUserService user,
     Infrastructure.Crosscutting.Authorize.IUserExtensionService userExtension)
 {
     if (user == null)
     {
         throw new ArgumentNullException("userService is null");
     }
     userService = user;
     userExtensionService = userExtension;
 }

 public Locale Build(Infrastructure.Data.Locale dataLocale, bool hasPhoto)
 {
     return new Locale(dataLocale.LocaleID)
     {
         Latitude = dataLocale.Lat,
         Longitude = dataLocale.Long,
         Name = dataLocale.LocaleName.Trim(),
         HasPhotos = hasPhoto
     };
 }

        private ImportSummary HandleResponse(Infrastructure.Http.Response response)
        {
            if (response.StatusCode == HttpStatusCode.OK)
            {
                return _client.JsonMapper.From<SetupResponse>(response.Body).ImportSummary;
            }

            _client.HandleErrors(response);

            return null;
        }

 private Association HandleAssociationResponse(Infrastructure.Http.Response response)
 {
     if (response.StatusCode == HttpStatusCode.OK
         || response.StatusCode == HttpStatusCode.Created
         || response.StatusCode == HttpStatusCode.Accepted)
     {
         return Client.JsonMapper.From<Association>(response.Body);
     }
     Client.HandleErrors(response);
     return null;
 }

 void ControlChannels_MessageReceivedOnChannel(object sender, Infrastructure.ChannelMessageEventArgs e)
 {
     if (e.Message != null && e.Message.Headers.ContainsKey(HeaderName.PressureValue)
                           && e.Message.Headers.ContainsKey(HeaderName.PressureChannel))
     {
         string name = (string)e.Message.Headers[HeaderName.PressureChannel];
         if (!mChannelPressure.ContainsKey(name))
             mChannelPressure.Add(name, 0);
         mChannelPressure[name] += (double)e.Message.Headers[HeaderName.PressureValue];
     }
 }

        public MappingsInfoViewModel(TypesListViewModel typesListViewModel, Infrastructure infrastructure)
            : base(infrastructure)
        {
            _infrastructure = infrastructure;
            TypesList = typesListViewModel;
            TypesList.PropertyChanged += (sender, args) =>
            {
                if (args.PropertyName != "SelectedType") return;

                LoadMapping();
            };
        }