public static void Run()
{
Console.WriteLine(nameof(TestAttributeExpressions));
TypeAttribute attr1 = typeof(Holder1).GetCustomAttribute <TypeAttribute>();
if (attr1.SomeType.ToString() != "ReflectionTest+TestAttributeExpressions+FirstNeverUsedType*[,]")
{
throw new Exception();
}
TypeAttribute attr2 = typeof(Holder2).GetCustomAttribute <TypeAttribute>();
if (attr2.SomeType.ToString() != "ReflectionTest+TestAttributeExpressions+Gen`1[ReflectionTest+TestAttributeExpressions+SecondNeverUsedType]")
{
throw new Exception();
}
EnumArrayAttribute attr3 = typeof(Holder3).GetCustomAttribute <EnumArrayAttribute>();
if (attr3.EnumArray[0] != 0)
{
throw new Exception();
}
}
static UserDefinedTypeCache()
{
TypeAttribute typeAttribute = typeof(T).GetCustomAttribute(typeof(TypeAttribute)) as TypeAttribute;
if (typeAttribute == null)
{
throw new TypeLoadException($"Unable to cache type {typeof(T).Name} as it does not have a 'Type' attribute");
}
Dictionary <string, PropertyInfo> properties = new Dictionary <string, PropertyInfo>();
Dictionary <string, string> aliases = new Dictionary <string, string>();
foreach (PropertyInfo property in typeof(T).GetProperties())
{
if (Attribute.IsDefined(property, typeof(IgnoreAttribute)))
{
continue;
}
ColumnAttribute column = property.GetCustomAttribute(typeof(ColumnAttribute)) as ColumnAttribute;
string columnName = column?.Name ?? property.Name;
properties.Add(columnName, property);
aliases.Add(property.Name, columnName);
}
CachedType = new UserDefinedType()
{
Columns = properties,
KeyspaceName = typeAttribute.KeyspaceName,
TypeName = typeAttribute.TypeName ?? typeof(T).Name,
Aliases = aliases
};
}
public ActionResult Create(TypeAttribute typeAttribute)
{
if (ModelState.IsValid)
{
var user = Session["User"] as User;
typeAttribute.CreateAt = DateTime.Now;
typeAttribute.Status = true;
typeAttribute.CreateBy = user.Id;
if (_typeAttribute.GetAll().FirstOrDefault(x => x.TypeName == typeAttribute.TypeName) != null)
{
ModelState.AddModelError("TypeName", "Category already exists");
return(View(typeAttribute));
}
try
{
if (_typeAttribute.Create(typeAttribute))
{
TempData["CreateSuccess"] = "Create Success";
return(RedirectToAction("Index"));
}
else
{
return(View(typeAttribute));
}
}
catch (Exception)
{
return(View(typeAttribute));
}
}
return(View());
}
static Column()
{
Type type = typeof(valueType);
if (type.IsEnum || !type.IsValueType)
{
AutoCSer.LogHelper.Error(type.fullName() + " 非值类型，不能用作数据列", LogLevel.Error | LogLevel.AutoCSer);
return;
}
attribute = TypeAttribute.GetAttribute <ColumnAttribute>(type, true) ?? ColumnAttribute.Default;
foreach (MethodInfo method in type.GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic))
{
#if NOJIT
if (typeof(ICustom).IsAssignableFrom(method.ReturnType)
#else
if (typeof(ICustom <valueType>).IsAssignableFrom(method.ReturnType)
#endif
&& method.GetParameters().Length == 0 && method.IsDefined(typeof(ColumnAttribute), false))
{
object customValue = method.Invoke(null, null);
if (customValue != null)
{
#if NOJIT
custom = (ICustom)customValue;
#else
custom = (ICustom <valueType>)customValue;
#endif
return;
}
}
}
Fields = Field.Get(MemberIndexGroup <valueType> .GetFields(attribute.MemberFilters), true).ToArray();
dataColumns = new AutoCSer.Threading.LockDictionary <HashString, KeyValue <string, Type>[]>();
AutoCSer.Memory.Common.AddClearCache(dataColumns.Clear, typeof(Column <valueType>), 60 * 60);
}
public virtual void TestCaptureState()
{
// init a first instance
AttributeSource src = new AttributeSource();
TermAttribute termAtt = (TermAttribute)src.AddAttribute(typeof(TermAttribute));
TypeAttribute typeAtt = (TypeAttribute)src.AddAttribute(typeof(TypeAttribute));
termAtt.SetTermBuffer("TestTerm");
typeAtt.SetType("TestType");
int hashCode = src.GetHashCode();
AttributeSource.State state = src.CaptureState();
// modify the attributes
termAtt.SetTermBuffer("AnotherTestTerm");
typeAtt.SetType("AnotherTestType");
Assert.IsTrue(hashCode != src.GetHashCode(), "Hash code should be different");
src.RestoreState(state);
Assert.AreEqual("TestTerm", termAtt.Term());
Assert.AreEqual("TestType", typeAtt.Type());
Assert.AreEqual(hashCode, src.GetHashCode(), "Hash code should be equal after restore");
// restore into an exact configured copy
AttributeSource copy = new AttributeSource();
copy.AddAttribute(typeof(TermAttribute));
copy.AddAttribute(typeof(TypeAttribute));
copy.RestoreState(state);
Assert.AreEqual(src.GetHashCode(), copy.GetHashCode(), "Both AttributeSources should have same hashCode after restore");
Assert.AreEqual(src, copy, "Both AttributeSources should be equal after restore");
// init a second instance (with attributes in different order and one additional attribute)
AttributeSource src2 = new AttributeSource();
typeAtt = (TypeAttribute)src2.AddAttribute(typeof(TypeAttribute));
Lucene.Net.Analysis.Tokenattributes.FlagsAttribute flagsAtt = (Lucene.Net.Analysis.Tokenattributes.FlagsAttribute)src2.AddAttribute(typeof(Lucene.Net.Analysis.Tokenattributes.FlagsAttribute));
termAtt = (TermAttribute)src2.AddAttribute(typeof(TermAttribute));
flagsAtt.SetFlags(12345);
src2.RestoreState(state);
Assert.AreEqual("TestTerm", termAtt.Term());
Assert.AreEqual("TestType", typeAtt.Type());
Assert.AreEqual(12345, flagsAtt.GetFlags(), "FlagsAttribute should not be touched");
// init a third instance missing one Attribute
AttributeSource src3 = new AttributeSource();
termAtt = (TermAttribute)src3.AddAttribute(typeof(TermAttribute));
try
{
src3.RestoreState(state);
Assert.Fail("The third instance is missing the TypeAttribute, so restoreState() should throw IllegalArgumentException");
}
catch (System.ArgumentException iae)
{
// pass
}
}
public ActionResult DeleteConfirmed(int id)
{
TypeAttribute typeAttribute = db.TypeAttributes.Find(id);
db.TypeAttributes.Remove(typeAttribute);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void ParseTypeAttributeTest()
{
//Parse tokens
MarkupParser markupParser = new MarkupParser(Init("type1"));
TypeAttribute parsedTypeAttribute = markupParser.ParseTypeAttribute();
//Check Id Attribute
Assert.AreEqual("type1", parsedTypeAttribute.GetType());
}
/// <summary>
/// 成员信息转换为数据列
/// </summary>
/// <param name="name">成员名称</param>
/// <param name="type">成员类型</param>
/// <param name="memberAttribute">SQL成员信息</param>
/// <returns>数据列</returns>
internal Column GetColumn(string name, Type type, MemberAttribute memberAttribute)
{
Column column = TypeAttribute.GetAttribute <ColumnAttribute>(type, false) == null?GetColumn(type, memberAttribute) : new Column
{
SqlColumnType = type
};
column.Name = name;
return(column);
}
public static string GetStringName(TypeAttribute ta)
{
string result;
if (typeAttribute.TryGetValue(ta, out result))
{
return(result);
}
return(null);
}
public ActionResult Edit(TypeAttribute typeAttribute)
{
if (_typeAttribute.Update(typeAttribute))
{
TempData["UpdateSuccess"] = "Update Success";
return(RedirectToAction("Index"));
}
TempData["UpdateFalse"] = "Update False!";
return(View(typeAttribute));
}
/// <summary>
/// Parser for TypeAttribute
/// </summary>
/// <returns>Parsed TypeAttribute</returns>
public TypeAttribute ParseTypeAttribute()
{
TypeAttribute typeAttribute = new TypeAttribute();
//Get type token
CurrentToken = TokenStream.NextToken();
typeAttribute.SetType(CurrentToken.GetValue().ToString());
return(typeAttribute);
}
public void ApplyChanges()
{
if (HasChanged)
{
var serviceProperties = new Dictionary <SystemServiceProperty, object>();
foreach (KeyValuePair <SystemServiceProperty, object> property in GetServiceProperties())
{
TypeAttribute typeAttribute = property.Key.GetEnumAttribute <TypeAttribute>();
switch (property.Key)
{
case SystemServiceProperty.DesktopInteract:
if (InteractWithDesktop != (bool)Convert.ChangeType(property.Value, typeAttribute.Type))
{
}
break;
case SystemServiceProperty.DisplayName:
if (DisplayName != Convert.ChangeType(property.Value, typeAttribute.Type).ToString())
{
}
break;
case SystemServiceProperty.PathName:
if (ServiceAssemblyPath != Convert.ChangeType(property.Value, typeAttribute.Type).ToString())
{
serviceProperties.Add(SystemServiceProperty.PathName, ServiceAssemblyPath);
}
break;
case SystemServiceProperty.StartMode:
if (ServiceStartMode != (ServiceStartMode)Convert.ChangeType(property.Value, typeAttribute.Type))
{
serviceProperties.Add(SystemServiceProperty.StartMode, ServiceStartMode);
}
break;
case SystemServiceProperty.StartName:
if (UserName != Convert.ChangeType(property.Value, typeAttribute.Type).ToString())
{
serviceProperties.Add(SystemServiceProperty.StartName, ServiceStartMode);
}
break;
default:
break;
}
}
;
}
}
public StringParser()
{
Type t = GetType();
ParseMethods = t.GetMethods().Where(x => TypeAttribute.HasAttribute(x)).ToDictionary(
(m) => TypeAttribute.GetAttribute(m).Type,
(m) => new Func <string, object>((str) =>
Try.Func <object>(
() => m.Invoke(this, new object[] { str }),
(ex) => { throw ex.InnerException; }
)));
}
//FIXME raise an assertion failure if setExplicitType(String) and setExplicitType(Type) are use at the same time
public void SetExplicitType(TypeAttribute typeAnn)
{
if (typeAnn != null)
{
explicitType = typeAnn.Type;
typeParameters.Clear();
foreach (ParameterAttribute param in typeAnn.Parameters)
{
typeParameters.Add(param.Name, param.Value);
}
}
}
public ActionResult Edit([Bind(Include = "Id,TypeId,AttributeId")] TypeAttribute typeAttribute)
{
if (ModelState.IsValid)
{
db.Entry(typeAttribute).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.AttributeId = new SelectList(db.Attributes, "Id", "Name", typeAttribute.AttributeId);
ViewBag.TypeId = new SelectList(db.Types, "Id", "Name", typeAttribute.TypeId);
return(View(typeAttribute));
}
//FIXME raise an assertion failure if setExplicitType(String) and setExplicitType(Type) are use at the same time
public void SetExplicitType(TypeAttribute typeAnn)
{
if (typeAnn != null)
{
explicitType = typeAnn.Type;
typeParameters.Clear();
foreach (ParameterAttribute param in typeAnn.Parameters)
{
typeParameters.Add( param.Name, param.Value);
}
}
}
private async void Type_TypeInfoChanged(object sender, EventArgs e)
{
this.typeInfo = this.type.TypeInfo;
if (this.typeInfo.IsFlag == true)
{
this.typeAttribute |= TypeAttribute.IsFlag;
}
else
{
this.typeAttribute &= ~TypeAttribute.IsFlag;
}
await this.RefreshAsync();
}
static void Main(string[] args)
{
var input = Console.ReadLine();
var typeAttribute = new TypeAttribute(input);
Console.WriteLine(typeAttribute);
//var type = typeof(TypeAttribute);
// var fielType = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
// .Where(f => f.Name == "Type");
// Console.WriteLine(fielType.GetType());
}
public void Load_ShouldNotLoadType_RegularCtor(string xml)
{
mSut = new TypeAttribute(new ReadOnlyCollection <IProperty>(new List <IProperty>()));
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml($"<appender name=\"ColoredConsoleAppender\" {xml}>\r\n" +
"</appender>");
mSut.Load(xmlDoc.FirstChild);
Assert.IsNull(mSut.Value);
}
void init()
{
TypeAttribute att = fieldInfo.GetCustomAttributes(typeof(TypeAttribute), false).FirstOrDefault(e => { return(e is TypeAttribute); }) as TypeAttribute;
if (att != null)
{
_refType = att.type;
}
else
{
_refType = typeof(GameObject);
}
}
public ActionResult Create([Bind(Include = "Id,TypeId,AttributeId")] TypeAttribute typeAttribute)
{
if (ModelState.IsValid)
{
db.TypeAttributes.Add(typeAttribute);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.AttributeId = new SelectList(db.Attributes, "Id", "Name", typeAttribute.AttributeId);
ViewBag.TypeId = new SelectList(db.Types, "Id", "Name", typeAttribute.TypeId);
return(View(typeAttribute));
}
public void TestCdmFolderToDataTypeAttribute()
{
CdmCorpusDefinition corpus = new CdmCorpusDefinition();
corpus.SetEventCallback(new EventCallback {
Invoke = CommonDataModelLoader.ConsoleStatusReport
}, CdmStatusLevel.Warning);
corpus.Storage.Mount("local", new LocalAdapter("C:\\Root\\Path"));
corpus.Storage.DefaultNamespace = "local";
var cdmTypeAttributeDefinition = corpus.MakeObject <CdmTypeAttributeDefinition>(CdmObjectType.TypeAttributeDef, "TestSavingTraitAttribute", false);
List <string> englishConstantsList = new List <string>()
{
"en", "Some description in English language"
};
List <string> serbianConstantsList = new List <string>()
{
"sr", "Opis na srpskom jeziku"
};
List <string> chineseConstantsList = new List <string>()
{
"cn", "一些中文描述"
};
List <List <string> > listOfConstLists = new List <List <string> > {
englishConstantsList, serbianConstantsList, chineseConstantsList
};
var constEntDef = corpus.MakeObject <CdmConstantEntityDefinition>(CdmObjectType.ConstantEntityDef, "localizedDescriptions", false);
constEntDef.ConstantValues = listOfConstLists;
constEntDef.EntityShape = corpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, "localizedTable", true);
var traitReference2 = corpus.MakeObject <CdmTraitReference>(CdmObjectType.TraitRef, "is.localized.describedAs", false);
traitReference2.Arguments.Add("localizedDisplayText", corpus.MakeRef <CdmEntityReference>(CdmObjectType.EntityRef, constEntDef, true));
cdmTypeAttributeDefinition.AppliedTraits.Add(traitReference2);
TypeAttribute result = PersistenceLayer.ToData <CdmTypeAttributeDefinition, TypeAttribute>(cdmTypeAttributeDefinition, null, null, PersistenceLayer.CdmFolder);
Assert.IsNotNull(result.AppliedTraits);
var argument = result.AppliedTraits[0].ToObject <TraitReferenceDefinition>().Arguments[0].ToObject <Argument>();
List <List <string> > constantValues = argument.Value.ToObject <EntityReferenceDefinition>().EntityReference.ToObject <ConstantEntity>().ConstantValues;
Assert.AreEqual("en", constantValues[0][0]);
Assert.AreEqual("Some description in English language", constantValues[0][1]);
Assert.AreEqual("sr", constantValues[1][0]);
Assert.AreEqual("Opis na srpskom jeziku", constantValues[1][1]);
Assert.AreEqual("cn", constantValues[2][0]);
Assert.AreEqual("一些中文描述", constantValues[2][1]);
}
public async Task <EntityEntry <TypeAttribute> > AddOrUpdateAsync(TypeAttribute entity)
{
var exists = await FindAsync <TypeAttribute>(entity.TypeId, entity.AttributeId);
if (exists == null)
{
return(Add(entity));
}
else
{
Entry(exists).CurrentValues.SetValues(entity);
return(Entry(entity));
}
}
public static void InjectAttributeInfo(MethodInfo methodInfo, Method method)
{
CommandAttribute commandAttribute = methodInfo.GetCustomAttribute <CommandAttribute>();
if (commandAttribute != null)
{
method.Command = commandAttribute.CommandName;
method.IsCommand = true;
}
TypeAttribute typeAttribute = methodInfo.GetCustomAttribute <TypeAttribute>();
method.Type = typeAttribute == null ? DispatcherType.Any : typeAttribute.Type;
}
// GET: TypeAttribute/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TypeAttribute typeAttribute = db.TypeAttributes.Find(id);
if (typeAttribute == null)
{
return(HttpNotFound());
}
return(View(typeAttribute));
}
/// <summary>
/// 获取数据库表格操作工具
/// </summary>
/// <returns>数据库表格操作工具</returns>
/// <param name="isCreateCacheWait">是否等待创建缓存</param>
public static ModelTable <modelType> Get(bool isCreateCacheWait = false)
{
Type type = typeof(modelType);
TableAttribute attribute = TypeAttribute.GetAttribute <TableAttribute>(type, false);
if (attribute != null)// && Array.IndexOf(ConfigLoader.Config.CheckConnectionNames, attribute.ConnectionType) != -1
{
ModelTable <modelType> table = new ModelTable <modelType>(attribute, isCreateCacheWait);
if (!table.IsError)
{
return(table);
}
}
return(null);
}
public TypeTreeViewItemViewModel(CremaDataType dataType, ISelector selector)
{
this.Target = dataType;
this.dataType = dataType;
this.dataType.ExtendedProperties[selector] = this;
this.selector = selector;
this.typeInfo = dataType.TypeInfo;
this.typeAttribute = TypeAttribute.None;
this.typeState = TypeState.None;
this.renameCommand = new DelegateCommand(async() => await this.RenameAsync());
this.deleteCommand = new DelegateCommand(async() => await this.DeleteAsync());
this.viewCommand = new DelegateCommand(async() => await this.ViewContentAsync());
this.dataType.PropertyChanged += DataType_PropertyChanged;
this.Items.CollectionChanged += Items_CollectionChanged;
}
static Model()
{
Type type = typeof(valueType);
attribute = TypeAttribute.GetAttribute <ModelAttribute>(type, true) ?? ModelAttribute.Default;
Fields = Field.Get(MemberIndexGroup <valueType> .GetFields(attribute.MemberFilters), false).ToArray();
Identity = Field.GetIdentity(Fields);
PrimaryKeys = Field.GetPrimaryKeys(Fields).ToArray();
MemberMap = new MemberMap <valueType>();
foreach (Field field in Fields)
{
MemberMap.SetMember(field.MemberMapIndex);
}
if (Identity != null)
{
IdentitySqlName = Identity.SqlFieldName;
#if NOJIT
new identity(Identity.Field).Get(out GetIdentity, out SetIdentity);
Action <valueType, int> setter32;
new identity32(Identity.Field).Get(out GetIdentity32, out setter32);
#else
DynamicMethod dynamicMethod = new DynamicMethod("GetSqlIdentity", typeof(long), new Type[] { type }, type, true);
ILGenerator generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldfld, Identity.FieldInfo);
if (Identity.FieldInfo.FieldType != typeof(long) && Identity.FieldInfo.FieldType != typeof(ulong))
{
generator.Emit(OpCodes.Conv_I8);
}
generator.Emit(OpCodes.Ret);
GetIdentity = (Func <valueType, long>)dynamicMethod.CreateDelegate(typeof(Func <valueType, long>));
dynamicMethod = new DynamicMethod("SetSqlIdentity", null, new Type[] { type, typeof(long) }, type, true);
generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldarg_1);
if (Identity.FieldInfo.FieldType != typeof(long) && Identity.FieldInfo.FieldType != typeof(ulong))
{
generator.Emit(OpCodes.Conv_I4);
}
generator.Emit(OpCodes.Stfld, Identity.FieldInfo);
generator.Emit(OpCodes.Ret);
SetIdentity = (Action <valueType, long>)dynamicMethod.CreateDelegate(typeof(Action <valueType, long>));
GetIdentity32 = getIdentityGetter32("GetSqlIdentity32", Identity.FieldInfo);
#endif
}
}
// GET: TypeAttribute/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
TypeAttribute typeAttribute = db.TypeAttributes.Find(id);
if (typeAttribute == null)
{
return(HttpNotFound());
}
ViewBag.AttributeId = new SelectList(db.Attributes, "Id", "Name", typeAttribute.AttributeId);
ViewBag.TypeId = new SelectList(db.Types, "Id", "Name", typeAttribute.TypeId);
return(View(typeAttribute));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private void testPositons(TypeTokenFilter stpf) throws java.io.IOException
private void testPositons(TypeTokenFilter stpf)
{
TypeAttribute typeAtt = stpf.getAttribute(typeof(TypeAttribute));
CharTermAttribute termAttribute = stpf.getAttribute(typeof(CharTermAttribute));
PositionIncrementAttribute posIncrAtt = stpf.getAttribute(typeof(PositionIncrementAttribute));
stpf.reset();
bool enablePositionIncrements = stpf.EnablePositionIncrements;
while (stpf.incrementToken())
{
log("Token: " + termAttribute.ToString() + ": " + typeAtt.type() + " - " + posIncrAtt.PositionIncrement);
assertEquals("if position increment is enabled the positionIncrementAttribute value should be 3, otherwise 1", posIncrAtt.PositionIncrement, enablePositionIncrements ? 3 : 1);
}
stpf.end();
stpf.close();
}
/// <summary>
/// 获取属性值并排序
/// </summary>
/// <param name="cp"></param>
/// <returns></returns>
public static List<FieldAttributeInfo> GetComponentField(TypeAttribute component)
{
List<FieldAttributeInfo> list = new List<FieldAttributeInfo>();
IEnumerable<PropertyName> pNames = component.GetPropertyNames();
FieldAttributeInfo info = null;
foreach (var n in pNames)
{
info = new FieldAttributeInfo();
PropertyInfo p = component.GetPropertyInfo(n.Name);
info.Name = n.Name;
var attrs = p.GetCustomAttributes(typeof(ComponentAttributeBase), false);
bool hide = false;
foreach (var a in attrs)
{
if (a is FieldDocumentAttribute)
{
FieldDocumentAttribute att = a as FieldDocumentAttribute;
if (att.Order == 0)
{
info.Order = 100;
}
else
{
info.Order = att.Order;
}
info.Title = att.Title;
info.Detail = att.Detail;
info.Link = att.Link;
hide = att.Hide;
}
}
if (hide)
{
continue;
}
if (attrs.Length == 0)
{
info.Order = 100;
}
list.Add(info);
}
List<FieldAttributeInfo> listAsc = list.OrderBy(o => o.Order).ToList();
return listAsc;
}
public List <DbAttribute> GetPropertyDbAtttibutes(string propertyName)
{
List <DbAttribute> dbAttributes = new List <DbAttribute>();
var property = ModelType.GetProperty(propertyName);
var attrs = System.Attribute.GetCustomAttributes(property);
var typeAttr = System.Attribute.GetCustomAttribute(property, typeof(TypeAttribute));
if (DbTypeMapping.TypeMapping(property.PropertyType).Equals(DbTypeMapping.UserType))
{
var dbType = DbTypeMapping.UserType;
typeAttr = new TypeAttribute(dbType.TypeName, dbType.DefaultSize);
}
else if (DbTypeMapping.TypeMapping(property.PropertyType).Equals(DbTypeMapping.List_UserType))
{
var dbType = DbTypeMapping.List_UserType;
typeAttr = new TypeAttribute(dbType.TypeName, dbType.DefaultSize);
}
else
{
if (typeAttr == null)
{
var dbType = DbTypeMapping.TypeMapping(property.PropertyType);
typeAttr = new TypeAttribute(dbType.TypeName, dbType.DefaultSize);
}
//加载约束特性
foreach (var attr in attrs)
{
if (attr is ConstraintAttribute)
{
dbAttributes.Add((DbAttribute)attr);
}
}
}
dbAttributes.Add((DbAttribute)typeAttr);
return(dbAttributes);
}
public BaseAttributeConfigBean()
{
helper = new TypeAttribute(this);
}
/// <summary> Write a Type XML Element from attributes in a member. </summary>
public virtual void WriteType(System.Xml.XmlWriter writer, System.Reflection.MemberInfo member, TypeAttribute attribute, BaseAttribute parentAttribute, System.Type mappedClass)
{
writer.WriteStartElement( "type" );
// Attribute: <name>
writer.WriteAttributeString("name", attribute.Name==null ? DefaultHelper.Get_Type_Name_DefaultValue(member) : GetAttributeValue(attribute.Name, mappedClass));
WriteUserDefinedContent(writer, member, null, attribute);
System.Collections.ArrayList memberAttribs = GetSortedAttributes(member);
int attribPos; // Find the position of the TypeAttribute (its <sub-element>s must be after it)
for(attribPos=0; attribPos<memberAttribs.Count; attribPos++)
if( memberAttribs[attribPos] is TypeAttribute
&& ((BaseAttribute)memberAttribs[attribPos]).Position == attribute.Position )
break; // found
int i = attribPos + 1;
// Element: <param>
for(; i<memberAttribs.Count; i++)
{
BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute;
if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType())
|| IsNextElement(memberAttrib, attribute, typeof(ParamAttribute)) )
break; // next attributes are 'elements' of the same level OR for 'sub-elements'
else
{
if( memberAttrib is TypeAttribute )
break; // Following attributes are for this Type
if( memberAttrib is ParamAttribute )
WriteParam(writer, member, memberAttrib as ParamAttribute, attribute, mappedClass);
}
}
WriteUserDefinedContent(writer, member, typeof(ParamAttribute), attribute);
writer.WriteEndElement();
}
public BaseTableComponent()
{
helper = new TypeAttribute(this);
}
public BaseChartComponent()
{
helper = new TypeAttribute(this);
}
public BaseAttributeConfigBean()
{
helper = new TypeAttribute(this);
UpdateLogDic = new Dictionary<string, object>();
}
