public void ShouldSerializeDatesAccodingToIso8601() { var entity = new JsonObjectTests.User(timestamp: new DateTime(2011, 06, 01, 12, 04, 34, 444, DateTimeKind.Utc)); dynamic fragment = NewtonsoftSerializer.SerializeAsJsonObject(entity); Assert.Equal("2011-06-01T12:04:34.444Z", (string)fragment.timestamp); }
public void ShouldSerializeEnumsAsString() { var entity = new JsonObjectTests.User(sex: JsonObjectTests.UserSex.Female); dynamic fragment = NewtonsoftSerializer.SerializeAsJsonObject(entity); Assert.Equal("Female", (string)fragment.sex); }
public RedisRepository() { _redisUrl = "127.0.0.1"; RefreshingRedis = false; var redisConfiguration = new RedisConfiguration() { AbortOnConnectFail = true, KeyPrefix = "", Hosts = new RedisHost[] { new RedisHost() { Host = this._redisUrl, Port = 6379 } }, AllowAdmin = true, ConnectTimeout = 3000, Database = 0, Ssl = false, Password = "", ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw } }; _serializer = new NewtonsoftSerializer(); _cacheClient = new StackExchangeRedisCacheClient(_serializer, redisConfiguration); _sqlLiteRepository = new SqlLiteRepository(); }
public ICacheClient GetCurrent(string connectionString) { if (!HttpContext.Current.Items.Contains(REDIS_CONTEXT_KEY)) { int port = 6379; var parts = connectionString.Split(':'); if (parts.Length == 2) { Int32.TryParse(parts[1], out port); } ISerializer serializer = new NewtonsoftSerializer(); RedisConfiguration configuration = new RedisConfiguration() { Hosts = new RedisHost[] { new RedisHost() { Host = parts[0], Port = port } } }; var redisClient = new StackExchangeRedisCacheClient(serializer, configuration); HttpContext.Current.Items.Add(REDIS_CONTEXT_KEY, redisClient); } return(HttpContext.Current.Items[REDIS_CONTEXT_KEY] as ICacheClient); }
public void ShouldConvertPropertyNameToCamelCase() { var entity = new JsonObjectTests.User(name: "john"); dynamic fragment = NewtonsoftSerializer.SerializeAsJsonObject(entity); Assert.NotNull((string)fragment.name); }
public NotificationRedisClientRequest(NotificationClientConfiguration configuration) { var serializer = new NewtonsoftSerializer(); _cacheKey = configuration.RedisKey; _cache = new StackExchangeRedisCacheClient(serializer, configuration.RedisConnectionString); }
public async Task <IEnumerable <string> > FindByKey(string keyPart) { var serializer = new NewtonsoftSerializer(); var cacheClient = new StackExchangeRedisCacheClient(_redis, serializer); return(await cacheClient.SearchKeysAsync($"*{keyPart}*")); }
public static ICacheClient GetClient(DataSettings dataSettings) { ISerializer serializer = new NewtonsoftSerializer(); var conn = ConnectionMultiplexer.Connect(dataSettings.RawSettings["RedisConnectionString"]); return(new StackExchangeRedisCacheClient(conn, serializer, int.Parse(dataSettings.RawSettings["RedisDbIndex"]))); }
internal static string ToUriString(LuceneQuery viewQuery, ISerializer serializer = null) { if (viewQuery.DesignDocumentName.HasNoValue() || viewQuery.IndexName.HasNoValue()) { return(null); } if (serializer == null) { serializer = new NewtonsoftSerializer(); } var uri = new StringBuilder(); uri.Append("_design/") .Append(viewQuery.DesignDocumentName) .Append("/") .Append(viewQuery.IndexName); var queryString = OptionListSerializer.ToQueryString(viewQuery, serializer); if (queryString.Length > 0) { uri.Append("?").Append(queryString); } return(uri.ToString()); }
private static ICacheClient GetClient() { var redisConfiguration = new RedisConfiguration() { AbortOnConnectFail = true, //KeyPrefix = "_my_key_prefix_", Hosts = new RedisHost[] { new RedisHost() { Host = "localhost" }, }, AllowAdmin = true, ConnectTimeout = 3000, Database = 0, //Ssl = true, //Password = "******", ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw } }; var serializer = new NewtonsoftSerializer(); var client = new StackExchangeRedisCacheClient(serializer, redisConfiguration); return(client); }
} // TODO use RedisCacheClient private RedisAccess() { _serializer = new NewtonsoftSerializer(); var redisConfiguration = RedisCachingSectionHandler.GetConfig(); RedisCacheClient = new StackExchangeRedisCacheClient(_serializer, redisConfiguration); }
static RedisStackExchangeHelper() { if (lazyConnection == null || !lazyConnection.IsValueCreated) { lazyConnection = new Lazy <ConnectionMultiplexer>(() => { ConfigurationOptions config = new ConfigurationOptions() { SyncTimeout = 500000, EndPoints = { { host, port } }, Password = password, AbortOnConnectFail = false, AllowAdmin = true }; return(ConnectionMultiplexer.Connect(config)); }); } var serializer = new NewtonsoftSerializer(); cacheClient = new StackExchangeRedisCacheClient(lazyConnection.Value, serializer); }
public RedisCacheFactory() { var serializer = new NewtonsoftSerializer(); var connection = GetConnection(); this.Client = new StackExchangeRedisCacheClient(connection, serializer); }
static void Main(string[] args) { //Target.Register<DevToolTarget>("DevTool"); NullTarget blackhole = new NullTarget(); LoggingConfiguration conf = LogManager.Configuration; // FIXME Evite un bouclage des logs internes avec leurs envoies. Boucle infini ... conf.AddRuleForAllLevels(blackhole, "DevToolsConnector.*", true); conf.AddRuleForAllLevels(blackhole, "DevToolsMessage.*", true); conf.AddTarget("DevTool", _targetOuput); conf.AddRuleForAllLevels(_targetOuput); LogManager.Configuration = conf; var serializer = new NewtonsoftSerializer(); var server = new DevToolServer(new DevSocketFactory(serializer)); server.Bound(); server.RegisterListener <DevIdentificationRequest>(IdentificationRequestHandler); server.RegisterListener <DevStartSendLogsRequest>(OnSetLogConfig); LOGGER.Debug("Enter to stop console."); Console.ReadLine(); server.UnRegisterListener <DevIdentificationRequest>(IdentificationRequestHandler); server.UnRegisterListener <DevStartSendLogsRequest>(OnSetLogConfig); server.Close(); }
public NewtonsoftQueueServiceIntegrationTest() { _queueConfig = GetConfiguration(); _queueService = new QueueService(_queueConfig); _queueName = "newtonsoft-test-queue"; _queueServiceClient = GetQueueServiceClient(); _serializeTestValidator = new NewtonsoftSerializer(_queueConfig.OptionalSerializeSettings as Newtonsoft.Json.JsonSerializerSettings); }
public RedisConnection(NoSqlConnectionString connectionString) { _connection = ConnectionMultiplexer.Connect(connectionString.Url); var serializer = new NewtonsoftSerializer(); _cacheClient = new StackExchangeRedisCacheClient(_connection, serializer); }
public JsonSerializerFacade(params Type[] objectTypes) { this.objectTypes = objectTypes; mapper = new MessageMapper(); mapper.Initialize(objectTypes); var settings = new SettingsHolder(); serializer = new NewtonsoftSerializer().Configure(settings)(mapper); }
/// <summary> /// Constructor: read settings from "config file" (or in this case the ConfigSettings class) and instatiate object instances. /// </summary> static Program() { _activitiesRequestUri = string.Concat(ConfigSettings.BaseRequestUri, ConfigSettings.ActivitiesRequestUri); _positionsRequestUri = string.Concat(ConfigSettings.BaseRequestUri, ConfigSettings.PositionsRequestUri); _apiClient = new ApiClient(new RestHttpClient(ConfigSettings.BaseUrl), NewtonsoftSerializer.GetInstance()); _parentItems = new List <Activity>(); }
public void ShouldSerializePublicFields() { var entity = new JsonObjectTests.User { Field = "quantum mechanics" }; dynamic fragment = NewtonsoftSerializer.SerializeAsJsonObject(entity); Assert.Equal("quantum mechanics", (string)fragment.field); }
public void SaveTempProduct(Product product) { var serializer = new NewtonsoftSerializer(); var cacheClient = new StackExchangeRedisCacheClient(serializer); var productList = new List <Product>(); productList.Add(product); cacheClient.Add("abc", product); }
private static StackExchangeRedisCacheClient GetCacheClient(string connectionString) { var serializer = new NewtonsoftSerializer(); if (string.IsNullOrWhiteSpace(connectionString)) return new StackExchangeRedisCacheClient(serializer); else { return new StackExchangeRedisCacheClient(serializer, connectionString, GetDefaultDatabase(connectionString)); } }
public T Read <T>(string key) { serializer = new NewtonsoftSerializer(); var redisConfiguration = RedisCachingSectionHandler.GetConfig(); using (cacheClient = new StackExchangeRedisCacheClient(serializer, redisConfiguration)) { return(cacheClient.Get <T>(key)); } }
//todo: make test more clear and informative public void Serialization_RatingTypeAsKey() { var serializer = new NewtonsoftSerializer(); var serialized = serializer.Serialize(new Dictionary <RatingType, string> { { RatingType.All, "now" } }); serializer.Deserialize <Dictionary <RatingType, string> >(serialized); }
public GeoService(string host) { _redis = ConnectionMultiplexer.Connect(host); var serializer = new NewtonsoftSerializer(); _client = new StackExchangeRedisCacheClient(_redis, serializer); Seed(); }
public JsonSerializerFacade(params Type[] objectTypes) { this.objectTypes = objectTypes; mapper = new MessageMapper(); mapper.Initialize(objectTypes); var settings = new SettingsHolder(); #pragma warning disable CS0618 // Type or member is obsolete serializer = new NewtonsoftSerializer().Configure(settings)(mapper); #pragma warning restore CS0618 // Type or member is obsolete }
static RedisConnectorHelper() { string ip = ConfigurationManager.AppSettings["IP"]; string port = ConfigurationManager.AppSettings["Port"]; string allowAdmin = ConfigurationManager.AppSettings["allowAdmin"]; var serializer = new NewtonsoftSerializer(); _lazyConnectionExt = new Lazy <StackExchangeRedisCacheClient>( () => new StackExchangeRedisCacheClient( ConnectionMultiplexer.Connect($"{ip}:{port}, allowAdmin={allowAdmin}"), serializer)); }
public bool Save <T>(string key, T value) { bool isSuccess; serializer = new NewtonsoftSerializer(); var redisConfiguration = RedisCachingSectionHandler.GetConfig(); using (cacheClient = new StackExchangeRedisCacheClient(serializer, redisConfiguration)) { isSuccess = cacheClient.Add <T>(key, value); } return(isSuccess); }
StackExchangeRedisCacheClient InitRedisCacheClient() { Contract.Ensures(Contract.Result <StackExchangeRedisCacheClient>() != null); var connectionMultiplexer = ConnectionMultiplexer.Connect("localhost"); var settings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }; var serializer = new NewtonsoftSerializer(settings); return(new StackExchangeRedisCacheClient(connectionMultiplexer, serializer)); }
private static ICacheClient CreateCacheClient() { var connString = ConfigurationManager.ConnectionStrings["azure.Redis"]; if (connString == null) { return(null); } ISerializer serializer = new NewtonsoftSerializer(); return(new StackExchangeRedisCacheClient(serializer, connString.ConnectionString, 1000)); }
public void Open(RedisConfig config) { var serializer = new NewtonsoftSerializer(); var connectionString = config.GetRedisConfiguration(); try { _client = new StackExchangeRedisCacheClient(serializer, connectionString); } catch (Exception) { _client = null; } }
public IExtractionManager GetExtractionManager() { var context = new ConcreteContext <EntityFramework>(); var dataContextDecExt = new DataContextDeclarationExtractor(context); var dbEntityExt = new DatabaseEntityDeclarationExtractorUsingDbContextProperties(context); var dbAccessingMethodCallExt = new DatabaseAccessingMethodCallExtractor(context); var codeExecutionPathExt = new CodeExecutionPathGenerator(context); var progressIndicator = new Progress <ExtractionProgress>((e) => ProgressChanged(e)); var serializer = new NewtonsoftSerializer <EntityFramework>(); IExtractionManager extractionManager = new ExtractionManager <EntityFramework>(dataContextDecExt, dbEntityExt, dbAccessingMethodCallExt, codeExecutionPathExt, progressIndicator, serializer); return(extractionManager); }
private void Open(string path) { try { var serializer = new NewtonsoftSerializer(); var project = Project.Open(path, serializer); if (project != null) { var documents = project.Documents.FirstOrDefault(); if (documents != null && documents.Containers != null) { ProjectViewer.Show(documents.Containers); } } } catch (Exception ex) { MessageBox.Show( string.Format("{0}{1}{2}", ex.Message, Environment.NewLine, ex.StackTrace), "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }