/// <summary>
/// Gets the property's value.
/// </summary>
/// <typeparam name="T">
/// The property value type. This must be the same as the type returned by <see cref="PropertyAccessorData.PropertyType"/>: For simple value properties,
/// this is the simple property type. For related objects, this is the related object's type. For related object collections,
/// this is <see cref="ObjectList{T}"/>, where "T" is the related objects' type.
/// </typeparam>
/// <returns>The value of the encapsulated property. For simple value properties,
/// this is the property value. For related objects, this is the related object. For related object collections,
/// this is an <see cref="ObjectList{T}"/>, where "T" is the related objects' type.</returns>
/// <exception cref="InvalidTypeException">
/// The type requested via <typeparamref name="T"/> is not the same as the property's type indicated by <see cref="PropertyAccessorData.PropertyType"/>.
/// </exception>
/// <exception cref="ClientTransactionsDifferException">The <see cref="DomainObject"/> cannot be used in the current <see cref="DomainObjects.ClientTransaction"/>.</exception>
/// <exception cref="ObjectInvalidException">The object is invalid in the associated <see cref="ClientTransaction"/>.</exception>
public T GetValue <T> ()
{
CheckType(typeof(T));
object value = GetValueWithoutTypeCheck();
Assertion.DebugAssert(
value != null || NullableTypeUtility.IsNullableType(PropertyData.PropertyType),
"Property '{0}' is a value type but the DataContainer returned null.",
PropertyData.PropertyIdentifier);
try
{
return((T)value);
}
catch (InvalidCastException ex)
{
Assertion.IsNotNull(value, "Otherwise, the cast would have succeeded (ref type) or thrown a NullReferenceException (value type).");
var message = string.Format(
"The property '{0}' was expected to hold an object of type '{1}', but it returned an object of type '{2}'.",
PropertyData.PropertyIdentifier,
PropertyData.PropertyType,
value.GetType());
throw new InvalidTypeException(message, ex);
}
}
private void CheckConstructorArguments(ConstructorInfo constructor, object[] constructorArguments)
{
var parameters = constructor.GetParameters();
if (parameters.Length != constructorArguments.Length)
{
var message = string.Format("Expected {0} constructor argument(s), but was {1}.", parameters.Length, constructorArguments.Length);
throw new ArgumentException(message, "constructorArguments");
}
for (int i = 0; i < parameters.Length; i++)
{
var parameterType = parameters[i].ParameterType;
var argument = constructorArguments[i];
if (argument == null)
{
if (!NullableTypeUtility.IsNullableType(parameterType))
{
var message = string.Format("Constructor parameter at position {0} of type '{1}' cannot be null.", i, parameterType);
throw new ArgumentException(message, "constructorArguments");
}
}
else if (!parameterType.IsInstanceOfType(argument))
{
throw ArgumentUtility.CreateArgumentItemTypeException("constructorArguments", i, parameterType, argument.GetType());
}
}
}
private Type GetPropertyType(PropertyDefinition propertyDefinition)
{
var propertyType = propertyDefinition.IsObjectID ? propertyDefinition.PropertyInfo.PropertyType : propertyDefinition.PropertyType;
if (NullableTypeUtility.IsNullableType(propertyType))
{
propertyType = NullableTypeUtility.GetBasicType(propertyType);
}
return(propertyType);
}
public void CollectPropertyType(PropertyDefinition propertyDefinition)
{
ArgumentUtility.CheckNotNull("propertyDefinition", propertyDefinition);
var propertyType = propertyDefinition.PropertyType;
if (NullableTypeUtility.IsNullableType(propertyType))
{
propertyType = NullableTypeUtility.GetBasicType(propertyType);
}
if (propertyType.IsEnum)
{
_enumTypes.Add(propertyType);
}
}
private void CheckEnumValue(object value, PropertyDefinition definition)
{
if (value != null)
{
Type underlyingType = definition.IsNullable ? NullableTypeUtility.GetBasicType(definition.PropertyType) : definition.PropertyType;
if (!EnumUtility.IsValidEnumValue(underlyingType, value))
{
string message = string.Format(
"Value '{0}' for property '{1}' is not defined by enum type '{2}'.",
value,
definition.PropertyName,
underlyingType);
throw new InvalidEnumValueException(message, definition.PropertyName, underlyingType, value);
}
}
}
public PropertyDefinition(
ClassDefinition classDefinition,
IPropertyInformation propertyInfo,
string propertyName,
bool isObjectID,
bool isNullable,
int?maxLength,
StorageClass storageClass)
{
ArgumentUtility.CheckNotNull("classDefinition", classDefinition);
ArgumentUtility.CheckNotNullOrEmpty("propertyName", propertyName);
ArgumentUtility.CheckNotNull("propertyInfo", propertyInfo);
_classDefinition = classDefinition;
_propertyInfo = propertyInfo;
_propertyType = isObjectID ? typeof(ObjectID) : propertyInfo.PropertyType;
_propertyName = propertyName;
_isObjectID = isObjectID;
_isNullablePropertyType = NullableTypeUtility.IsNullableType(propertyInfo.PropertyType);
_isNullable = isNullable;
_maxLength = maxLength;
_storageClass = storageClass;
}
/// <summary>
/// Warning: this method uses System.Windows.Forms.MessageBox.
/// </summary>
/// <param name="element"></param>
static public void GetTableElementDictionary(this TableElement element)
{
element.conversionElements.Clear();
// ac_table
element.conversionElements.Add("TableType", element.DbType);
element.conversionElements.Add("tabletype", string.Format("{0}", element.DbType).ToLower());
// see the primary key related tags below
element.conversionElements.Add("PK", element.PrimaryKey);
element.conversionElements.Add("pk", element.PrimaryKey == null ? string.Empty : element.PrimaryKey.ToLower());
element.conversionElements.Add("PrimaryKey", element.PrimaryKey == null ? string.Empty : element.PrimaryKey);
element.conversionElements.Add("PrimaryKeyCleanC", element.PrimaryKey == null ? string.Empty : element.PrimaryKey.ToStringCapitolize().Clean());
element.conversionElements.Add("primarykey", element.PrimaryKey == null ? string.Empty : element.PrimaryKey.ToLower());
//
element.conversionElements.Add("Table", element.Name.Replace("-", "_"));
//
element.conversionElements.Add("TableName", element.Name);
element.conversionElements.Add("tablename", element.Name.ToLower());
//
element.conversionElements.Add("TableNameC", element.Name.ToStringCapitolize());
element.conversionElements.Add("TableNameClean", element.FriendlyName);
element.conversionElements.Add("tablenameclean", element.FriendlyName.ToLower());
element.conversionElements.Add("TableNameCClean", element.FriendlyName.ToStringCapitolize());
//
element.conversionElements.Add("TableCleanName", element.Name.Clean());
element.conversionElements.Add("TableCleanNameC", element.Name.Clean().ToStringCapitolize());
//
element.conversionElements.Add("AdapterNs", element.NsAdapter);
element.conversionElements.Add("AdapterT", element.TAdapter);
element.conversionElements.Add("AdapterNsT", element.TypeAdapter);
//
element.conversionElements.Add("CommandNs", element.NsCommand);
element.conversionElements.Add("CommandT", element.TCommand);
element.conversionElements.Add("CommandNsT", element.TypeCommand);
//
element.conversionElements.Add("ConnectionNs", element.NsConnection);
element.conversionElements.Add("ConnectionT", element.TConnection);
element.conversionElements.Add("ConnectionNsT", element.TypeConnection);
//
element.conversionElements.Add("ParameterT", element.TParameter);
//
element.conversionElements.Add("ReaderNs", element.NsReader);
element.conversionElements.Add("ReaderT", element.TReader);
element.conversionElements.Add("ReaderNsT", element.TypeReader);
//
element.conversionElements.Add("Date", DateTime.Now.ToString("MM/dd/yyyy"));
element.conversionElements.Add("Time", DateTime.Now.ToString("hh:mm.ss tt"));
element.conversionElements.Add("DateTime", string.Format("{0:MM/dd/yyyy} {1:hh:mm.ss tt}", DateTime.Now, DateTime.Now));
//
if (element.PrimaryKey == null)
{
System.Windows.Forms.MessageBox.Show("Table must provide a primary key", "Please check the table.");
return;
}
else if (element.PrimaryKey != string.Empty)
{
element.conversionElements.Add("PKDataName", element.PrimaryKeyElement.DataName);
element.conversionElements.Add("PKDataType", element.PrimaryKeyElement.DataType);
element.conversionElements.Add("PKDataTypeNative", element.PrimaryKeyElement.DataTypeNative);
element.conversionElements.Add("PKNativeNullType", NullableTypeUtility.GetNativeNullType(element.PrimaryKeyElement["Native"].ToString()));
element.conversionElements.Add("PKNativeNullValue", NullableTypeUtility.IsNativeNullable(element.PrimaryKeyElement["Native"].ToString()) ? ".Value" : "");
// Add("PKDataTypeNative", PrimaryKeyElement.DataTypeNative);
element.conversionElements.Add("PKDescription", element.PrimaryKeyElement.Description);
//
element.conversionElements.Add("PKDataNameC", element.PrimaryKeyElement.DataName.ToStringCapitolize());
element.conversionElements.Add("PKCleanName", element.PrimaryKeyElement.DataName.Replace("-", "_"));
element.conversionElements.Add("PKCleanName,Nodash", element.PrimaryKeyElement.DataName.Clean());
element.conversionElements.Add("PKFriendlyName", element.PrimaryKeyElement.DataName.Clean());
element.conversionElements.Add("PKFriendlyNameC", element.PrimaryKeyElement.DataName.Clean().ToStringCapitolize());
}
else
{
Global.statR(ResourceUtil.ResourceManager.GetString("TableElement_PrimaryKeyNotFound"), element.Name);
}
}
private bool IsNullSupported(Type dotNetType)
{
return(NullableTypeUtility.IsNullableType(dotNetType));
}
public void GetBasicType_ReferenceType()
{
Assert.That(NullableTypeUtility.GetBasicType(typeof(string)), Is.EqualTo(typeof(string)));
}
public void GetBasicType_NullableValueType()
{
Assert.That(NullableTypeUtility.GetBasicType(typeof(int?)), Is.EqualTo(typeof(int)));
}
public void GetNullableType_WithNull_ThrowsArgumentNullException()
{
Assert.That(
() => NullableTypeUtility.GetNullableType(null),
Throws.TypeOf <ArgumentNullException>().With.Message.EndsWith("Parameter name: type"));
}
public void IsNullableType_ReferenceType()
{
Assert.That(NullableTypeUtility.IsNullableType(typeof(object)), Is.True);
Assert.That(NullableTypeUtility.IsNullableType(typeof(string)), Is.True);
}
public void IsNullableType_NullableValueType()
{
Assert.That(NullableTypeUtility.IsNullableType(typeof(int?)), Is.True);
Assert.That(NullableTypeUtility.IsNullableType(typeof(DateTime?)), Is.True);
}
public void IsNullableType_ValueType()
{
Assert.That(NullableTypeUtility.IsNullableType(typeof(int)), Is.False);
Assert.That(NullableTypeUtility.IsNullableType(typeof(DateTime)), Is.False);
}
virtual public void InitializeDictionary()
{
conversionElements.Clear();
// ac_table
//
#region Table Type
Add(StrKeys.TableType, DbType);
Add(StrKeys.tabletype, string.Format("{0}", DbType).ToLower());
#endregion
//
#region Primary Key
// see the primary key related tags below
Add(StrKeys.PK, PrimaryKey);
Add(StrKeys.pk, PrimaryKey == null ? string.Empty : PrimaryKey.ToLower());
Add(StrKeys.PrimaryKey, PrimaryKey ?? string.Empty);
Add(StrKeys.PrimaryKeyCleanC, PrimaryKey == null ? string.Empty : PrimaryKey.ToStringCapitolize().Clean());
Add(StrKeys.primarykey, PrimaryKey == null ? string.Empty : PrimaryKey.ToLower());
#endregion
//
#region TableName
//
Add(StrKeys.Name, Name);
Add(StrKeys.Table, Name.Replace("-", "_"));
try {
Add(StrKeys.TableAlias, View != null ? View.Alias : Link != null ? Link.Alias : Name);
Add(StrKeys._TableAlias, View != null ? View.Alias : Link != null ? Link.Alias : Name.Replace("-", "_"));
Add(StrKeys.tablealias, (conversionElements[StrKeys.TableAlias] as string).ToLower());
//
Add(StrKeys.TableAliasC, conversionElements[StrKeys.TableAlias].ToStringCapitolize());
Add(StrKeys.FriendlyTableAlias, (conversionElements[StrKeys.TableAlias] as string).Clean());
Add(StrKeys.TableAliasClean, conversionElements[StrKeys.FriendlyTableAlias]);
Add(StrKeys.tablealiasclean, (conversionElements[StrKeys.TableAlias] as string).ToLower());
Add(StrKeys.TableAliasCClean, conversionElements[StrKeys.TableAlias].ToStringCapitolize());
Add(StrKeys.TABLEALIASCLEAN, (conversionElements[StrKeys.TableAlias] as string).ToUpper());
//
// Add("AliasCClean", conversionElements["FriendlyAlias"].ToStringCapitolize());
//
Add(StrKeys.TableAliasCName, (conversionElements[StrKeys.TableAlias] as string).Clean());
Add(StrKeys.TableAliasCNameC, (conversionElements[StrKeys.TableAliasCName] as string).ToStringCapitolize());
} catch (Exception error) {
Logger.Warn("Parse Exception", error.Message);
}
//
Add(StrKeys.TableName, Name);
Add(StrKeys.tablename, Name.ToLower());
//
Add(StrKeys.TableNameC, Name.ToStringCapitolize());
Add(StrKeys.TableNameClean, FriendlyName);
Add(StrKeys.tablenameclean, FriendlyName.ToLower());
Add(StrKeys.TableNameCClean, FriendlyName.ToStringCapitolize());
//
Add(StrKeys.TableCleanName, Name.Clean());
Add(StrKeys.TableCleanNameC, Name.Clean().ToStringCapitolize());
#endregion
//
#region Namespace Types
Add(StrKeys.AdapterNs, NsAdapter);
Add(StrKeys.AdapterT, TAdapter);
Add(StrKeys.AdapterNsT, TypeAdapter);
//
Add(StrKeys.CommandNs, NsCommand);
Add(StrKeys.CommandT, TCommand);
Add(StrKeys.CommandNsT, TypeCommand);
//
Add(StrKeys.ConnectionNs, NsConnection);
Add(StrKeys.ConnectionT, TConnection);
Add(StrKeys.ConnectionNsT, TypeConnection);
//
Add(StrKeys.ParameterT, TParameter);
//
Add(StrKeys.ReaderNs, NsReader);
Add(StrKeys.ReaderT, TReader);
Add(StrKeys.ReaderNsT, TypeReader);
#endregion
//
GeneratorTypeProvider.GetTypes <GeneratorDateTimeFieldProvider>(conversionElements);
#region Primary Key Automated Reference (NOT FOR VIEWS)
//
if (PrimaryKey == null)
{
ErrorMessage.Show("Table must provide a primary key", "Please check the table.");
return;
}
else if (PrimaryKey != string.Empty && PrimaryKey != "%PKUNKNOWN%")
{
Add(StrKeys.PKDataName, PrimaryKeyElement.DataName);
Add(StrKeys.PKDataType, PrimaryKeyElement.DataType);
Add(StrKeys.PKDataTypeNative, PrimaryKeyElement.DataTypeNative);
Add(StrKeys.PKNativeNullType, NullableTypeUtility.GetNativeNullType(PrimaryKeyElement[StrKeys.Native].ToString()));
Add(StrKeys.PKNativeIsNullable, PrimaryKeyElement.IsNullable);
Add(StrKeys.PKNativeNullValue, NullableTypeUtility.IsNativeNullable(PrimaryKeyElement[StrKeys.Native].ToString()) ? ".Value" : "");
Add(StrKeys.PKNativeNullValueGo, PrimaryKeyElement.Params[StrKeys.NativeNullTypeGo].ToString());
Add(StrKeys.PKNativeNullValueGoAddress, PrimaryKeyElement.IsNullable ? "&" : string.Empty);
Add(StrKeys.PKNativeNullValueGoPointer, PrimaryKeyElement.IsNullable ? "*" : string.Empty);
// Add("PKDataTypeNative",PrimaryKeyElement.DataTypeNative);
Add(StrKeys.PKDescription, PrimaryKeyElement.Description);
//
Add(StrKeys.PKDataNameC, PrimaryKeyElement.DataName.ToStringCapitolize());
Add(StrKeys.PKCleanName, PrimaryKeyElement.DataName.Replace("-", "_"));
Add(StrKeys.PKCleanName_Nodash, PrimaryKeyElement.DataName.Clean());
Add(StrKeys.PKFriendlyName, PrimaryKeyElement.DataName.Clean());
Add(StrKeys.PKFriendlyNameC, PrimaryKeyElement.DataName.Clean().ToStringCapitolize());
}
else
{
Logger.Warn("TableElement.InitializeDictionary", Gen.Messages.TableElement_PrimaryKeyNotFound, Name);
}
#endregion
if (Transform != null)
{
Transform(conversionElements);
}
}
