public RabbitMqEndpointBehavior(IEnumerable <Type> knownTypes)
{
this.ConfigRegister = ConfigurationManager.GetSection("serviceTypeRegister") as ServiceTypeRegister
?? new ServiceTypeRegister();
SerializerSettings serializerInfo = this.ConfigRegister.SerializerConfig;
CustomContractResolver resolver = new CustomContractResolver(true, false, this.ConfigRegister.TryToNormalize)
{
DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
};
this.Serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.None,
ContractResolver = resolver
};
if (!serializerInfo.OnlyPublicConstructor)
{
Serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
}
if (serializerInfo.EnablePolymorphicMembers)
{
Serializer.Binder = new OperationTypeBinder(this.ConfigRegister);
Serializer.TypeNameHandling = TypeNameHandling.Objects;
}
}
public void RoundtripNoPrivateSetters()
{
var settings = new SerializerSettings();
settings.RegisterAssembly(typeof(SerializationTests).Assembly);
var serializer = new Serializer(settings);
var modified = new PrivateSetters();
modified.ModifyPrivateProperties();
var buffer = new StringWriter();
serializer.Serialize(buffer, modified);
Dump.WriteLine(buffer);
var deserialized = serializer.Deserialize <PrivateSetters>(buffer.ToString());
foreach (var property in typeof(PrivateSetters).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (property.CanRead && property.GetSetMethod(false) == null)
{
Console.WriteLine("Property " + property.Name + " / " + property.GetValue(modified, null) + " / " + property.GetValue(deserialized, null));
Assert.AreNotEqual(
property.GetValue(modified, null),
property.GetValue(deserialized, null),
"Property " + property.Name);
}
}
}
public string Serialize(Base resource, FhirMimeType type = FhirMimeType.Json)
{
switch (Version)
{
case FhirVersion.R3:
var settingsR3 = new SerializerSettings {
Pretty = true
};
return(type == FhirMimeType.Json
? new R3Serialization.FhirJsonSerializer(settingsR3).SerializeToString(resource)
: new R3Serialization.FhirXmlSerializer(settingsR3).SerializeToString(resource));
case FhirVersion.R4:
var settingsR4 = new SerializerSettings {
Pretty = true
};
return(type == FhirMimeType.Json
? new R4Serialization.FhirJsonSerializer(settingsR4).SerializeToString(resource)
: new R4Serialization.FhirXmlSerializer(settingsR4).SerializeToString(resource));
default:
return(default);
}
}
private void Roundtrip <T>(SerializerSettings settings)
where T : new()
{
settings.RegisterAssembly(typeof(SerializationTests).Assembly);
var serializer = new Serializer(settings);
var buffer = new StringWriter();
var original = new T();
serializer.Serialize(buffer, original);
Dump.WriteLine(buffer);
var bufferText = buffer.ToString();
var copy = serializer.Deserialize <T>(bufferText);
foreach (var property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (property.CanRead && property.CanWrite)
{
Assert.AreEqual(
property.GetValue(original, null),
property.GetValue(copy, null));
}
}
}
public void SerializeToString_WhenBatchedVersionedMessage_ExpectCorrectString()
{
// Arrange
var serializerSettings = new SerializerSettings {
SerializerType = SerializerType.Json
};
var messageSerializer = new MessageSerializer(serializerSettings);
var testEntity = new TestEntity {
Data = "val"
}.SerializeToVersionedMessage(SerializerType.Json);
var batchedVersionedMessage = new BatchedVersionedMessage {
Messages = new List <VersionedMessage> {
testEntity
}
};
// Act
var stopwatch = Stopwatch.StartNew();
var serializeToString = messageSerializer.SerializeToString(batchedVersionedMessage);
stopwatch.Stop();
// Assert
this.WriteTimeElapsed(stopwatch);
Assert.That(serializeToString, Is.EqualTo("{\"m\":[{\"v\":{\"T\":\"TestEntity\",\"Ma\":1,\"Mi\":0,\"P\":0,\"VT\":0,\"VTV\":0},\"d\":\"{\\\"Data\\\":\\\"val\\\"}\"}]}"));
}
public void TestSimpleObjectAndPrimitive()
{
var text = @"!MyObject
A0Anchor: &o1 Test
A1Alias: *o1
Array: [1, 2, 3]
ArrayContent: [1, 2]
Bool: true
BoolFalse: false
Byte: 2
Double: 6.6
Enum: B
EnumWithFlags: A, B
Float: 5.5
Int16: 3
Int32: 5
Int64: 7
SByte: 1
String: This is a test
UInt16: 4
UInt32: 6
UInt64: 8
".Trim();
var settings = new SerializerSettings()
{
LimitPrimitiveFlowSequence = 20
};
settings.RegisterTagMapping("MyObject", typeof(MyObject));
SerialRoundTrip(settings, text);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameSystem" /> class.
/// </summary>
/// <param name="registry">The registry.</param>
public YamlManager(IServiceRegistry registry) : base(registry)
{
Services.AddService(this);
yamlSettings = new SerializerSettings();
attributeRegistry = yamlSettings.Attributes;
serializer = new Serializer(yamlSettings);
}
public void RoundtripWithDefaults()
{
var settings = new SerializerSettings()
{
EmitDefaultValues = true
};
settings.RegisterAssembly(typeof(SerializationTests).Assembly);
var serializer = new Serializer(settings);
var buffer = new StringWriter();
var original = new X();
serializer.Serialize(buffer, original);
Dump.WriteLine(buffer);
var bufferText = buffer.ToString();
var copy = serializer.Deserialize <X>(bufferText);
foreach (var property in typeof(X).GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
if (property.CanRead && property.CanWrite)
{
Assert.Equal(
property.GetValue(original, null),
property.GetValue(copy, null));
}
}
}
public override object Deserialize(BinaryTypesReader br, Type type, SerializerSettings settings, ISerializerArg serializerArg)
{
var classMap = SerializerRegistry.GetClassMap(type); //todo: also base types?
var fastReflectionClassMap = GetFastReflectionClassMap(type);
var propNames = fastReflectionClassMap.PropertyInfos.Keys.ToList();
var instance = fastReflectionClassMap.CreateInstance(Type.EmptyTypes); //Activator.CreateInstance(type);
foreach (var propName in propNames)
{
MemberMap memberMap = classMap?.GetMemberMap(propName);
if (memberMap?.Ignored == true)
{
continue;
}
var pInfo = fastReflectionClassMap.PropertyInfos[propName];
pInfo.Setter(
ref instance,
Serializer.DeserializeObject(br, pInfo.PropertyType, settings, memberMap?.Serializer, memberMap?.SerializerArg));
}
return(instance);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameSystem" /> class.
/// </summary>
/// <param name="game">The game.</param>
public YamlManager(Game game) : base(game)
{
Services.AddService(this);
yamlSettings = new SerializerSettings();
attributeRegistry = yamlSettings.Attributes;
serializer = new Serializer(yamlSettings);
}
public void Ignored_WhenInternalSetter_DefaultsToTrue()
{
SerializerSettings context = new SerializerSettings();
ITypeData handler = context.Types[typeof(NonWritableProperty)];
Assert.IsTrue(handler.FindProperty("InternalInt").Ignored);
}
public void TestImplicitDictionaryAndList()
{
var settings = new SerializerSettings()
{
LimitPrimitiveFlowSequence = 0
};
var text = @"BasicList:
- 1
- 2
BasicMap:
a: 1
b: 2
ListByContent:
- a
- b
Name: Yes
StringList:
- 1
- 2
StringListByContent:
- 3
- 4
StringMap:
c: yes
d: 3
StringMapbyContent:
e: 4
f: no
Value: 0
".Trim();
SerialRoundTrip(settings, text, typeof(Dictionary <object, object>));
}
public void WhenDefaultValuesSetOnContext_PropertyInheritsFromContextIfNotSetOnType()
{
ISerializerSettings config = new SerializerSettings();
ITypeData typeData = config.Types[typeof(SimpleObject)];
typeData.DefaultValueSetting = DefaultValueOption.SuppressDefaultValues;
config.DefaultValues[typeof(string)] = "FromType";
typeData.DefaultValues[typeof(int)] = 22;
IPropertyData stringProperty = config.Types[typeof(SimpleObject)].FindProperty("StringValue");
Assert.IsFalse(stringProperty.ShouldWriteValue(config, "FromType"));
Assert.IsTrue(stringProperty.ShouldWriteValue(config, ""));
IPropertyData intProperty = config.Types[typeof(SimpleObject)].FindProperty("IntValue");
Assert.IsFalse(intProperty.ShouldWriteValue(config, 22));
Assert.IsTrue(intProperty.ShouldWriteValue(config, 0));
IPropertyData shortProperty = config.Types[typeof(SimpleObject)].FindProperty("ShortValue");
shortProperty.DefaultValue = (short)9;
Assert.IsFalse(shortProperty.ShouldWriteValue(config, (short)9));
Assert.IsTrue(shortProperty.ShouldWriteValue(config, 0));
}
/// <summary>
/// Initializes a new instance of the <see cref="GameSystem" /> class.
/// </summary>
/// <param name="game">The game.</param>
public YamlManager(Game game) : base(game)
{
Services.AddService(this);
yamlSettings = new SerializerSettings();
attributeRegistry = yamlSettings.Attributes;
serializer = CreateSerializer(yamlSettings);
}
private static Serializer CreateSerializer(ref Serializer localSerializer)
{
if (localSerializer == null)
{
// var clock = Stopwatch.StartNew();
var config = new SerializerSettings()
{
EmitAlias = false,
LimitPrimitiveFlowSequence = 0,
Attributes = new AtributeRegistryFilter(),
PreferredIndent = 4,
EmitShortTypeName = true,
};
for (int index = RegisteredAssemblies.Count - 1; index >= 0; index--)
{
var registeredAssembly = RegisteredAssemblies[index];
config.RegisterAssembly(registeredAssembly);
}
localSerializer = new Serializer(config);
localSerializer.Settings.ObjectSerializerBackend = new OverrideKeyMappingTransform(TypeDescriptorFactory.Default);
// Log.Info("New YAML serializer created in {0}ms", clock.ElapsedMilliseconds);
}
return(localSerializer);
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
var loggerFactory = new LoggerFactory()
.AddConsole(LogLevel.Error)
.AddDebug(LogLevel.Error);
services.AddSingleton(loggerFactory);
services.AddLogging();
services.AddSingleton(Configuration);
services.AddMvc()
.AddJsonOptions(options =>
{
options.SerializerSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver();
options.SerializerSettings.Converters = SerializerSettings.GetDefaultConverters();
});
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration("v1", "MarginTrading_Api");
options.OperationFilter <AddAuthorizationHeaderParameter>();
});
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.SecurityTokenValidators.Clear();
options.SecurityTokenValidators.Add(ApplicationContainer.Resolve <ISecurityTokenValidator>());
});
var builder = new ContainerBuilder();
var appSettings = Configuration.LoadSettings <ApplicationSettings>()
.Nested(s =>
{
if (!string.IsNullOrEmpty(Configuration["Env"]))
{
s.MtFrontend.MarginTradingFront.Env = Configuration["Env"];
}
return(s);
});
var settings = appSettings.Nested(s => s.MtFrontend);
Console.WriteLine($"Env: {settings.CurrentValue.MarginTradingFront.Env}");
SetupLoggers(services, appSettings);
RegisterModules(builder, appSettings);
builder.Populate(services);
ApplicationContainer = builder.Build();
SetSubscribers(settings.CurrentValue);
return(new AutofacServiceProvider(ApplicationContainer));
}
public void IgnoreProperty_WhenFieldDoesntExist_ThrowsError()
{
SerializerSettings context = new SerializerSettings();
ITypeData handler = context.Type <SimpleObject>();
handler.IgnoreProperty("Foo");
}
/// <summary>
///
/// </summary>
/// <param name="knownTypes"></param>
/// <param name="enableUriTemplate"></param>
public WebHttpJsonNetBehavior2(IEnumerable <Type> knownTypes, bool enableUriTemplate = true)
: base(knownTypes, enableUriTemplate)
{
SerializerSettings serializerInfo = this.ConfigRegister.SerializerConfig;
CustomContractResolver resolver = new CustomContractResolver(true, false, this.ConfigRegister.TryToNormalize)
{
DefaultMembersSearchFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
};
this.Serializer = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
TypeNameHandling = TypeNameHandling.None,
ContractResolver = resolver
};
if (!serializerInfo.OnlyPublicConstructor)
{
Serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
}
if (serializerInfo.EnablePolymorphicMembers)
{
Serializer.Binder = new OperationTypeBinder(this.ConfigRegister);
Serializer.TypeNameHandling = TypeNameHandling.Objects;
}
}
public void JsonKeysAreQuoted()
{
var settings = new SerializerSettings()
{
EmitDefaultValues = true, EmitJsonComptible = true, EmitTags = false
};
var serializer = new Serializer(settings);
var buffer = new StringWriter();
serializer.Serialize(buffer, new Dictionary <int, int> {
{ 5, 10 }
});
Dump.WriteLine(buffer);
var bufferText = buffer.ToString();
Assert.AreEqual("{\"5\": 10}", bufferText.Trim());
var dict = serializer.Deserialize <Dictionary <int, int> >(bufferText);
Assert.AreEqual(1, dict.Count);
Assert.AreEqual(5, dict.First().Key);
Assert.AreEqual(10, dict.First().Value);
}
public void IgnoredBaseProperty_SharedByChildren()
{
SerializerSettings context = new SerializerSettings();
ITypeData child = context.Types[typeof(ChildClass)];
ITypeData baseClass = context.Types[typeof(BaseClass)];
Assert.AreSame(baseClass.FindProperty("IgnoredProperty"), child.FindProperty("IgnoredProperty"), "child IgnoredProperty");
}
public void OverridenBaseProperty_NotSharedByChildren()
{
SerializerSettings context = new SerializerSettings();
ITypeData child = context.Types[typeof(ChildClass)];
ITypeData baseClass = context.Types[typeof(BaseClass)];
Assert.AreNotSame(baseClass.FindProperty("OverriddenProperty"), child.FindProperty("OverriddenProperty"), "child OverriddenProperty");
}
public void NonOverridenBaseProperty_SharedByChildren()
{
SerializerSettings context = new SerializerSettings();
ITypeData <ChildClass> child = context.Type <ChildClass>();
ITypeData <BaseClass> baseClass = context.Type <BaseClass>();
Assert.AreSame(baseClass.Property(t => t.BaseProperty), child.Property(t => t.BaseProperty), "child BaseProperty");
}
public void ChildClassReceivesBaseClassPropertiesPlusItsOwn()
{
SerializerSettings context = new SerializerSettings();
TypeData <ChildClass> child = new TypeData <ChildClass>(context);
Assert.IsNotNull(child.Property(t => t.BaseProperty), "BaseProperty");
Assert.IsNotNull(child.Property(t => t.ChildProperty), "ChildProperty");
}
static Generator()
{
SerializerSettings.RegisterSerializerFactory(new ValueTupleSerializer());
//SerializerSettings.RegisterSerializerFactory(new NullableSerializer());
SerializerSettings.RegisterSerializerFactory(new YamlNodeSerializer());
SerializerSettings.RegisterSerializerFactory(new PrimitiveSerializer());
Serializer = new Serializer(SerializerSettings);
}
private static Serializer GetSerializer()
{
SerializerSettings settings = new SerializerSettings {
EmitAlias = false, EmitTags = false
};
return(new Serializer(settings));
}
public void ThePropertyIsSerializedIfTheSerializerHasNoKnowledgeOfEnabledFeatures()
{
var settings = SerializerSettings.For(new DefaultContractResolver());
var json = JsonConvert.SerializeObject(model, Formatting.None, settings);
json.Should().Be(serializedWithAllProperties);
}
public void FindProperty_FindsIgnoredProperties()
{
SerializerSettings context = new SerializerSettings();
ITypeData handler = context.Type <IgnoredFieldClass>();
IPropertyData fieldHandler = handler.FindProperty("IVal");
Assert.IsNotNull(fieldHandler, "Ignored property not found");
}
static void CircularRefRead()
{
List <Book> books1 = new List <Book> {
new Book()
{
Title = "title1", Authors = new List <Author>()
}
};
Author author1 = new Author()
{
Name = "name1",
Books = books1
};
books1[0].Authors.Add(author1);
var settings = new SerializerSettings {
EmitAlias = true, EmitShortTypeName = true
};
var serializer = new Serializer(settings);
var text = serializer.Serialize(author1);
Console.WriteLine(text);
StringBuilder yaml1 = new StringBuilder();
var cf = new ChoYamlRecordConfiguration()
{
UseYamlSerialization = true
};
cf.YamlSerializerSettings.EmitTags = true;
Console.WriteLine(ChoYamlWriter.Serialize <Author>(author1, cf));
return;
string yaml = @"
&o0 !ChoYamlReaderTest.Program+Author
Name: name1
Books:
- Title: title1
Authors:
- *o0
";
//var settings = new SerializerSettings { EmitAlias = true, EmitShortTypeName = true };
//settings.RegisterAssembly(typeof(Author).Assembly);
//settings.RegisterTagMapping("!o0", typeof(Author), true);
//var serializer = new Serializer(settings);
//var text = serializer.Deserialize(yaml, typeof(Author));
//Console.WriteLine(text.Dump());
// using (var r = ChoYamlReader<Author>.LoadText(yaml)
// .YamlSerializerSettings(y => y.RegisterAssembly(typeof(Author).Assembly))
//)
// {
// foreach (var rec in r)
// Console.WriteLine(rec.Dump());
// }
}
public void Initialize()
{
var logSize = 1L << 20;
this.log = Devices.CreateLogDevice(@$ "{this.dataFolder}\Store-hlog.log", preallocateFile: false);
this.objLog = Devices.CreateLogDevice(@$ "{this.dataFolder}\Store-hlog-obj.log", preallocateFile: false);
var logSettings = new LogSettings
{
LogDevice = this.log,
ObjectLogDevice = this.objLog,
MutableFraction = 0.9,
PageSizeBits = 25, // 25
SegmentSizeBits = 30, // 30
MemorySizeBits = 34 // 34
};
var chekcpoint = new CheckpointSettings
{
CheckpointDir = $"{this.dataFolder}/checkpoints"
};
var serializer = new SerializerSettings <Types.StoreKey, Types.StoreValue>
{
keySerializer = () => new Types.StoreKeySerializer(),
valueSerializer = () => new Types.StoreValueSerializer()
};
this.db = new FasterKV
<Types.StoreKey, Types.StoreValue, Types.StoreInput, Types.StoreOutput, Types.StoreContext, Types.StoreFunctions>(
logSize,
new Types.StoreFunctions(),
logSettings,
chekcpoint,
serializer);
if (Directory.Exists($"{this.dataFolder}/checkpoints"))
{
this.db.Recover();
}
Block genesis = this.network.GetGenesis();
using (var session = this.db.NewSession())
{
var wrapper = new Types.SessionWrapper {
Session = session
};
if (this.GetTipHash() == null)
{
this.SetBlockHash(wrapper, new HashHeightPair(genesis.GetHash(), 0));
this.Checkpoint();
// Genesis coin is unspendable so do not add the coins.
// transaction.Commit();
}
}
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
var loggerFactory = new LoggerFactory()
.AddConsole(LogLevel.Error)
.AddDebug(LogLevel.Error);
services.AddSingleton(loggerFactory);
services.AddLogging();
services.AddSingleton(Configuration);
services.AddMvc(options => options.Filters.Add(typeof(MarginTradingEnabledFilter)))
.AddJsonOptions(
options => { options.SerializerSettings.Converters = SerializerSettings.GetDefaultConverters(); });
services.AddAuthentication(KeyAuthOptions.AuthenticationScheme)
.AddScheme <KeyAuthOptions, KeyAuthHandler>(KeyAuthOptions.AuthenticationScheme, "", options => { });
var isLive = Configuration.IsLive();
services.AddSwaggerGen(options =>
{
options.DefaultLykkeConfiguration("v1", $"MarginTrading_Api_{Configuration.ServerType()}");
options.OperationFilter <ApiKeyHeaderOperationFilter>();
});
var builder = new ContainerBuilder();
var envSuffix = !string.IsNullOrEmpty(Configuration["Env"]) ? "." + Configuration["Env"] : "";
var mtSettings = Configuration.LoadSettings <MtBackendSettings>()
.Nested(s =>
{
var inner = isLive ? s.MtBackend.MarginTradingLive : s.MtBackend.MarginTradingDemo;
inner.IsLive = isLive;
inner.Env = Configuration.ServerType() + envSuffix;
return(s);
});
var settings =
mtSettings.Nested(s => isLive ? s.MtBackend.MarginTradingLive : s.MtBackend.MarginTradingDemo);
var riskInformingSettings =
mtSettings.Nested(s => isLive ? s.RiskInformingSettings : s.RiskInformingSettingsDemo);
Console.WriteLine($"IsLive: {settings.CurrentValue.IsLive}");
SetupLoggers(services, mtSettings, settings);
RegisterModules(builder, mtSettings, settings, Environment, riskInformingSettings);
builder.Populate(services);
ApplicationContainer = builder.Build();
MtServiceLocator.FplService = ApplicationContainer.Resolve <IFplService>();
MtServiceLocator.AccountUpdateService = ApplicationContainer.Resolve <IAccountUpdateService>();
MtServiceLocator.AccountsCacheService = ApplicationContainer.Resolve <IAccountsCacheService>();
MtServiceLocator.SwapCommissionService = ApplicationContainer.Resolve <ICommissionService>();
MtServiceLocator.OvernightSwapService = ApplicationContainer.Resolve <IOvernightSwapService>();
return(new AutofacServiceProvider(ApplicationContainer));
}
public void DefaultValuesOnPropertyAreConvertedIfNotSameType()
{
ISerializerSettings config = new SerializerSettings();
ITypeData typeData = config.Types[typeof(MockDefaultValues)];
IPropertyData property = typeData.FindProperty("ConvertedValue");
Assert.IsFalse(property.ShouldWriteValue(config, (short)32));
Assert.IsTrue(property.ShouldWriteValue(config, 0));
}
public void SetUp()
{
var serializerSettings = new SerializerSettings();
Func<DataStore> createDataStore = () =>
{
var ds = new DataStore(serializerSettings);
indexer = new Indexer(ds);
return ds;
};
var store = new FileTransactionStore(Path.GetRandomFileName());
database = new PieDatabase(store, createDataStore: createDataStore);
dbSession = database.OpenSession();
}
