/// <summary>
/// Append the property definition
/// </summary>
/// <param name="propertyDefinitions"></param>
private void AppendPropertyDefinition(IList <PropertyConfigurationType> propertyDefinitions)
{
for (int i = 0; i < propertyDefinitions.Count; i++)
{
PropertyConfigurationType propertyDefinition = propertyDefinitions[i];
PropertyInfo pi = objectType.GetProperty(propertyDefinition.Name);
if (pi == null)
{
throw new TypeLoadException(
string.Format(ErrorNoPropertyExists, propertyDefinition.Name, objectType.Name));
}
if (!string.IsNullOrEmpty(propertyDefinition.Ref))
{
var refType = GetRefType(propertyDefinition.Ref, pi.PropertyType);
if (refType == null)
{
throw new TypeLoadException(
string.Format(ErrorSettingRefProperty, propertyDefinition.Name, objectType.Name));
}
propertyRefTypes.Add(refType);
properties.Add(pi);
propertyValueTypes.Add(refType.GetType());
}
else if (TypeSerializer.CanCreateFromString(pi.PropertyType))
{
properties.Add(pi);
propertyValueTypes.Add(pi.PropertyType);
}
else
{
throw new TypeLoadException(
string.Format(ErrorPropertyTypeNotSupported, propertyDefinition.Name, objectType.Name));
}
}
}
protected override string GetUndefinedColumnDefinition(Type fieldType, int?fieldLength)
{
if (TypeSerializer.CanCreateFromString(fieldType))
{
return(string.Format(StringLengthColumnDefinitionFormat, fieldLength.HasValue ? fieldLength.Value.ToString() : "MAX"));
}
return(base.GetUndefinedColumnDefinition(fieldType, fieldLength));
}
public void Can_convert_to_nullable_datetime()
{
Assert.That(TypeSerializer.CanCreateFromString(typeof(DateTime?)), Is.True);
DateTime?dateValue = new DateTime(1979, 5, 9);
var actualValue = TypeSerializer.DeserializeFromString <DateTime?>("1979-05-09");
Assert.That(actualValue, Is.EqualTo(dateValue));
}
public void Can_convert_to_nullable_enum()
{
Assert.That(TypeSerializer.CanCreateFromString(typeof(TestEnum?)), Is.True);
TestEnum?enumValue = TestEnum.EnumValue1;
var actualValue = TypeSerializer.DeserializeFromString <TestEnum?>(enumValue.ToString());
Assert.That(actualValue, Is.EqualTo(enumValue));
}
public void Can_convert_string_collection()
{
Assert.That(TypeSerializer.CanCreateFromString(typeof(string[])), Is.True);
var stringValue = TypeSerializer.SerializeToString(stringValues);
var expectedString = "[" + string.Join(",", stringValues.ToArray()) + "]";
Assert.That(stringValue, Is.EqualTo(expectedString));
}
protected virtual string GetUndefinedColumnDefinition(Type fieldType, int?fieldLength)
{
if (TypeSerializer.CanCreateFromString(fieldType))
{
return(string.Format(StringLengthColumnDefinitionFormat, fieldLength.GetValueOrDefault(DefaultStringLength)));
}
throw new NotSupportedException(
string.Format("Property of type: {0} is not supported", fieldType.FullName));
}
public void Can_convert_to_Byte_array()
{
Assert.That(TypeSerializer.CanCreateFromString(typeof(byte[])), Is.True);
var byteArrayValue = new byte[] { 0, 65, 97, 255, };
var byteArrayString = TypeSerializer.SerializeToString(byteArrayValue);
var actualValue = TypeSerializer.DeserializeFromString <byte[]>(byteArrayString);
Assert.That(actualValue, Is.EqualTo(byteArrayValue));
}
public void Can_convert_Guid()
{
Assert.That(TypeSerializer.CanCreateFromString(typeof(Guid)), Is.True);
var guidValue = Guid.NewGuid();
var stringValue = TypeSerializer.SerializeToString(guidValue);
var expectedString = guidValue.ToString("N");
Assert.That(stringValue, Is.EqualTo(expectedString));
}
protected virtual string GetUndefinedColumnDefintion(Type fieldType)
{
if (TypeSerializer.CanCreateFromString(fieldType))
{
return(this.StringColumnDefinition);
}
throw new NotSupportedException(
string.Format("Property of type: {0} is not supported", fieldType.FullName));
}
public void Can_convert_comma_delimited_string_to_List_String()
{
Assert.That(TypeSerializer.CanCreateFromString(typeof(List <string>)), Is.True);
var stringValueList = "[" + string.Join(",", stringValues) + "]";
var convertedJsvValues = TypeSerializer.DeserializeFromString <List <string> >(stringValueList);
Assert.That(convertedJsvValues, Is.EquivalentTo(stringValues));
var convertedJsonValues = JsonSerializer.DeserializeFromString <List <string> >(stringValueList);
Assert.That(convertedJsonValues, Is.EquivalentTo(stringValues));
}
/// <summary>
/// Find the right constructor for the matching types
/// </summary>
/// <param name="constructorArgDefinitions"></param>
private void AppendConstructorDefinition(IList <PropertyConfigurationType> constructorArgDefinitions)
{
foreach (ConstructorInfo ci in objectType.GetConstructors())
{
ParameterInfo[] constructorParams = ci.GetParameters();
//We can only call a constructor that has the right number of arguments.
bool possibleMatch = constructorParams.Length == constructorArgDefinitions.Count;
if (possibleMatch)
{
for (int i = 0; i < constructorParams.Length; i++)
{
ParameterInfo constructorParam = constructorParams[i];
PropertyConfigurationType constructorArgDefinition = constructorArgDefinitions[i];
if (!string.IsNullOrEmpty(constructorArgDefinition.Ref))
{
RefType refType = GetRefType(constructorArgDefinition.Ref, constructorParam.ParameterType);
constructorRefTypes.Add(refType);
constructorValueTypes.Add(refType.GetType());
}
else if (TypeSerializer.CanCreateFromString(constructorParam.ParameterType))
{
constructorValueTypes.Add(constructorParam.ParameterType);
}
else
{
break;
}
}
bool matchingConstructorFound = constructorValueTypes.Count == constructorParams.Length;
if (matchingConstructorFound)
{
constructorInfo = ci;
return;
}
}
}
//if it got this far no matching constructor *that we can use* has been found
throw new TypeLoadException(string.Format(ErrorNoMatchingConstructor, objectType.Name));
}
public virtual string GetQuotedValue(object value, Type fieldType)
{
if (value == null)
{
return("NULL");
}
if (!fieldType.UnderlyingSystemType.IsValueType && fieldType != typeof(string))
{
if (TypeSerializer.CanCreateFromString(fieldType))
{
return("'" + EscapeParam(TypeSerializer.SerializeToString(value)) + "'");
}
throw new NotSupportedException(
string.Format("Property of type: {0} is not supported", fieldType.FullName));
}
return(ShouldQuoteValue(fieldType)
? "'" + EscapeParam(value) + "'"
: value.ToString());
}
public virtual string GetQuotedValue(object value, Type fieldType)
{
if (value == null)
{
return("NULL");
}
if (!fieldType.UnderlyingSystemType.IsValueType && fieldType != typeof(string))
{
if (TypeSerializer.CanCreateFromString(fieldType))
{
return(OrmLiteConfig.DialectProvider.GetQuotedValue(TypeSerializer.SerializeToString(value)));
}
throw new NotSupportedException(
string.Format("Property of type: {0} is not supported", fieldType.FullName));
}
if (fieldType == typeof(float))
{
return(((float)value).ToString(CultureInfo.InvariantCulture));
}
if (fieldType == typeof(double))
{
return(((double)value).ToString(CultureInfo.InvariantCulture));
}
if (fieldType == typeof(decimal))
{
return(((decimal)value).ToString(CultureInfo.InvariantCulture));
}
return(ShouldQuoteValue(fieldType)
? OrmLiteConfig.DialectProvider.GetQuotedValue(value.ToString())
: value.ToString());
}