private ConfigurationContainer ReadConfiguration(string file)
{
ConfigurationContainer container = new ConfigurationContainer();
XmlTextReader reader = null;
try {
reader = new XmlTextReader(new StreamReader(file));
while (!reader.EOF) {
reader.Read();
if (reader.IsStartElement()) {
if (reader.Name == "WaitTime") {
reader.MoveToContent();
reader.Read();
container.WaitTime = int.Parse(reader.Value);
}
else if (reader.Name == "AutoStart") {
reader.MoveToContent();
reader.Read();
container.AutoStart = bool.Parse(reader.Value);
}
else if (reader.Name == "MaxRetryCount") {
reader.MoveToContent();
reader.Read();
container.MaxRetryCount = int.Parse(reader.Value);
}
}
}
return container;
}
catch { return null; }
finally { if (reader != null) reader.Close(); }
}
public void CreateDefaultConfiguration()
{
cContainer = new ConfigurationContainer();
cContainer.AutoStart = true;
cContainer.MaxRetryCount = 5;
cContainer.WaitTime = 3000;
}
public static SynchronousViewManagerEventDispatcherConfiguationBuilder UseSynchronousViewManangerEventDispatcher(
this EventDispatcherConfigurationBuilder builder, params IViewManager[] viewManagers)
{
var viewManagerConfigurationContainer = new ConfigurationContainer();
builder.UseEventDispatcher(context =>
{
var viewManagerContext = viewManagerConfigurationContainer.CreateContext();
context.AddChildContext(viewManagerContext);
var eventDispatcher = new SynchronousViewManagerEventDispatcher(
context.Get<IAggregateRootRepository>(),
context.Get<IDomainEventSerializer>(),
context.Get<IDomainTypeNameMapper>(),
viewManagers);
var contextItems = viewManagerContext.GetOrDefault<IDictionary<string, object>>();
if (contextItems != null)
{
eventDispatcher.SetContextItems(contextItems);
}
return eventDispatcher;
});
return new SynchronousViewManagerEventDispatcherConfiguationBuilder(viewManagerConfigurationContainer);
}
/// <summary>
/// Gets the settings container for this platform
/// </summary>
/// <param name="container">The settings container.</param>
/// <returns>The settings container.</returns>
protected ApplicationDataContainer GetSettingsContainer(ConfigurationContainer container)
{
ApplicationDataContainer settings = null;
lock (_containerCache)
{
if (!_containerCache.TryGetValue(container, out settings))
{
switch (container)
{
case ConfigurationContainer.Local:
settings = ApplicationData.Current.LocalSettings;
break;
case ConfigurationContainer.Roaming:
settings = ApplicationData.Current.RoamingSettings;
break;
default:
throw new ArgumentOutOfRangeException("container");
}
_containerCache[container] = settings;
}
}
return settings;
}
public void ReturnsValueForKeyWithSpecialCharacters(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
configurationService.SetValue(container, "key with special chars", "myValue");
Assert.AreEqual("myValue", configurationService.GetValue(container, "key with special chars", "nonExistingValue"));
}
public void ReturnsExistingValue(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
configurationService.SetValue(container, "myKey", "myValue");
Assert.AreEqual("myValue", configurationService.GetValue<string>(container, "myKey"));
}
public void LoadConfiguration()
{
try{
string configFile = SharedBO.GetConfigurationFile();
//cContainer = MoreXmlSerializer.Deserialize<ConfigurationContainer>(configFile);
cContainer = ReadConfiguration(configFile);
}catch {
CreateDefaultConfiguration();
}
}
void VerifyProperties()
{
var buttonEx2 = new ButtonEx2 {
MyProperty = 1.0
};
var serializer = new ConfigurationContainer().Extend(FallbackSerializationExtension.Default)
.Type <ButtonExBase2>()
.Member(x => x.MyProperty)
.Ignore()
.Create()
.ForTesting();
serializer.Cycle(buttonEx2)
.Should()
.BeEquivalentTo(buttonEx2);
}
public void IsNotInvokedDuringSetValueMethodForEqualValues(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
var invoked = false;
configurationService.SetValue(container, "key", "value");
configurationService.ConfigurationChanged += (sender, e) =>
{
invoked = true;
};
configurationService.SetValue(container, "key", "value");
Assert.IsFalse(invoked);
}
public void ShouldPreserveNullStringValueIfDefaultIsNotNull()
{
var config = new ConfigurationContainer();
config.Emit(EmitBehaviors.WhenModified);
var serializer = config.Create();
var xml = serializer.Serialize(new ClassWithDefaultString()
{
Name = null, SubNode = null
});
var deserialized = serializer.Deserialize <ClassWithDefaultString>(xml);
deserialized.Name.Should()
.BeNull();
}
public static void RunSimpleConfig()
{
Program.PrintHeader("Serialization reference object");
// Configuration
IExtendedXmlSerializer serializer = new ConfigurationContainer().UseEncryptionAlgorithm(new CustomEncryption())
.ConfigureType <Person>()
.Member(p => p.Password)
.Encrypt()
.Create();
// EndConfiguration
Run(serializer);
}
public void VerifyTable()
{
var serializer = new ConfigurationContainer().Type <Key>()
.Register()
.Converter()
.Using(KeyConverter.Default)
.UseAutoFormatting()
.Create()
.ForTesting();
var instance = new KeyDictionary <string> {
{ 6776, "Hello World!" }
};
serializer.Cycle(instance).Should().BeEquivalentTo(instance);
}
void Verify()
{
var support = new ConfigurationContainer().EnableParameterizedContentWithPropertyAssignments()
.Create()
.ForTesting();
var instance = new DataHolder(13);
instance.Lenght = 13;
instance.Data.Add(new Data(1.23f));
instance.Data.Add(new Data(3.27f));
instance.Data.Add(new Data(5.14f));
instance.Data.Add(new Data(7.29f));
support.Cycle(instance).ShouldBeEquivalentTo(instance);
}
private static void WithModifier(ConfigurationContainer configuration)
{
while (!CancellationRequested)
{
if (Game.IsKeyDownRightNow(configuration.ForcePursuitModifierKey))
{
if (Game.IsKeyDown(configuration.ForcePursuitKey))
{
Extensions.LogTrivial($"Modifier {configuration.ForcePursuitModifierKey} and key {configuration.ForcePursuitKey} pressed");
PursuitOnTheFly.TryForce(configuration);
}
}
GameFiber.Yield();
}
Extensions.LogTrivial($"Cancellation requested.");
}
public Game(IInput input, IOutput output, ISoundManager soundManager, Stream defaultsStream, Stream audioStream, Stream commandsStream, Stream storyStepsStream)
{
Input = input;
Input.OnTextReceived += InputOnOnTextReceived;
Output = output;
SoundManager = soundManager;
DefaultsContainer = new ConfigurationContainer<Defaults>(defaultsStream);
DefaultsContainer.ReadFromStream();
AudioListContainer = new ConfigurationListContainer<Sound>(audioStream);
AudioListContainer.ReadFromStream();
CommandListContainer = new ConfigurationListContainer<Command>(commandsStream);
CommandListContainer.ReadFromStream();
DefaultCommands = CommandListContainer.Get(c => c.IsDefault);
StoryStepListContainer = new ConfigurationListContainer<StoryStep>(storyStepsStream);
StoryStepListContainer.ReadFromStream();
}
public void Execute(object parameter)
{
// Example
IExtendedXmlSerializer serializer = new ConfigurationContainer().EnableAllConstructors()
.Create();
SubjectByFactory subject = SubjectByFactory.Create("Hello World!");
string contents = serializer.Serialize(subject);
// ...
// EndExample
string data = serializer.Serialize(new XmlWriterSettings {
Indent = true
}, subject);
File.WriteAllText(@"bin\Extensibility.PrivateConstructors.xml", data);
}
public void Verify()
{
var serializer = new ConfigurationContainer().EnableParameterizedContent()
.ConfigureType <Plane>()
.Member(x => x.Rows).Ignore()
.Member(x => x.Length).Attribute()
.Create()
.ForTesting();
var subject = new Plane(4.33);
serializer.Cycle(subject)
.ShouldBeEquivalentTo(subject);
serializer.Serialize(subject)
.Should()
.Be(@"<?xml version=""1.0"" encoding=""utf-8""?><Issue146Tests-Plane Length=""4.33"" xmlns=""clr-namespace:ExtendedXmlSerializer.Tests.ReportedIssues;assembly=ExtendedXmlSerializer.Tests"" />");
}
public void CanSaveAndLoadConfigurationTest()
{
EntitiesAccessor target = EntitiesAccessor.Instance;
string filename = "config.xml";
ConfigurationContainer cc = new ConfigurationContainer();
ConfigurationContainer actual;
Assert.IsTrue(target.SaveConfiguration(filename, cc), "Save function for SaveConfiguration did not return true");
Assert.IsTrue(System.IO.File.Exists(filename), "File {0} did not exists while it should be wrtten.", filename);
actual = target.LoadConfiguration(filename);
Assert.IsNotNull(actual, "Could not read file {0}.", filename);
}
void VerifyElement()
{
var container = new ConfigurationContainer().EnableImplicitTypingFromNested <Issue261Tests>()
.EnableClassicSchemaTyping()
.Create()
.ForTesting();
var content =
@"<?xml version=""1.0"" encoding=""utf-8""?><List xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:exs=""https://extendedxmlserializer.github.io/v2"" exs:arguments=""ModelObject"" xmlns=""https://extendedxmlserializer.github.io/system""><Capacity>4</Capacity><Issue261Tests-ModelObject xsi:type=""Issue261Tests-Project"" /></List>";
container.Deserialize <List <Entity> >(content)
.Should()
.HaveCount(1)
.And.Subject.Only()
.Should()
.BeOfType <Project>();
}
public void Verify()
{
var serializer = new ConfigurationContainer().Type <Subject>()
.Member(x => x.NoMessage)
.Ignore()
.Create();
var instance = new Subject {
Message = "Hello World!", NoMessage = "Ignored"
};
var cycled = serializer.Cycle(instance);
cycled.NoMessage.Should().BeNullOrEmpty();
cycled.Message.Should().Be(instance.Message);
}
public void Execute(object parameter)
{
// Example
var serializer = new ConfigurationContainer().EnableParameterizedContent()
.Create();
var subject = new ParameterizedSubject("Hello World!", 123, DateTime.Now);
var contents = serializer.Serialize(subject);
// ...
// EndExample
var data = serializer.Serialize(new XmlWriterSettings {
Indent = true
}, subject);
File.WriteAllText(@"bin\Extensibility.ParameterizedContent.xml", data);
}
public void ShouldPreserveNullObjectValueIfEmitWhenReturnsTrue()
{
var serializer = new ConfigurationContainer().Emit(EmitBehaviors.Assigned)
.ConfigureType <ClassWithDefaultString>()
.Member(x => x.SubNode)
.EmitWhen(x => true)
.Create();
string xml = serializer.Serialize(new ClassWithDefaultString()
{
Name = null, SubNode = null
});
var deserialized = serializer.Deserialize <ClassWithDefaultString>(xml);
deserialized.SubNode.Should().BeNull();
}
/// <summary>
/// Saves the configuration.
/// </summary>
/// <param name="fileName">The fileName.</param>
/// <param name="configContainer">The configuration container.</param>
/// <returns></returns>
public bool SaveConfiguration(string fileName, ConfigurationContainer configContainer)
{
if (configContainer == null)
{
throw new ArgumentNullException("configContainer");
}
if (string.IsNullOrEmpty(fileName))
{
throw new ArgumentNullException("fileName");
}
ObjectXMLSerializer <ConfigurationContainer> .Save(configContainer, fileName, SerializedFormat.Document);
return(true);
}
void Verify()
{
var serializer = new ConfigurationContainer().EnableMemberExceptionHandling()
.Create()
.ForTesting();
serializer.Invoking(x => x.Serialize(new Subject()))
.ShouldThrowExactly <InvalidOperationException>()
.WithMessage("An exception was encountered while serializing member 'ExtendedXmlSerializer.Tests.ReportedIssues.Issue214Tests+Subject.Message'. Provided instance is 'ExtendedXmlSerializer.Tests.ReportedIssues.Issue214Tests+Subject'.")
.WithInnerException <InvalidOperationException>();
serializer.Invoking(x => x.Deserialize <Subject>(@"<?xml version=""1.0"" encoding=""utf-8""?><Issue214Tests-Subject xmlns=""clr-namespace:ExtendedXmlSerializer.Tests.ReportedIssues;assembly=ExtendedXmlSerializer.Tests""><Message>Hello World!</Message></Issue214Tests-Subject>"))
.ShouldThrowExactly <InvalidOperationException>()
.WithMessage("An exception was encountered while deserializing member 'ExtendedXmlSerializer.Tests.ReportedIssues.Issue214Tests+Subject.Message'.")
.WithInnerException <XmlException>();
}
//执行之前处理
public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
#region 通过请求token获取当前用户登录信息
var coreConfiguration = ConfigurationContainer.Get <BaseConfiguration>(ConfigurationNames.Application);
if (coreConfiguration.DyCRMSetting != null)
{
var dyCRMSetting = coreConfiguration.DyCRMSetting;
_baseUrl = $"{dyCRMSetting.CrmUrl}/api/data/v{dyCRMSetting.CrmApiVersion}";
}
IHttpContextAccessor _accessor = new HttpContextAccessor();
var token = _accessor.HttpContext?.Request.Headers["token"].ToString();
if (!string.IsNullOrEmpty(token))
{
var helper = DIContainerContainer.Get <AdfsEndpointRepositoryHelper>();
string userName = "";
if (token.Contains("ADAUTH:"))
{
userName = token.Split(':')[1];
}
else
{
var endpoint = await helper.QueryByName("Main");
var claims = await endpoint.ValidateJWT(token, new string[] { _baseUrl });
userName = claims.FindFirst(System.Security.Claims.ClaimTypes.Name).Value;
}
if (!string.IsNullOrEmpty(userName))
{
#region 缓存用户登录信息
var logioninfo = await helper.GetLoginInfo(userName, token);
if (logioninfo != null)
{
ContextContainer.SetValue <UserInfo>(ContextExtensionTypes.CurrentUserInfo, logioninfo);
}
#endregion
}
}
else
{
//throw new Exception("接口鉴权失败");
}
#endregion
await next();
}
public void List()
{
var container = new ConfigurationContainer();
container.Type <TestClassReference>()
.EnableReferences(x => x.Id);
var support = new SerializationSupport(container);
var parent = new TestClassReference {
Id = 1
};
var other = new TestClassReference {
Id = 2, ObjectA = parent, ReferenceToObjectA = parent
};
var instance = new List <IReference>
{
new TestClassReference {
Id = 3, ObjectA = parent, ReferenceToObjectA = parent
},
new TestClassReference {
Id = 4, ObjectA = other, ReferenceToObjectA = other
},
other,
parent
};
var actual = support.Assert(instance,
@"<?xml version=""1.0"" encoding=""utf-8""?><List xmlns:ns1=""clr-namespace:ExtendedXmlSerializer.Tests.TestObject;assembly=ExtendedXmlSerializer.Tests"" xmlns:exs=""https://extendedxmlserializer.github.io/v2"" exs:arguments=""ns1:IReference"" xmlns=""https://extendedxmlserializer.github.io/system""><Capacity>4</Capacity><ns1:TestClassReference Id=""3""><ObjectA exs:type=""ns1:TestClassReference"" Id=""1"" /><ReferenceToObjectA exs:type=""ns1:TestClassReference"" exs:entity=""1"" /></ns1:TestClassReference><ns1:TestClassReference Id=""4""><ObjectA exs:type=""ns1:TestClassReference"" Id=""2""><ObjectA exs:type=""ns1:TestClassReference"" exs:entity=""1"" /><ReferenceToObjectA exs:type=""ns1:TestClassReference"" exs:entity=""1"" /></ObjectA><ReferenceToObjectA exs:type=""ns1:TestClassReference"" exs:entity=""2"" /></ns1:TestClassReference><ns1:TestClassReference exs:entity=""2"" /><ns1:TestClassReference exs:entity=""1"" /></List>");
Assert.Same(actual[0]
.To <TestClassReference>()
.ObjectA, actual[0]
.To <TestClassReference>()
.ReferenceToObjectA);
Assert.Same(actual[1]
.To <TestClassReference>()
.ObjectA, actual[1]
.To <TestClassReference>()
.ReferenceToObjectA);
Assert.Same(actual[2], actual[1]
.To <TestClassReference>()
.ObjectA);
Assert.Same(actual[3], actual[0]
.To <TestClassReference>()
.ObjectA);
}
static TrackerStrategyRepository()
{
ConfigurationContainer.RegisterJsonListener <string[]>("TrackerStrategyData.json", (names) =>
{
var trackerStrategyList = new Dictionary <string, TrackerStrategy>();
foreach (var item in names)
{
trackerStrategyList.Add(item, new TrackerStrategy()
{
ID = Guid.NewGuid(),
Name = item
});
}
_trackerStrategyList = trackerStrategyList;
});
}
public void Execute(object parameter)
{
// Type
var serializer = new ConfigurationContainer().ConfigureType <Subject>()
.Name("ModifiedSubject")
.Create();
// EndType
var subject = new Subject {
Count = 6776, Message = "Hello World!"
};
var contents = serializer.Serialize(new XmlWriterSettings {
Indent = true
}, subject);
File.WriteAllText(@"bin\Introduction.Type.xml", contents);
}
/// <summary>
/// Determines whether the specified key value exists in the configuration.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="key">The key.</param>
/// <returns><c>true</c> if the value exists, <c>false</c> otherwise.</returns>
protected virtual bool ValueExists(ConfigurationContainer container, string key)
{
#if PCL || (XAMARIN && !ANDROID)
throw Log.ErrorAndCreateException <NotSupportedInPlatformException>("No configuration objects available");
#elif ANDROID
return(_preferences.Contains(key));
#elif NETFX_CORE
var settings = GetSettingsContainer(container);
return(settings.Values.ContainsKey(key));
#elif WINDOWS_PHONE || SILVERLIGHT
var settings = IsolatedStorageSettings.ApplicationSettings;
return(settings.Contains(key));
#else
var settings = GetSettingsContainer(container);
return(settings.IsConfigurationKeyAvailable(key));
#endif
}
public void Verify()
{
var serializer = new ConfigurationContainer().UseAutoFormatting()
.UseOptimizedNamespaces()
.EnableImplicitTyping(typeof(MainDTO),
typeof(SubDTO), typeof(SubSubDTO))
.Type <SubSubDTO>()
.EnableReferences(definition => definition.Id)
.Create()
.ForTesting();
var instance = new MainDTO();
var cycled = serializer.Cycle(instance);
cycled.Sub1.SubSub1.Should().BeSameAs(cycled.Sub2.SubSub1);
cycled.Sub1.SubSub1.Should().BeSameAs(cycled.Sub3.SubSub1);
}
public void TestMethod1()
{
var cfg = @"<cfg name='test'>
<entities>
<add name='entity'>
<rows>
<add key='1' json='{ ""string"": ""problematic"", ""number"": 1, ""array"": [2,3,4], ""object"" : { ""sixPointFour"": 6.4} }' />
</rows>
<fields>
<add name='key' type='int' primary-key='true' />
<add name='json' length='max' />
</fields>
<calculated-fields>
<add name='string' t='copy(json).jsonpath($.string)' />
<add name='number' type='int' t='copy(json).jsonpath($.number)' />
<add name='array' t='copy(json).jsonpath($.array)' />
<add name='numberInArray' type='int' t='copy(json).jsonpath($.array[2])' />
<add name='sixPoint4' type='decimal' t='copy(json).jsonpath($.object.sixPointFour)' />
<add name='filter' t='copy(json).jsonpath($.array[?(@!=2)])' />
</calculated-fields>
</add>
</entities>
</cfg>";
var logger = new ConsoleLogger(LogLevel.Debug);
using (var outer = new ConfigurationContainer(new JsonTransformModule()).CreateScope(cfg, logger)) {
var process = outer.Resolve <Process>();
using (var inner = new Container(new JsonTransformModule()).CreateScope(process, logger)) {
var controller = inner.Resolve <IProcessController>();
IRow[] output = controller.Read().ToArray();
Assert.AreEqual(1, output.Length);
Assert.AreEqual("problematic", output[0][process.Entities[0].CalculatedFields[0]]);
Assert.AreEqual(1, output[0][process.Entities[0].CalculatedFields[1]]);
Assert.AreEqual(@"[
2,
3,
4
]", output[0][process.Entities[0].CalculatedFields[2]]);
Assert.AreEqual(4, output[0][process.Entities[0].CalculatedFields[3]]);
Assert.AreEqual(6.4M, output[0][process.Entities[0].CalculatedFields[4]]);
Assert.AreEqual("3", output[0][process.Entities[0].CalculatedFields[5]]);
}
}
}
/// <summary>
/// Gets the value from the store.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="key">The key.</param>
/// <returns>The value.</returns>
protected virtual string GetValueFromStore(ConfigurationContainer container, string key)
{
#if PCL || (XAMARIN && !ANDROID)
throw Log.ErrorAndCreateException <NotSupportedInPlatformException>("No configuration objects available");
#elif ANDROID
return(_preferences.GetString(key, null));
#elif NETFX_CORE
var settings = GetSettingsContainer(container);
return((string)settings.Values[key]);
#elif WINDOWS_PHONE || SILVERLIGHT
var settings = IsolatedStorageSettings.ApplicationSettings;
return((string)settings[key]);
#else
var settings = GetSettingsContainer(container);
return(settings.GetConfigurationValue <string>(key));
#endif
}
public void Verify()
{
var instance = new DecoratedImage(null);
var serializer = new ConfigurationContainer().EnableParameterizedContentWithPropertyAssignments()
.UseOptimizedNamespaces()
//
.Type <DecoratedImage>()
.Register()
.Serializer()
.Of <ImageSerializer>()
//
.Create()
.ForTesting();
serializer.Assert(instance, @"<?xml version=""1.0"" encoding=""utf-8""?><Issue458Tests-DecoratedImage xmlns=""clr-namespace:ExtendedXmlSerializer.Tests.ReportedIssues;assembly=ExtendedXmlSerializer.Tests.ReportedIssues"" />");
}
public void Execute(object parameter)
{
// Create
IExtendedXmlSerializer serializer = new ConfigurationContainer()
// Configure...
.Create();
// EndCreate
Subject subject = new Subject {
Count = 6776, Message = "Hello World!"
};
string contents = serializer.Serialize(new XmlWriterSettings {
Indent = true
}, subject);
File.WriteAllText(@"bin\Introduction.xml", contents);
}
public void VerifyVerbatimAttribute()
{
var serializer = new ConfigurationContainer().ConfigureType <SubjectWithAttribute>()
.Create()
.ForTesting();
var subject = new SubjectWithAttribute {
Message = @"Hello??? (<, &, ', and "")"
};
var serialize = serializer.Serialize(subject);
serialize.Should()
.Be(@"<?xml version=""1.0"" encoding=""utf-8""?><Issue150Tests-SubjectWithAttribute xmlns=""clr-namespace:ExtendedXmlSerializer.Tests.ReportedIssues;assembly=ExtendedXmlSerializer.Tests""><Message><![CDATA[Hello??? (<, &, ', and "")]]></Message></Issue150Tests-SubjectWithAttribute>");
serializer.Deserialize <SubjectWithAttribute>(serialize)
.ShouldBeEquivalentTo(subject);
}
public void BasicTests()
{
var xml = $@"
<add name='TestProcess' read-only='false'>
<entities>
<add name='TestData'>
<rows>
<add vin='11111111111111111' />
<add vin='2LMDJ6JK0FBL33226' />
<add vin='JM1BK323071624570' />
</rows>
<fields>
<add name='vin' primary-key='true' />
</fields>
<calculated-fields>
<add name='valid' type='bool' t='copy(vin).vinisvalid()' />
<add name='year' type='short' t='copy(vin).vingetmodelyear()' />
<add name='make' t='copy(vin).vingetworldmanufacturer()' />
</calculated-fields>
</add>
</entities>
</add>";
var logger = new ConsoleLogger(LogLevel.Debug);
using (var outer = new ConfigurationContainer(new VinModule()).CreateScope(xml, logger)) {
var process = outer.Resolve <Process>();
using (var inner = new Container(new VinModule()).CreateScope(process, logger)) {
var controller = inner.Resolve <IProcessController>();
controller.Execute();
var rows = process.Entities.First().Rows;
Assert.AreEqual(true, rows[0]["valid"]);
Assert.AreEqual(true, rows[1]["valid"]);
Assert.AreEqual(false, rows[2]["valid"]);
Assert.AreEqual((short)2001, rows[0]["year"]);
Assert.AreEqual((short)2015, rows[1]["year"]);
Assert.AreEqual((short)2007, rows[2]["year"]);
Assert.AreEqual("", rows[0]["make"]);
Assert.AreEqual("Lincoln", rows[1]["make"]);
Assert.AreEqual("Mazda", rows[2]["make"]);
}
}
}
void GenericSimpleValue()
{
var serializer = new ConfigurationContainer()
.Create()
.ForTesting();
var singleValue = new ClassWithGeneric <int>();
singleValue.Description = "testtest123";
var result = serializer.Serialize(singleValue);
var deserializedValue = serializer.Deserialize <ClassWithGeneric <int> >(result);
deserializedValue.Description.Should()
.Be("testtest123");
}
public void VerifyAlternate()
{
var serializer = new ConfigurationContainer().UseAutoFormatting()
.EnableImmutableTypes()
.EnableParameterizedContentWithPropertyAssignments()
.Create();
var settings = new XmlWriterSettings {
Indent = true
};
var instance = new U("ciao", null);
var xml = serializer.Serialize(settings, instance);
var deserialized = serializer.Deserialize <U>(xml);
deserialized.Member.Should().BeNull();
}
/// <summary>
/// Gets the settings container for this platform
/// </summary>
/// <param name="container">The settings container.</param>
/// <returns>The settings container.</returns>
protected DynamicConfiguration GetSettingsContainer(ConfigurationContainer container)
{
DynamicConfiguration settings = null;
switch (container)
{
case ConfigurationContainer.Local:
settings = _localConfiguration;
break;
case ConfigurationContainer.Roaming:
settings = _roamingConfiguration;
break;
default:
throw new ArgumentOutOfRangeException("container");
}
return settings;
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationChangedEventArgs" /> class.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="key">The key.</param>
/// <param name="newValue">The new value.</param>
public ConfigurationChangedEventArgs(ConfigurationContainer container, string key, object newValue)
{
Container = container;
Key = key;
NewValue = newValue;
}
public void ThrowsArgumentExceptionForEmptyKey(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
ExceptionTester.CallMethodAndExpectException<ArgumentException>(() => configurationService.SetValue(container, string.Empty, "value"));
}
public void ReturnsDefaultValueForNonExistingValue(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
Assert.AreEqual("nonExistingValue", configurationService.GetValue(container, "nonExistingKey", "nonExistingValue"));
}
public ConsoleContainer(string configFile, bool isRemote)
{
configuration = CreateConfiguration(configFile);
server = CreateServer(isRemote);
}
protected override void DoSetUp()
{
_container = new ConfigurationContainer();
}
public void SetsValueCorrectlyForKeyWithSpecialCharacters(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
configurationService.SetValue(container, "key with special chars", "myValue");
Assert.AreEqual("myValue", configurationService.GetValue<string>(container, "key with special chars"));
}
public void SetsValueCorrectly(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
configurationService.SetValue(container, "myKey", "myValue");
Assert.AreEqual("myValue", configurationService.GetValue<string>(container, "myKey"));
}
private void WriteConfiguration(ConfigurationContainer container, string file)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
sb.AppendLine("<ConfigurationContainer xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">");
sb.AppendFormat("<WaitTime>{0}</WaitTime>\n", container.WaitTime);
sb.AppendFormat("<AutoStart>{0}</AutoStart>\n", container.AutoStart);
sb.AppendFormat("<MaxRetryCount>{0}</MaxRetryCount>\n", container.MaxRetryCount);
sb.AppendLine("</ConfigurationContainer>");
System.IO.StreamWriter sw = null;
try {
sw = new System.IO.StreamWriter(file);
sw.Write(sb.ToString());
}
catch { }
finally { if (sw != null) sw.Close(); }
}
public void ThrowsArgumentExceptionForNullKey(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
ExceptionTester.CallMethodAndExpectException<ArgumentException>(() => configurationService.GetValue<string>(container, null));
}
public void IsInvokedDuringSetValueMethod(ConfigurationContainer container)
{
var configurationService = GetConfigurationService();
bool invoked = false;
ConfigurationContainer receivedContainer = ConfigurationContainer.Roaming;
string receivedKey = null;
object receivedValue = null;
configurationService.ConfigurationChanged += (sender, e) =>
{
invoked = true;
receivedContainer = e.Container;
receivedKey = e.Key;
receivedValue = e.NewValue;
};
configurationService.SetValue(container, "key", "value");
Assert.IsTrue(invoked);
Assert.AreEqual(container, receivedContainer);
Assert.AreEqual("key", receivedKey);
Assert.AreEqual("value", (string)receivedValue);
}
