public static bool TryGetValue <T>(this IIniSection iniSection, string propertyName, out T propertyValue)
{
IIniProperty property = iniSection.GetProperty(propertyName);
// Only attempt to convert the string if the property isn't empty, because some types will get an unexpected value (e.g. bools will be false).
if (!string.IsNullOrWhiteSpace(property?.Value))
{
try {
Type convertType = typeof(T);
if (convertType.IsNullableType())
{
convertType = Nullable.GetUnderlyingType(convertType);
}
object convertedPropertyValue = Convert.ChangeType(property.Value, convertType, CultureInfo.InvariantCulture);
if (!(convertedPropertyValue is null))
{
propertyValue = (T)convertedPropertyValue;
return(true);
}
}
catch (FormatException) { }
}
propertyValue = default;
return(false);
}
private IniFileContainer CreateContainer(string iniFileName, IIniSection iniSection)
{
var iniFileConfig = IniFileConfigBuilder.Create()
.WithApplicationName("Dapplo")
.WithFilename(iniFileName)
.WithoutSaveOnExit()
.WithFixedDirectory(@"RestTests\IniTestFiles")
.BuildIniFileConfig();
return(new IniFileContainer(iniFileConfig, new[] { iniSection }));
}
/// <summary>
/// Returns an Ini-section if it exists, or generates a new one using the provided generateSection method.
/// </summary>
/// <param name="section">Name of the section</param>
/// <param name="generateSection">Function to generate a new section if it does not exist. Parameter is the Section</param>
/// <returns>Implementation of IIniSection</returns>
public IIniSection GetOrAddSection(string section, Func <string, IIniSection> generateSection)
{
IIniSection sec = GetSection(section);
if (sec == null)
{
sec = generateSection(section);
lock (_ini)
_ini.Add(sec);
}
return(sec);
}
/// <summary>
/// Creates a new <see cref="IIniDocument"/> using data from a <see cref="TextReader"/>.
/// </summary>
/// <param name='reader'>
/// A <see cref="TextReader"/> that will supply the input data.
/// </param>
public static IIniDocument Read(TextReader reader)
{
IIniDocument output = new IniDocument();
IIniSection currentSection = output;
bool endOfStream = false;
int lineNumber = 0;
while (!endOfStream)
{
string currentLine = reader.ReadLine();
Match currentMatch;
lineNumber++;
// If we get a null response then we are at the end of the stream and can exit
if (currentLine == null)
{
endOfStream = true;
continue;
}
// We silently skip over empty lines
if (EmptyLine.Match(currentLine).Success || CommentLine.Match(currentLine).Success)
{
continue;
}
// If we find a 'new section' line then we create a new section and begin dealing with it
currentMatch = SectionLine.Match(currentLine);
if (currentMatch.Success)
{
string sectionName = currentMatch.Groups[1].Value.Trim();
currentSection = new IniSection();
output.Sections.Add(sectionName, currentSection);
continue;
}
// If we find a value line then we store it within the current section.
currentMatch = ValueLine.Match(currentLine);
if (currentMatch.Success)
{
string key = currentMatch.Groups[1].Value.Trim();
string value = currentMatch.Groups[2].Value.Trim();
currentSection[key] = value;
continue;
}
throw new FormatException(String.Format("Invalid INI data at line {0}.", lineNumber));
}
return(output);
}
public static bool TryGetValue <T>(this IIniDocument document, string sectionName, string propertyName, out T propertyValue)
{
IIniSection section = document.GetSection(sectionName);
if (!(section is null))
{
return(section.TryGetValue(propertyName, out propertyValue));
}
propertyValue = default;
return(false);
}
/// <summary>
/// Automatically call the update action when the Saved fires
/// If the is called on a DI object, make sure it's available.
/// </summary>
/// <param name="iniSection">IIniSection</param>
/// <param name="eventAction">Action to call on events, argument is the IniSectionEventArgs</param>
/// <returns>an IDisposable, calling Dispose on this will stop everything</returns>
public static IDisposable OnSaved(this IIniSection iniSection, Action <IniSectionEventArgs> eventAction)
{
if (iniSection == null)
{
throw new ArgumentNullException(nameof(iniSection));
}
if (eventAction == null)
{
throw new ArgumentNullException(nameof(eventAction));
}
var observable = Observable.FromEventPattern <EventHandler <IniSectionEventArgs>, IniSectionEventArgs>(h => iniSection.Saved += h, h => iniSection.Saved -= h);
return(observable.Subscribe(pce => eventAction(pce.EventArgs)));
}
public static async Task DepraseAsync(this IIniSection @this, TextWriter writer)
{
await writer.WriteAsync($"[{@this.Name}]");
if (!string.IsNullOrEmpty(@this.Summary))
{
await writer.WriteAsync($"; {@this.Summary}");
}
await writer.WriteLineAsync();
foreach (var item in @this)
{
await item.DepraseAsync(writer);
await writer.WriteLineAsync();
}
}
public static bool TryGetValue <T>(this IIniSection iniSection, string propertyName, out T propertyValue)
{
IIniProperty property = iniSection.GetProperty(propertyName);
// Only attempt to convert the string if the property isn't empty, because some types will get an unexpected value (e.g. bools will be false).
if (!string.IsNullOrWhiteSpace(property?.Value))
{
try {
return(TypeUtilities.TryCast(property.Value, out propertyValue));
}
catch (FormatException) { }
}
propertyValue = default;
return(false);
}
/// <summary>
/// Helper method to fill the values of one section
/// </summary>
/// <param name="iniSection"></param>
private void FillSection(IIniSection iniSection)
{
if (_saveTimer != null)
{
_saveTimer.Enabled = false;
}
// Make sure there is no write protection
iniSection.RemoveWriteProtection();
// Defaults:
if (_defaults != null)
{
FillSection(_defaults, iniSection);
}
// Ini:
if (_ini != null)
{
FillSection(_ini, iniSection);
}
// Constants:
if (_constants != null)
{
iniSection.StartWriteProtecting();
FillSection(_constants, iniSection);
iniSection.StopWriteProtecting();
}
// After load
iniSection.AfterLoad();
iniSection.ResetHasChanges();
if (_saveTimer != null)
{
_saveTimer.Enabled = true;
}
}
public static string GetValue(this IIniSection iniSection, string propertyName)
{
return(iniSection.GetValue <string>(propertyName));
}
/// <summary>
/// The constructor of an IniValue
/// </summary>
/// <param name="iniSection">IIniSection</param>
/// <param name="propertyInfo">PropertyInfo</param>
public IniValue(IIniSection iniSection, PropertyInfo propertyInfo)
{
_iniSection = iniSection;
_propertyInfo = propertyInfo;
}
/// <summary>
/// Put the values from the iniProperties to the proxied object
/// </summary>
/// <param name="iniSections"></param>
/// <param name="iniSection"></param>
private void FillSection(IDictionary <string, IDictionary <string, string> > iniSections, IIniSection iniSection)
{
var sectionName = iniSection.GetSectionName();
// Might be null
iniSections.TryGetValue(sectionName, out var iniProperties);
var iniValues = from iniValue in iniSection.GetIniValues().Values.ToList()
where iniValue.Behavior.Read
select iniValue;
foreach (var iniValue in iniValues)
{
ITypeDescriptorContext context = null;
try
{
var propertyDescription = TypeDescriptor.GetProperties(iniSection.GetType()).Find(iniValue.PropertyName, true);
context = new TypeDescriptorContext(iniSection, propertyDescription);
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex.Message);
}
// Test if there is a separate section for this inivalue, this is used for Dictionaries
if (iniSections.TryGetValue($"{sectionName}-{iniValue.IniPropertyName}", out var value))
{
try
{
iniValue.Value = iniValue.ValueType.ConvertOrCastValueToType(value, iniValue.Converter, context);
continue;
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex.Message);
}
}
// Skip if the iniProperties doesn't have anything
if (iniProperties is null || iniProperties.Count == 0)
{
continue;
}
// Skip values that don't have a property
if (!iniProperties.TryGetValue(iniValue.IniPropertyName, out var stringValue))
{
continue;
}
// convert
try
{
iniValue.Value = iniValue.ValueType.ConvertOrCastValueToType(stringValue, iniValue.Converter, context);
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex.Message);
}
}
}
/// <summary>
/// Helper method to create ini section values for writing.
/// The actual values are stored in the _ini
/// </summary>
/// <param name="iniSection">Section to write</param>
/// <param name="iniSectionsComments">Comments</param>
private void CreateSaveValues(IIniSection iniSection, IDictionary <string, IDictionary <string, string> > iniSectionsComments)
{
// This flag tells us if the header for the section is already written
var isSectionCreated = false;
var sectionName = iniSection.GetSectionName();
var sectionProperties = new SortedDictionary <string, string>();
var sectionComments = new SortedDictionary <string, string>();
// Loop over the ini values, this automatically skips all NonSerialized properties
foreach (var iniValue in iniSection.GetIniValues().Values.ToList())
{
// Check if we need to write the value, this is not needed when it has the default or if write is disabled
if (!iniValue.IsWriteNeeded)
{
// Remove the value, if it's still in the cache
if (_ini.ContainsKey(sectionName) && _ini[sectionName].ContainsKey(iniValue.PropertyName))
{
_ini[sectionName].Remove(iniValue.PropertyName);
}
continue;
}
// Before we are going to write, we need to check if the section header "[Sectionname]" is already written.
// If not, do so now before writing the properties of the section itself
if (!isSectionCreated)
{
if (_ini.ContainsKey(sectionName))
{
_ini.Remove(sectionName);
}
_ini.Add(sectionName, sectionProperties);
iniSectionsComments.Add(sectionName, sectionComments);
var description = iniSection.GetSectionDescription();
if (!string.IsNullOrEmpty(description))
{
sectionComments.Add(sectionName, description);
}
// Mark section as created!
isSectionCreated = true;
}
// Check if the property has a description, if so write it in the ini comment before the property
if (!string.IsNullOrEmpty(iniValue.Description))
{
sectionComments.Add(iniValue.IniPropertyName, iniValue.Description);
}
ITypeDescriptorContext context = null;
try
{
var propertyDescription = TypeDescriptor.GetProperties(iniSection.GetType()).Find(iniValue.PropertyName, true);
context = new TypeDescriptorContext(iniSection, propertyDescription);
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex.Message);
}
// Get specified converter
var converter = iniValue.Converter;
// Special case, for idictionary derrivated types
if (iniValue.ValueType.IsGenericType && iniValue.ValueType.GetGenericTypeDefinition() == typeof(IDictionary <,>))
{
var subSection = TypeExtensions.ConvertOrCastValueToType <IDictionary <string, string> >(iniValue.Value, converter, context, false);
if (subSection != null)
{
try
{
// Use this to build a separate "section" which is called "[section-propertyname]"
string dictionaryIdentifier = $"{sectionName}-{iniValue.IniPropertyName}";
if (_ini.ContainsKey(dictionaryIdentifier))
{
_ini.Remove(dictionaryIdentifier);
}
_ini.Add(dictionaryIdentifier, subSection);
if (!string.IsNullOrWhiteSpace(iniValue.Description))
{
var dictionaryComments = new SortedDictionary <string, string>
{
{ dictionaryIdentifier, iniValue.Description }
};
iniSectionsComments.Add(dictionaryIdentifier, dictionaryComments);
}
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex.Message);
//WriteErrorHandler(iniSection, iniValue, ex);
}
continue;
}
}
try
{
// Convert the value to a string
var writingValue = TypeExtensions.ConvertOrCastValueToType <string>(iniValue.Value, converter, context, false);
// And write the value with the IniPropertyName (which does NOT have to be the property name) to the file
sectionProperties.Add(iniValue.IniPropertyName, writingValue);
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex.Message);
//WriteErrorHandler(iniSection, iniValue, ex);
}
}
}
public static void SetValue <T>(this IIniSection iniSection, string propertyName, T propertyValue)
{
iniSection.AddProperty(new IniProperty(propertyName, Convert.ToString(propertyValue, CultureInfo.InvariantCulture)));
}
public static void AddProperty(this IIniSection iniSection, string name, string value)
{
iniSection.AddProperty(new IniProperty(name, value));
}
public static T GetValue <T>(this IIniSection iniSection, string propertyName)
{
iniSection.TryGetValue(propertyName, out T propertyValue);
return(propertyValue);
}
public static bool HasProperty(this IIniSection iniSection, string name)
{
return(!(iniSection.GetProperty(name) is null));
}
