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);
}
}
