C# IConfiguration.GetValue方法代码示例

        internal RippleApi(IConfiguration config, ILogger logger, IFeeProvider feeProvider, ITransactionSigner txSigner, string dataApiUrl, string exchIssuerAddress, string fiatCurrencyCode)
        {
            _config = config;
            _logger = logger;
            _feeProvider = feeProvider;
            _txSigner = txSigner;
            _dataApiUrl = dataApiUrl;
            _issuerAddress = exchIssuerAddress;
            _fiatCurreny = fiatCurrencyCode;
            _walletAddress = _config.AccessKey;

            _webSocket = new WebSocket(_rippleSocketUri = _config.GetValue("server"));

            string proxyHost = _config.GetValue("proxyHost");
            string proxyPort = _config.GetValue("proxyPort");
            if (null != proxyHost && null != proxyPort)
            {
                //TODO: these two lines don't belong here, rather to WebClient2
                _webProxy = new WebProxy(proxyHost, int.Parse(proxyPort));
                _webProxy.Credentials = CredentialCache.DefaultCredentials;

                var wsProxy = new HttpConnectProxy(new DnsEndPoint(proxyHost, Int32.Parse(proxyPort)), "1.0");
                _webSocket.Proxy = wsProxy;
            }

            _webSocket.Opened += websocket_Opened;
            _webSocket.Error += websocket_Error;
            _webSocket.Closed += websocket_Closed;
            _webSocket.MessageReceived += websocket_MessageReceived;
        }

        public DefaultSenderConfiguration(IConfiguration configuration)
        {
            m_address = configuration.GetValue(APP_KEY_FROM_ADDRESS);
            m_name = configuration.GetValue(APP_KEY_FROM_NAME);

            if (string.IsNullOrWhiteSpace(m_address))
            {
                throw new ConfigurationMissingException(APP_KEY_FROM_ADDRESS);
            }
        }

        OrderInfoResponse _dummySellOrder; //TODO: DELETE THESE TWO LINES

        #endregion Fields

        #region Constructors

        internal CoinsBankApi(IConfiguration config, ILogger logger, string baseAsset, string counterAsset)
        {
            _config = config;
            _logger = logger;
            _baseAsset = baseAsset.ToUpperInvariant();
            _counterAsset = counterAsset.ToUpperInvariant();
            _dataBaseUrl = config.GetValue("data_api_url");
            _tradeBaseUrl = config.GetValue("trading_base_url");

            _hashMaker = new HMACSHA512(Encoding.ASCII.GetBytes(_config.SecretKey));
        }

 internal BtcChinaApi(IConfiguration config, ILogger logger)
 {
     _config = config;
     _logger = logger;
     var proxyHost = _config.GetValue("proxyHost");
     var proxyPort = _config.GetValue("proxyPort");
     if (null != proxyHost && null != proxyPort)
     {
         _webProxy = new WebProxy(proxyHost, int.Parse(proxyPort));
         _webProxy.Credentials = CredentialCache.DefaultCredentials;
     }
 }

 public LakeBtcApi(IConfiguration config, ILogger logger, string baseCurrencyCode, string arbCurrencyCode)
 {
     _logger = logger;
     var proxyHost = config.GetValue("proxyHost");
     var proxyPort = config.GetValue("proxyPort");
     if (null != proxyHost && null != proxyPort)
     {
         _webProxy = new WebProxy(proxyHost, int.Parse(proxyPort));
         _webProxy.Credentials = CredentialCache.DefaultCredentials;
     }
     /*TODO:del?
     var nonceOffset = Configuration.GetValue("nonce_offset");
     if (!String.IsNullOrEmpty(nonceOffset))
         _nonceOffset = long.Parse(nonceOffset);*/
 }

        public void SaveFrom(IConfiguration config, ConfigurationLevel level, Stream outputStream)
        {
            try {
                var keys = config.GetKeys(level);
                var properties = new Properties();

                foreach (var configKey in keys) {
                    var configValue = config.GetValue(configKey);
                    object value;
                    if (configValue == null || configValue.Value == null) {
                        value = configKey.DefaultValue;
                    } else {
                        value = configValue.Value;
                    }

                    var stringValue = Convert.ToString(value, CultureInfo.InvariantCulture);
                    properties.SetProperty(configKey.Name, stringValue);
                }

                properties.Store(outputStream, String.Empty);
            } catch (DatabaseConfigurationException) {
                throw;
            } catch (Exception ex) {
                throw new DatabaseConfigurationException("Could not save the configurations to the given stream.", ex);
            }
        }

        public FileFolderMailQueue(
            IFileSystem fileSystem = null,
            IConfiguration configuration = null)
        {
            m_settings = new JsonSerializerSettings();
            m_settings.TypeNameHandling = TypeNameHandling.All;
            m_settings.NullValueHandling = NullValueHandling.Ignore;

            m_configuration = configuration ?? new DefaultConfiguration();

            m_fileSystem = fileSystem ?? new DefaultFileSystem();


            m_baseDirectory = m_configuration.GetValue(APP_FOLDER);
            if (string.IsNullOrWhiteSpace(m_baseDirectory))
            {
                throw new ConfigurationMissingException(APP_FOLDER);
            }

            if (!m_fileSystem.ExistDir(m_baseDirectory))
            {
                throw new Exception(string.Format("Directory '{0}' does not exist. Cannot continue.",
                    m_baseDirectory));
            }

            m_fileSystem.CreateDir(m_queueDir = Path.Combine(m_baseDirectory, FOLDER_QUEUE));
            m_fileSystem.CreateDir(m_sentDir = Path.Combine(m_baseDirectory, FOLDER_SENT));
            m_fileSystem.CreateDir(m_errorDir = Path.Combine(m_baseDirectory, FOLDER_ERROR));
            m_fileSystem.CreateDir(m_workerDir = Path.Combine(m_baseDirectory, "worker-" + Guid.NewGuid().ToString()));

        }

        internal HuobiApi(IConfiguration config, ILogger logger)
        {
            _config = config;
            _logger = logger;
            var proxyHost = _config.GetValue("proxyHost");
            var proxyPort = _config.GetValue("proxyPort");
            if (null != proxyHost && null != proxyPort)
            {
                _webProxy = new WebProxy(proxyHost, int.Parse(proxyPort));
                _webProxy.Credentials = CredentialCache.DefaultCredentials;
            }

            var nonceOffset = _config.GetValue("nonce_offset");
            if (!String.IsNullOrEmpty(nonceOffset))
                _timeOffset = long.Parse(nonceOffset) / 10000000;
        }

 public NightlyFrogBoiling(IConfiguration config, ILogger logger)
 {
     _logger = logger;
     _operativeAmount = double.Parse(config.GetValue("operative_amount"));
     _logger.Message("Nightly Frog Boiling trader initialized with operative amount " + _operativeAmount + " BTC");
     _requestor = new BtcChinaApi(config, logger);
 }

        public CookieSession()
        {
            try
            {
                m_configuration = ObjectFactory.GetInstance<IConfiguration>();

                CookieName = m_configuration.GetValue<string>(CONFIG_COOKIENAME, "DRAGON.COOKIE");

                if (HttpContext.Current != null)
                {
                    CheckAndSetHttpContext();
                    SetVariablesFromHttpContext();
                    LoadFromCookie();

                    // WebSocket Requests do not have Response Objects to Save Cookies to
                    if (!HttpContext.Current.IsWebSocketRequest)
                    {
                        SaveToCookie();
                    }
                }
            }
            catch (Exception ex)
            {
                if (Debugger.IsAttached) Debugger.Break();
                throw new Exception("Ctor in CookieSession caught exception.", ex);
            }
        }

        public BitstampApi(IConfiguration config, ILogger logger, string baseAssetCode, string counterAssetCode)
        {
            _config = config;
            _logger = logger;

            _hashMaker = new HMACSHA256(Encoding.ASCII.GetBytes(_config.SecretKey));

            _baseAsset = baseAssetCode;
            _counterAsset = counterAssetCode;

            var proxyHost = _config.GetValue("proxyHost");
            var proxyPort = _config.GetValue("proxyPort");
            if (null != proxyHost && null != proxyPort)
            {
                _webProxy = new WebProxy(proxyHost, int.Parse(proxyPort));
                _webProxy.Credentials = CredentialCache.DefaultCredentials;
            }
        }

        public FileFolderTemplateRepository(
            string directory = null,
            IConfiguration configuration = null,
            IFileSystem fileSystem = null,
            string ignorePrefix = "_")
        {
            m_ignorePrefix = ignorePrefix;
            m_fileSystem = fileSystem ?? new DefaultFileSystem();
            m_configuration = configuration ?? new DefaultConfiguration();
            m_baseFolder = (directory ?? string.Empty).Trim();

            if (string.IsNullOrWhiteSpace(m_baseFolder))
            {
                m_baseFolder = m_configuration.GetValue(APP_KEY_FOLDER);
            }

            if (string.IsNullOrWhiteSpace(m_baseFolder))
            {
                throw new ConfigurationMissingException(APP_KEY_FOLDER);
            }

            var culture = m_configuration.GetValue(APP_KEY_DEFLANG);
            if (!string.IsNullOrWhiteSpace(culture))
            {
                try
                {
                    m_cultureInfo = CultureInfo.CreateSpecificCulture(culture);
                }
                catch (CultureNotFoundException)
                {
                    throw new Exception(string.Format("The specified default culture is " +
                                                      "{0} is invalid. Use format such as " +
                                                      "en and en-us.",
                        culture));
                }
            }

            if (!m_fileSystem.ExistDir(m_baseFolder))
            {
                throw new Exception(string.Format("Template directory {0} does not exist.", m_baseFolder));
            }
        }

        /// <summary>Bitfinex JSON API helper</summary>
        /// <param name="logger">Logger</param>
        /// <param name="minOrderAmount">
        /// Minimum order amount to use when troubleshooting balance inconsistencies
        /// </param>
        public BitfinexApi(IConfiguration config, ILogger logger, double minOrderAmount)
        {
            _config = config;
            _logger = logger;
            var proxyHost = _config.GetValue("proxyHost");
            var proxyPort = _config.GetValue("proxyPort");
            if (null != proxyHost && null != proxyPort)
            {
                _webProxy = new WebProxy(proxyHost, int.Parse(proxyPort));
                _webProxy.Credentials = CredentialCache.DefaultCredentials;
            }

            _minOrderAmount = minOrderAmount;

            var nonceOffset = _config.GetValue("nonce_offset");
            if (!String.IsNullOrEmpty(nonceOffset))
            {
                _nonceOffset = long.Parse(nonceOffset);
            }
        }

 public AeEventBasedEmailClient(IConfiguration configuration)
 {
     configuration = configuration.GetSubsection("EmailClient");
     client = new ImapClient(
         configuration.GetValue("Host"),
         configuration.GetValue("Username"),
         configuration.GetValue("Password"),
         ImapClient.AuthMethods.Login,
         configuration.GetValue<int>("Port"),
         configuration.GetValue<bool>("Secure"),
         configuration.GetValue<bool>("SkipSslValidation"));
     client.NewMessage += (sender, args) =>
                              {
                                  if (args.MessageCount > 0)
                                  {
                                      unread.AddRange(client.SearchMessages(SearchCondition.New())
                                                          .Select(message => new MailMessage
                                                                                 {
                                                                                     Date = message.Value.Date,
                                                                                     Sender =
                                                                                         message.Value.Sender,
                                                                                     Receivers = message.Value.To,
                                                                                     Subject =
                                                                                         message.Value.Subject,
                                                                                     Body = message.Value.Body
                                                                                 }));
                                  }
                              };
 }

        public AeEmailClient(IConfiguration configuration)
        {
            configuration = configuration.GetSubsection("EmailClient");
            client = new ImapClient(
                configuration.GetValue("Host"),
                configuration.GetValue("Username"),
                configuration.GetValue("Password"),
                ImapClient.AuthMethods.Login,
                configuration.GetValue<int>("Port"),
                configuration.GetValue<bool>("Secure"),
                configuration.GetValue<bool>("SkipSslValidation"));

            var unreadMessages = client.SearchMessages(SearchCondition.Unseen());
            foreach (var message in unreadMessages)
            {
                client.SetFlags(Flags.Seen, message.Value);
            }

            unread.AddRange(unreadMessages.Select(message => GetInputMailMessage(message.Value)));

            client.NewMessage += (sender, args) =>
                {
                    var message = client.GetMessage(args.MessageCount - 1, false, true);
                    client.SetFlags(Flags.Seen, message);
                    unread.Add(GetInputMailMessage(message));

                    if (null != MailMessageReceived)
                        {
                            MailMessageReceived(this, args);
                        }
                };
        }