private object ParseReadXmlDictionary(XmlReader reader, Type valueType)
{
var values = new Dictionary <string, string>();
var hierarchy = reader.ToHierarchy();
var items = hierarchy.Find(h => h.Instance.Name == EnumerableElementName && h.Depth == 1).ToList();
foreach (var item in items)
{
if (item.HasChildren)
{
try
{
var key = item.GetChildren().SingleOrDefault();
var value = key?.GetChildren().SingleOrDefault();
if (value != null)
{
values.Add(key.Instance.Value.ToString(), value.Instance.Value.ToString());
}
}
catch (Exception ex)
{
throw new NotSupportedException("Deserialization of complex objects is not supported in this version.", ex);
}
}
}
var dictionaryType = (valueType.GetGenericArguments() ?? valueType.GetAncestorsAndSelf(typeof(object)).Yield()).ToArray();
var dictionary = typeof(Dictionary <,>).MakeGenericType(dictionaryType);
var castedValues = values.Select(pair => TupleUtility.CreateTwo(ObjectConverter.ChangeType(pair.Key, dictionaryType[0]), ObjectConverter.ChangeType(pair.Value, dictionaryType[1]))).ToList();
var instance = Activator.CreateInstance(dictionary);
var addMethod = valueType.GetMethod("Add");
foreach (var item in castedValues)
{
addMethod.Invoke(instance, new[] { item.Arg1, item.Arg2 });
}
return(instance);
}
private object ParseReadXmlEnumerable(XmlReader reader, Type valueType)
{
var values = new List <KeyValuePair <string, string> >();
var hierarchy = reader.ToHierarchy();
var items = hierarchy.Find(h => h.Instance.Name == EnumerableElementName && h.Depth == 1).ToList();
if (items.FirstOrDefault()?.HasChildren ?? false)
{
throw new NotSupportedException("Deserialization of complex objects is not supported in this version.");
}
values.AddRange(items.Select(h => new KeyValuePair <string, string>(h.Instance.Name, h.Instance.Value.ToString())));
var enumerableType = valueType.GetGenericArguments().FirstOrDefault() ?? valueType.GetAncestorsAndSelf(typeof(object));
var listEnumerable = typeof(List <>).MakeGenericType(enumerableType);
var castedValues = values.Where(pair => pair.Key == EnumerableElementName).Select(pair => ObjectConverter.ChangeType(pair.Value, enumerableType)).ToList();
var instance = Activator.CreateInstance(listEnumerable);
var addMethod = valueType.GetMethod("Add");
foreach (var item in castedValues)
{
addMethod.Invoke(instance, new[] { item });
}
return(instance);
}
private object ParseReadXmlDefault(XmlReader reader, Type valueType)
{
var key = "";
var values = new Dictionary <string, string>();
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Attribute:
values.Add(reader.Name, reader.Value);
while (reader.MoveToNextAttribute())
{
goto case XmlNodeType.Attribute;
}
reader.MoveToElement();
break;
case XmlNodeType.Element:
if (reader.Depth == 0)
{
continue;
}
key = reader.Name;
if (reader.HasAttributes)
{
if (reader.MoveToFirstAttribute())
{
goto case XmlNodeType.Attribute;
}
}
break;
case XmlNodeType.CDATA:
case XmlNodeType.Text:
values.AddOrUpdate(key, reader.Value);
break;
}
}
var constructors = valueType.GetConstructors(ReflectionUtility.BindingInstancePublicAndPrivate).ToList();
var properties = valueType.GetProperties(ReflectionUtility.BindingInstancePublicAndPrivate).Where(info => info.CanWrite).ToDictionary(info => info.Name);
var propertyNames = properties.Select(info => info.Key).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).ToList();
List <object> args = new List <object>();
foreach (var ctr in constructors)
{
var arguments = ctr.GetParameters();
var argumentsLength = arguments.Select(info => info.Name).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).Count();
if (arguments.Length == argumentsLength)
{
foreach (var arg in arguments)
{
args.Add(ObjectConverter.ChangeType(values.First(pair => pair.Key.Equals(arg.Name, StringComparison.OrdinalIgnoreCase)).Value, arg.ParameterType));
}
break;
}
}
if (args.Count == 0)
{
var staticMethods = valueType.GetMethods(ReflectionUtility.BindingInstancePublicAndPrivateNoneInheritedIncludeStatic).Where(info => info.ReturnType == valueType && info.IsStatic && !info.IsSpecialName).ToList();
foreach (var method in staticMethods)
{
var arguments = method.GetParameters();
var argumentsLength = arguments.Select(info => info.Name).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).Count();
if (arguments.Length == argumentsLength)
{
foreach (var arg in arguments)
{
args.Add(ObjectConverter.ChangeType(values.First(pair => pair.Key.Equals(arg.Name, StringComparison.OrdinalIgnoreCase)).Value, arg.ParameterType));
}
return(method.Invoke(null, args.ToArray()));
}
}
throw new SerializationException("Unable to find a suitable constructor or static method for deserialization.");
}
var instance = Activator.CreateInstance(valueType, args.ToArray());
foreach (var propertyName in propertyNames)
{
var property = properties[propertyName];
property.SetValue(instance, ObjectConverter.ChangeType(values.First(pair => pair.Key == propertyName).Value, property.PropertyType));
}
return(instance);
}
/// <summary>
/// Executes the command statement, and returns the value as the specified <paramref name="returnType"/> from the first column of the first row in the result set.
/// Additional columns or rows are ignored.
/// </summary>
/// <param name="dataCommand">The data command to execute.</param>
/// <param name="returnType">The type to return the first column value as.</param>
/// <param name="provider">An object that supplies culture-specific formatting information.</param>
/// <param name="parameters">The parameters to use in the command.</param>
/// <returns>The first column of the first row in the result from <paramref name="dataCommand"/> as the specified <paramref name="returnType"/>.</returns>
public object ExecuteScalarAsType(IDataCommand dataCommand, Type returnType, IFormatProvider provider, params DbParameter[] parameters)
{
return(ObjectConverter.ChangeType(ExecuteScalar(dataCommand, parameters), returnType, provider));
}
