public static KeyInfo Create(PropertyInfo propertyInfo, DataMemberAttribute dataMember)
{
return new KeyInfo
{
Name = dataMember.Name ?? propertyInfo.Name,
IsRequired = dataMember.IsRequired
};
}
public void TestDataMemberAttribute ()
{
DataMemberAttribute x = new DataMemberAttribute ();
Assert.AreEqual (null, x.Name, "#01");
Assert.AreEqual (-1, x.Order, "#02");
Assert.AreEqual (true, x.EmitDefaultValue, "#02");
Assert.AreEqual (false, x.IsRequired, "#02");
}
/// <summary>
/// Inport parameters to the DB.
/// </summary>
/// <param name="target">Device, Category, Table or property that parameters are saved.</param>
/// <param name="id">Target ID.</param>
/// <param name="parent">Parent template.</param>
/// <param name="items">Keyvalue pair template who owns the parameter and value of the parameter.</param>
void ImportParameters(object target, ulong id, object parent, List<object[]> items)
{
DataMemberAttribute dma = new DataMemberAttribute();
object value;
foreach (PropertyDescriptor it in TypeDescriptor.GetProperties(target))
{
if (it.Name == "DisabledActions")
{
continue;
}
//If value is not stored.
DataMemberAttribute dm = it.Attributes[typeof(DataMemberAttribute)] as DataMemberAttribute;
if (dm == null)
{
continue;
}
ValueAccessAttribute va = it.Attributes[typeof(ValueAccessAttribute)] as ValueAccessAttribute;
if (va == null || va.RunTime != ValueAccessType.Edit)
{
continue;
}
//Save default value.
value = it.GetValue(target);
GXAmiParameterTemplate param = new GXAmiParameterTemplate();
param.ParentID = id;
param.Name = it.Name;
param.Value = value;
// param.Description
if (it.PropertyType == typeof(object) && param.Value != null)
{
param.Type = param.Value.GetType();
}
else
{
param.Type = it.PropertyType;
}
//If parameter is enum add possible values to the DB.
if (it.PropertyType.IsEnum)
{
List<GXAmiValueItem> values = new List<GXAmiValueItem>();
foreach(string val in Enum.GetNames(it.PropertyType))
{
GXAmiValueItem vi = new GXAmiValueItem();
//Parameter ID is updated after parameter template is saved to the DB.
vi.ParameterId = 0;
vi.UIValue = val;
values.Add(vi);
}
param.Values = values.ToArray();
}
param.Storable = it.Attributes.Contains(dma);
param.Access = va.RunTime;
items.Add(new object[] { parent, param });
}
}
public MemberContractMap(MemberInfo member, int sortOrder)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
this.member = member;
this.sortOrder = sortOrder;
this.contract = null;
}
public MemberContractMap(MemberInfo member, DataMemberAttribute contract)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
if (contract == null)
{
throw new ArgumentNullException("contract");
}
this.member = member;
this.contract = contract;
this.sortOrder = this.contract.Order;
}
public DataMemberInfo(MemberInfo member, DataMemberAttribute dma, string rootNamespce, string ns)
{
if (dma == null)
{
throw new ArgumentNullException("dma");
}
Order = dma.Order;
Member = member;
IsRequired = dma.IsRequired;
XmlName = XmlConvert.EncodeLocalName(dma.Name != null ? dma.Name : member.Name);
XmlNamespace = ns;
XmlRootNamespace = rootNamespce;
if (Member is FieldInfo)
{
MemberType = ((FieldInfo)Member).FieldType;
}
else
{
MemberType = ((PropertyInfo)Member).PropertyType;
}
}
List <DataMemberInfo> GetMembers(Type type)
{
List <DataMemberInfo> data_members = new List <DataMemberInfo> ();
BindingFlags flags = AllInstanceFlags | BindingFlags.DeclaredOnly;
foreach (PropertyInfo pi in type.GetProperties(flags))
{
DataMemberAttribute dma =
GetDataMemberAttribute(pi);
if (dma == null)
{
continue;
}
KnownTypes.Add(pi.PropertyType);
var map = KnownTypes.FindUserMap(pi.PropertyType);
if (!pi.CanRead || (!pi.CanWrite && !(map is ICollectionTypeMap)))
{
throw new InvalidDataContractException(String.Format(
"DataMember property '{0}' on type '{1}' must have both getter and setter.", pi, pi.DeclaringType));
}
data_members.Add(CreateDataMemberInfo(dma, pi, pi.PropertyType, KnownTypeCollection.GetStaticQName(pi.DeclaringType).Namespace));
}
foreach (FieldInfo fi in type.GetFields(flags))
{
DataMemberAttribute dma =
GetDataMemberAttribute(fi);
if (dma == null)
{
continue;
}
data_members.Add(CreateDataMemberInfo(dma, fi, fi.FieldType, KnownTypeCollection.GetStaticQName(fi.DeclaringType).Namespace));
}
return(data_members);
}
public static Type AddDataContractAttributeToType(Type type)
{
string typeName = "Derived_" + type.Name;
// create a dynamic assembly and module
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "tmpAssembly";
AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder module = assemblyBuilder.DefineDynamicModule("tmpModule");
// create a new type builder
TypeBuilder typeBuilder = module.DefineType(typeName, TypeAttributes.Public | TypeAttributes.Class
| TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout,
null, new Type[] { typeof(IEntity) });
{
DataContractAttribute dca = new DataContractAttribute();
ConstructorInfo ctor = typeof(DataContractAttribute).GetConstructor(new Type[] { });
CustomAttributeBuilder myCABuilder = new CustomAttributeBuilder(ctor, new object[] { },
new PropertyInfo[] { typeof(DataContractAttribute).GetProperty("Name") },
new object[] { typeName });
typeBuilder.SetCustomAttribute(myCABuilder);
}
int idx = 0;
// Loop over the attributes that will be used as the properties names in out new type
foreach (PropertyInfo propertyInfo in type.GetProperties())
{
string propertyName = propertyInfo.Name;
Type propertyType = propertyInfo.PropertyType;
bool supportedType = false;
if (propertyType.IsValueType)
{
if (propertyType.IsEnum)
{
propertyType = propertyType.GetEnumUnderlyingType();
}
supportedType = true;
}
else if (propertyType == typeof(string))
{
supportedType = true;
}
if (!supportedType)
continue;
// Generate a private field
FieldBuilder field = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
// Generate a public property
PropertyBuilder property = typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault,
propertyType, null);
// The property set and property get methods require a special set of attributes:
MethodAttributes GetSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
// Define the "get" accessor method for current private field.
MethodBuilder currGetPropMthdBldr = typeBuilder.DefineMethod("get_" + propertyName, GetSetAttr,
propertyType, Type.EmptyTypes);
// Intermediate Language stuff...
ILGenerator currGetIL = currGetPropMthdBldr.GetILGenerator();
currGetIL.Emit(OpCodes.Ldarg_0);
currGetIL.Emit(OpCodes.Ldfld, field);
currGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for current private field.
MethodBuilder currSetPropMthdBldr = typeBuilder.DefineMethod("set_" + propertyName, GetSetAttr,
null, new Type[] { propertyType });
// Again some Intermediate Language stuff...
ILGenerator currSetIL = currSetPropMthdBldr.GetILGenerator();
currSetIL.Emit(OpCodes.Ldarg_0);
currSetIL.Emit(OpCodes.Ldarg_1);
currSetIL.Emit(OpCodes.Stfld, field);
currSetIL.Emit(OpCodes.Ret);
// Last, we must map the two methods created above to our PropertyBuilder to
// their corresponding behaviors, "get" and "set" respectively.
property.SetGetMethod(currGetPropMthdBldr);
property.SetSetMethod(currSetPropMthdBldr);
DataMemberAttribute dca = new DataMemberAttribute();
ConstructorInfo ctor = typeof(DataMemberAttribute).GetConstructor(new Type[] { });
CustomAttributeBuilder myCABuilder = new CustomAttributeBuilder(ctor, new object[] { },
new PropertyInfo[] { typeof(DataMemberAttribute).GetProperty("Name"), typeof(DataMemberAttribute).GetProperty("Order") },
new object[] { propertyName, idx });
property.SetCustomAttribute(myCABuilder);
idx++;
}
// Generate our type
Type generetedType = typeBuilder.CreateType();
return generetedType;
}
public static Type GenerateTypeFromGridColumn(string gridName)
{
// create a dynamic assembly and module
AssemblyName assemblyName = new AssemblyName();
assemblyName.Name = "tmpAssembly";
AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
ModuleBuilder module = assemblyBuilder.DefineDynamicModule("tmpModule");
// create a new type builder
TypeBuilder typeBuilder = module.DefineType(gridName, TypeAttributes.Public | TypeAttributes.Class
| TypeAttributes.Class | TypeAttributes.AutoClass | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout,
null, new Type[] { typeof(IEntity) });
{
DataContractAttribute dca = new DataContractAttribute();
ConstructorInfo ctor = typeof(DataContractAttribute).GetConstructor(new Type[] { });
CustomAttributeBuilder myCABuilder = new CustomAttributeBuilder(ctor, new object[] { },
new PropertyInfo[] { typeof(DataContractAttribute).GetProperty("Name") },
new object[] { gridName });
typeBuilder.SetCustomAttribute(myCABuilder);
}
int idx = 0;
// Loop over the attributes that will be used as the properties names in out new type
foreach (GridColumnInfo info in ADInfoBll.Instance.GetGridColumnInfos(gridName))
{
if (info.GridColumnType != GridColumnType.Normal
&& info.GridColumnType != GridColumnType.ExpressionColumn)
continue;
string propertyName = info.GridColumnName;
Type propertyType = typeof(string);
//Type propertyType = info.CreateType();
//if (propertyType.IsEnum || propertyType.IsClass || info.CellViewerManager == "Combo")
//{
// propertyType = typeof(string);
//}
//if (!propertyType.IsClass/* && Authority.AuthorizeByRule(info.NotNull)*/)
//{
// propertyType = Utils.ReflectionHelper.CreateGenericType(typeof(Nullable<>), new Type[] { propertyType });
//}
// Generate a private field
FieldBuilder field = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
// Generate a public property
PropertyBuilder property = typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault,
propertyType, null);
// The property set and property get methods require a special set of attributes:
MethodAttributes GetSetAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig;
// Define the "get" accessor method for current private field.
MethodBuilder currGetPropMthdBldr = typeBuilder.DefineMethod("get_" + propertyName, GetSetAttr,
propertyType, Type.EmptyTypes);
// Intermediate Language stuff...
ILGenerator currGetIL = currGetPropMthdBldr.GetILGenerator();
currGetIL.Emit(OpCodes.Ldarg_0);
currGetIL.Emit(OpCodes.Ldfld, field);
currGetIL.Emit(OpCodes.Ret);
// Define the "set" accessor method for current private field.
MethodBuilder currSetPropMthdBldr = typeBuilder.DefineMethod("set_" + propertyName, GetSetAttr,
null, new Type[] { propertyType });
// Again some Intermediate Language stuff...
ILGenerator currSetIL = currSetPropMthdBldr.GetILGenerator();
currSetIL.Emit(OpCodes.Ldarg_0);
currSetIL.Emit(OpCodes.Ldarg_1);
currSetIL.Emit(OpCodes.Stfld, field);
currSetIL.Emit(OpCodes.Ret);
// Last, we must map the two methods created above to our PropertyBuilder to
// their corresponding behaviors, "get" and "set" respectively.
property.SetGetMethod(currGetPropMthdBldr);
property.SetSetMethod(currSetPropMthdBldr);
DataMemberAttribute dca = new DataMemberAttribute();
ConstructorInfo ctor = typeof(DataMemberAttribute).GetConstructor(new Type[] { });
CustomAttributeBuilder myCABuilder = new CustomAttributeBuilder(ctor, new object[] { },
new PropertyInfo[] { typeof(DataMemberAttribute).GetProperty("Name"), typeof(DataMemberAttribute).GetProperty("Order") },
new object[] { propertyName, idx });
property.SetCustomAttribute(myCABuilder);
idx++;
}
// Generate our type
Type generetedType = typeBuilder.CreateType();
return generetedType;
}
public static MetadataDataMember ToDataMember(DataMemberAttribute attr)
{
if (attr == null) return null;
var metaAttr = new MetadataDataMember
{
Name = attr.Name,
EmitDefaultValue = attr.EmitDefaultValue != true ? attr.EmitDefaultValue : (bool?)null,
Order = attr.Order >= 0 ? attr.Order : (int?)null,
IsRequired = attr.IsRequired != false ? attr.IsRequired : (bool?)null,
};
return metaAttr;
}
public TypeMapProperty (PropertyInfo pi, DataMemberAttribute dma)
: base (pi, dma)
{
this.property = pi;
}
public TypeMapField (FieldInfo fi, DataMemberAttribute dma)
: base (fi, dma)
{
this.field = fi;
}
protected TypeMapMember (MemberInfo mi, DataMemberAttribute dma)
{
this.mi = mi;
this.dma = dma;
}
private static string GetModelPropertyName(PropertyInfo prop, DataMemberAttribute dataMemberAttribute)
{
var name = dataMemberAttribute == null ? prop.Name : (dataMemberAttribute.Name ?? prop.Name);
return UseCamelCaseModelPropertyNames
? (UseLowercaseUnderscoreModelPropertyNames ? name.ToLowercaseUnderscore() : name.ToCamelCase())
: name;
}
private static CustomAttributeBuilder GetDataMemberAttributeBuilder(DataMemberAttribute dataMemberAtt)
{
Dictionary<string, object> dataMemberProperties = new Dictionary<string, object>();
Type dataMemberType = typeof(DataMemberAttribute);
if (dataMemberAtt != null)
{
if (dataMemberAtt.Name != null)
{
dataMemberProperties["Name"] = dataMemberAtt.Name;
}
if (!dataMemberAtt.EmitDefaultValue)
{
dataMemberProperties["EmitDefaultValue"] = false;
}
if (dataMemberAtt.IsRequired)
{
dataMemberProperties["IsRequired"] = true;
}
// The only other property is Order. Since we don't allow this in code gen, we should not allow it here.
}
return GetAttributeBuilder(dataMemberType, dataMemberProperties);
}
/// <summary>
/// Initializes a new instance of <see cref="FieldBinding"/>.
/// </summary>
/// <param name="fieldInfo">The <see cref="FieldInfo"/> associated with this <see cref="FieldBinding"/>.</param>
public FieldBinding(FieldInfo fieldInfo)
{
Verify.NotNull(fieldInfo, nameof(fieldInfo));
this.fieldInfo = fieldInfo;
this.propertyInfo = GetPropertyInfo(fieldInfo);
this.metadata = GetDataMemberAttribute(fieldInfo, propertyInfo);
this.ignore = CannotBindField(fieldInfo, propertyInfo);
}
/// <summary>
/// Get the <see cref="DataMemberAttribute"/> associated with the field or property.
/// </summary>
/// <param name="fieldInfo">The <see cref="FieldInfo"/> instance to check for a <see cref="DataMemberAttribute"/> instance.</param>
/// <param name="propertyInfo">The <see cref="PropertyInfo"/> instance to check for a <see cref="DataMemberAttribute"/> instance.</param>
private static DataMemberAttribute GetDataMemberAttribute(FieldInfo fieldInfo, PropertyInfo propertyInfo)
{
DataMemberAttribute attribute;
String name = propertyInfo == null ? fieldInfo.Name : propertyInfo.Name;
attribute = propertyInfo == null ? fieldInfo.GetCustomAttribute<DataMemberAttribute>() : propertyInfo.GetCustomAttribute<DataMemberAttribute>();
if (attribute == null)
attribute = new DataMemberAttribute { EmitDefaultValue = false, IsRequired = false, Name = name };
if (attribute.Name.IsNullOrWhiteSpace())
attribute.Name = name;
return attribute;
}
