/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
if (!Type.Type.IsInterface)
{
LeftArray <MemberExpression> members = default(LeftArray <MemberExpression>);
nodeTypeNames.Clear();
bool isMember = true;
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Instance, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref members, new MemberExpression {
Attribute = attribute, Member = member, IntputParameters = member.IsField ? NullValue <ExpressionParameter> .Array : ExpressionParameter.Get(MethodParameter.Get(((PropertyInfo)member.Member).GetGetMethod(true), NullValue <Type> .Array))
});
}
}
Members = members.ToArray();
LeftArray <MethodExpression> methods = default(LeftArray <MethodExpression>);
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Instance, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref methods, new MethodExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
Methods = methods.ToArray();
LeftArray <StaticMemberExpression> staticMembers = default(LeftArray <StaticMemberExpression>);
foreach (MemberIndex member in MemberIndex.GetStaticMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref staticMembers, new StaticMemberExpression {
Attribute = attribute, Member = member, IntputParameters = NullValue <ExpressionParameter> .Array
});
}
}
StaticMembers = staticMembers.ToArray();
LeftArray <StaticMethodExpression> staticMethods = default(LeftArray <StaticMethodExpression>);
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref staticMethods, new StaticMethodExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
StaticMethods = staticMethods.ToArray();
if (isMember && (Members.Length | Methods.Length | StaticMemberCount) != 0)
{
create(true);
}
}
}
public ActionResult Edit(int?id)
{
//if(User.IsInRole(admin))
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Member member = db.Members.Find(id);
MemberIndex vm = new MemberIndex()
{
MemberID = member.MemberID,
MemberAccount = member.MemberAccount,
MemberName = member.Name,
Phone = member.Phone,
Address = member.Address,
Email = member.Email
};
if (member == null)
{
return(HttpNotFound());
}
return(View(vm));
}
public Builder Clear(MemberIndex index)
{
if (memberMap != null)
{
memberMap.ClearMember(index.Index);
}
return(this);
}
public Builder Set(MemberIndex index)
{
if (memberMap != null)
{
memberMap.SetMember(index.Index);
}
return(this);
}
private string MatchesForPrefixToString(MemberIndex index, StringStore strings, String8 prefix)
{
Range matches;
if (!strings.TryGetRangeStartingWith(prefix, out matches))
{
return(String.Empty);
}
return(MatchesToString(index, matches));
}
private string MatchesForWordToString(MemberIndex index, StringStore strings, String8 word)
{
Range matches;
if (!strings.TryFindString(word, out matches))
{
return(String.Empty);
}
return(MatchesToString(index, matches));
}
public AddReferenceDatabase(ArdbVersion ardbVersion)
{
this.DatabaseFormatVersion = ardbVersion;
this.StringStore = new StringStore();
this.DeclaredMembers = new ItemTree();
this.DeclaredMemberTypes = new List <SymbolType>();
this.DeclaredMemberTypes.Add(SymbolType.Package);
this.Index = new MemberIndex();
_mergedMembers = new MergedMembersDatabase(this.StringStore);
}
public void AlphanumericSplitter_EndToEndPerformance()
{
String8 code = AllCodeText.AllCode8;
String8Set set = default(String8Set);
PartialArray <int> matchContainer = new PartialArray <int>(2048);
HashSet <String8> uniqueWords = new HashSet <String8>();
StringStore strings = new StringStore();
MemberIndex index = new MemberIndex();
int iterations = 10;
int totalWordsSplit = 0;
// Split, Add, Index Goal: 30k per millisecond [30 MB/sec]
Verify.PerformanceByBytes(30 * LongExtensions.Megabyte, () =>
{
for (int iteration = 0; iteration < iterations; ++iteration)
{
String8Set codeByLine = code.Split(UTF8.Newline, new PartialArray <int>());
for (int lineIndex = 0; lineIndex < codeByLine.Count; ++lineIndex)
{
// Convert and Split the line
String8 line = codeByLine[lineIndex];
set = AlphanumericSplitter.Split(line, ref matchContainer);
totalWordsSplit += set.Count;
if (set.Count > 0)
{
int matchIndex = AlphanumericSplitter.IsAlphaNumeric(set[0][0]) ? 0 : 1;
for (; matchIndex < set.Count; matchIndex += 2)
{
// If the word is long enough...
String8 word = set[matchIndex];
if (word.Length > 2)
{
if (!uniqueWords.Contains(word))
{
int wordIdentifier = strings.FindOrAddString(word);
uniqueWords.Add(strings[wordIdentifier]);
index.AddItem(wordIdentifier, lineIndex);
}
}
}
}
}
}
return(iterations * code.Length);
});
}
public void MemberIndex_Basic()
{
StringStore strings = new StringStore();
MemberIndex index = new MemberIndex();
// Add six sample strings to StringStore
string[] testValues = new string[] { "Zero", "One", "Two", "Three", "Four", "Five" };
int[] testValueIDs = new int[testValues.Length];
for (int i = 0; i < testValues.Length; ++i)
{
testValueIDs[i] = strings.FindOrAddString(testValues[i]);
}
// Add 100 items to index - each item has the values it is evenly divisible by (10 has "Five" and "Two")
for (int indexId = 1; indexId < 20; ++indexId)
{
for (int wordIndex = 1; wordIndex < testValueIDs.Length; ++wordIndex)
{
if (indexId % wordIndex == 0)
{
index.AddItem(testValueIDs[wordIndex], indexId);
}
}
}
// Convert for search
strings.ConvertToImmutable();
index.ConvertToImmutable(strings);
// Verify matches for three are correct
Assert.AreEqual("3, 6, 9, 12, 15, 18", MatchesForWordToString(index, strings, strings[testValueIDs[3]]));
Assert.AreEqual("3, 6, 9, 12, 15, 18", MatchesForPrefixToString(index, strings, String8.Convert("Three", new byte[String8.GetLength("Three")])));
// Verify matches for five are correct
Assert.AreEqual("5, 10, 15", MatchesForWordToString(index, strings, strings[testValueIDs[5]]));
Assert.AreEqual("5, 10, 15", MatchesForPrefixToString(index, strings, String8.Convert("Five", new byte[String8.GetLength("Five")])));
// Verify no matches for zero
Assert.AreEqual("", MatchesForWordToString(index, strings, strings[testValueIDs[0]]));
Assert.AreEqual("", MatchesForPrefixToString(index, strings, String8.Convert("Zero", new byte[String8.GetLength("Zero")])));
// Verify "Four" and "Five" matches for "F"
Assert.AreEqual("5, 10, 15, 4, 8, 12, 16", MatchesForPrefixToString(index, strings, String8.Convert("F", new byte[String8.GetLength("F")])));
}
/// <summary>
/// 设置远程缓存成员集合
/// </summary>
protected void setRemoteMemberCache()
{
LeftArray <RemoteMember> remoteMembers = new LeftArray <RemoteMember>();
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Sql.RemoteMemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.NonPublicInstanceProperty, true, false))
{
if (member.CanGet)
{
AutoCSer.Sql.RemoteMemberAttribute remoteAttribute = member.GetSetupAttribute <AutoCSer.Sql.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
if (member.IsField || ((PropertyInfo)member.Member).GetIndexParameters().Length == 0)
{
remoteMembers.Add(new RemoteMember {
Member = member, Attribute = remoteAttribute
});
}
}
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Sql.RemoteMemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.NonPublicInstance, false, true, false))
{
if (!member.Method.IsGenericMethodDefinition)
{
AutoCSer.Sql.RemoteMemberAttribute remoteAttribute = member.GetSetupAttribute <AutoCSer.Sql.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
remoteMembers.Add(new RemoteMember {
Method = member, Attribute = remoteAttribute
});
}
}
}
RemoteMembers = remoteMembers.ToArray();
RemoteCacheBuilder cacheBuilder = new RemoteCacheBuilder();
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Sql.RemoteMemberCacheAttribute>(Type, AutoCSer.Metadata.MemberFilters.NonPublicInstance, true, false))
{
cacheBuilder.Push(member);
}
RemoteCaches = cacheBuilder.Caches.ToArray();
}
public PackageDatabase(PackageIdentity identity)
{
this.Identity = identity;
this.StringStore = new StringStore();
this.FileTree = new ItemTree();
// Build the symbol tree with a sentinel root
this.DeclaredMembers = new ItemTree();
// Populate sentinel details and location
this.DeclaredMemberDetails = new List <SymbolDetails>();
this.DeclaredMemberDetails.Add(new SymbolDetails()
{
Type = SymbolType.Any
});
this.DeclaredMemberLocations = new List <SymbolLocation>();
this.DeclaredMemberLocations.Add(new SymbolLocation());
this.Index = new MemberIndex();
}
/// <summary>
/// 获取远程调用链类型信息
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
internal static RemoteLinkType GetRemoteLinkType(Type type)
{
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.TcpStaticServer.RemoteKeyAttribute>(type, MemberFilters.PublicInstance, true, false))
{
foreach (MethodIndex method in MethodIndex.GetMethods <AutoCSer.Net.TcpStaticServer.RemoteKeyAttribute>(type, MemberFilters.Static, false, true, false))
{
if (!method.Method.IsGenericMethodDefinition && type.IsAssignableFrom(method.Method.ReturnType))
{
ParameterInfo[] parameters = method.Method.GetParameters();
if (parameters.Length == 1 && parameters[0].ParameterType == member.MemberSystemType)
{
return(new RemoteLinkType {
Type = type, RemoteKeyMember = member, RemoteKeyMethod = method, ParameterType = member.MemberSystemType
});
}
}
}
break;
}
return(null);
}
public ActionResult Edit(MemberIndex vm)
{
if (ModelState.IsValid)
{
Member member = db.Members.Find(vm.MemberID);
member.MemberID = vm.MemberID;
member.MemberAccount = vm.MemberAccount;
member.Name = vm.MemberName;
member.Phone = vm.Phone;
member.Address = vm.Address;
member.Email = vm.Email;
//db.Entry(member).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
;
return(View(vm));
}
/// <summary>
/// 获取成员集合
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static cache getCache(Type type)
{
cache members;
if (!memberCache.TryGetValue(type, out members))
{
LeftArray <RemoteLink> remoteMembers = new LeftArray <RemoteLink>(0);
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, true, false))
{
if (member.CanGet)
{
AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute remoteAttribute = member.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
remoteMembers.Add(new RemoteLink {
Member = member, PropertyParameters = member.IsField ? EmptyArray <MethodParameter> .Array : MethodParameter.Get(((PropertyInfo)member.Member).GetGetMethod(true), EmptyArray <Type> .Array), Attribute = remoteAttribute
});
}
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, false, true, false))
{
if (!member.Method.IsGenericMethodDefinition)
{
AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute remoteAttribute = member.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
remoteMembers.Add(new RemoteLink {
Method = member, Attribute = remoteAttribute
});
}
}
}
memberCache.Add(type, members = new cache {
Members = remoteMembers.ToArray(), Caches = MemberIndex.GetMembers <AutoCSer.Net.TcpStaticServer.RemoteLinkAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, true, false)
});
}
return(members);
}
public void MemberIndex_CaseSensitivity()
{
StringStore strings = new StringStore();
MemberIndex index = new MemberIndex();
byte[] buffer = new byte[20];
// Add strings to store (some differ only by casing), ten values
string[] testValues = new string[] { "null", "bool", "Bool", "array", "ARRAY", "Collections", "Dictionary", "int", "Int", "friend" };
int[] testValueIDs = new int[testValues.Length];
for (int i = 0; i < testValues.Length; ++i)
{
testValueIDs[i] = strings.FindOrAddString(testValues[i]);
}
// Add 3 items per string to index [0, 10, 20 => "null", 1, 11, 21 => "bool", 2, 12, 22 => "Bool", ...]
int indexId = 0;
for (int countToIndex = 0; countToIndex < 3; ++countToIndex)
{
for (int wordIndex = 0; wordIndex < testValueIDs.Length; ++wordIndex)
{
index.AddItem(testValueIDs[wordIndex], indexId++);
}
}
// Convert index for search. Pages should be merged into case-insensitive groups in insertion (ID) order
strings.ConvertToImmutable();
index.ConvertToImmutable(strings);
// Verify "BOOL" gets matches for "bool" and "Bool" in insertion order
Assert.AreEqual("1, 2, 11, 12, 21, 22", MatchesForWordToString(index, strings, String8.Convert("BOOL", buffer)));
// Verify "array" gets matches for "array" and "ARRAY" in insertion order
Assert.AreEqual("3, 4, 13, 14, 23, 24", MatchesForWordToString(index, strings, String8.Convert("array", buffer)));
// Verify "Dictionary" matches unmerged
Assert.AreEqual("6, 16, 26", MatchesForWordToString(index, strings, String8.Convert("Dictionary", buffer)));
}
/// <summary>
///
/// </summary>
/// <param name="members"></param>
/// <returns></returns>
public MemberIndex[] CheckMembers(ref LeftArray <MemberIndex> members)
{
int count = 0;
foreach (MemberIndex member in members)
{
foreach (MemberIndex field in Members)
{
if (field.MemberSystemType == member.MemberSystemType && field.MemberName == member.MemberName)
{
++count;
break;
}
}
}
if (count == Members.Length)
{
return(Members);
}
if (count == 0)
{
return(null);
}
MemberIndex[] fields = new MemberIndex[count];
foreach (MemberIndex member in members)
{
foreach (MemberIndex field in Members)
{
if (field.MemberSystemType == member.MemberSystemType && field.MemberName == member.MemberName)
{
int memberIndex = fields.Length - count;
fields[--count] = new MemberIndex((FieldInfo)field.Member, memberIndex);
break;
}
}
}
return(fields);
}
private string MatchesToString(MemberIndex index, Range stringRange)
{
// Find matches for string range
int[] matchBlock;
int matchIndex, matchCount;
bool success = index.TryGetMatchesInRange(stringRange, out matchBlock, out matchIndex, out matchCount);
// Ensure success means there were matches
Assert.AreEqual(success, matchCount > 0);
// Convert results to comma delimited string
StringBuilder results = new StringBuilder();
for (int i = matchIndex; i < matchIndex + matchCount; ++i)
{
if (results.Length > 0)
{
results.Append(", ");
}
results.Append(matchBlock[i].ToString());
}
return(results.ToString());
}
/// <summary>
/// 添加远程缓存成员
/// </summary>
/// <param name="member"></param>
internal void Push(MemberIndex member)
{
members.Add(new RemoteLinkMember {
Member = member, Attribute = member.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteLinkAttribute>(false), Index = members.Length
});
cache cache = getCache(member.MemberSystemType);
if (cache.Members.Length != 0)
{
RemoteLinkMember[] memberArray = members.ToArray();
foreach (RemoteLink nextMember in cache.Members)
{
Caches.Add(new RemoteLink {
Members = memberArray, Method = nextMember.Method, Member = nextMember.Member, PropertyParameters = nextMember.PropertyParameters, Attribute = nextMember.Attribute
});
}
}
foreach (MemberIndex nextMember in cache.Caches)
{
bool isMember = true;
foreach (RemoteLinkMember cacheMember in members)
{
if (cacheMember.Member.MemberSystemType == nextMember.MemberSystemType)
{
Messages.Message("远程调用链类型循环引用 " + members.JoinString(" . ", value => value.Member.MemberType.FullName + " " + value.Member.MemberName) + " . " + nextMember.MemberType.FullName + " " + nextMember.MemberName);
isMember = false;
break;
}
}
if (isMember)
{
Push(nextMember);
}
}
--members.Length;
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
Type modelType;
AutoCSer.Sql.ModelAttribute modelAttribute = Type.Type.customAttribute <AutoCSer.Sql.ModelAttribute>(out modelType);
if (modelAttribute != null)
{
AutoCSer.Net.TcpStaticServer.ServerAttribute serverAttribute = AutoCSer.Metadata.TypeAttribute.GetAttribute <AutoCSer.Net.TcpStaticServer.ServerAttribute>(Type, false);
if (serverAttribute != null && serverAttribute.ServerName != null && !serverAttribute.IsRemoteLinkType && serverAttribute.IsRemoteLink && (RemoteLinkType = TcpStaticServer.Generator.GetRemoteLinkType(Type)) != null)
{
LeftArray <TcpStaticServer.Generator.RemoteMethod> remoteMethods = new LeftArray <TcpStaticServer.Generator.RemoteMethod>(0);
foreach (MethodIndex method in MethodIndex.GetMethods <AutoCSer.Net.TcpStaticServer.MethodAttribute>(Type, serverAttribute.GetMemberFilters, false, serverAttribute.IsAttribute, serverAttribute.IsBaseTypeAttribute))
{
if (!method.Method.IsGenericMethodDefinition)
{
AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute remoteAttribute = method.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(false);
if (remoteAttribute != null && !remoteAttribute.IsClientRemoteMember)
{
MethodParameter[] parameters = method.Parameters;
if (parameters.Length >= 1 && parameters[0].ParameterType == RemoteLinkType.ParameterType)
{
remoteMethods.Add(new TcpStaticServer.Generator.RemoteMethod {
Type = Type, Method = method, MethodParameters = parameters, Attribute = remoteAttribute
});
}
}
}
}
LeftArray <SqlModel.Generator.LogMember> logMembers = new LeftArray <SqlModel.Generator.LogMember>(0);
foreach (MemberIndex member in MemberIndex.GetMembers(modelType, modelAttribute.MemberFilters))
{
if (!member.IsIgnore)
{
AutoCSer.Sql.MemberAttribute attribute = member.GetAttribute <AutoCSer.Sql.MemberAttribute>(false);
if (modelAttribute.LogServerName != null)
{
AutoCSer.Sql.LogAttribute logAttribute = member.GetAttribute <AutoCSer.Sql.LogAttribute>(false);
if (logAttribute != null)
{
SqlModel.Generator.LogMember logMember = new SqlModel.Generator.LogMember {
Member = member, Attribute = logAttribute, MemberAttribute = attribute
};
if (modelAttribute.LogServerName != null && logMember.IsProxy)
{
logMembers.Add(logMember);
foreach (TcpStaticServer.Generator.RemoteMethod remoteMethod in remoteMethods)
{
if (remoteMethod.Attribute.MemberName == member.MemberName)
{
remoteMethod.Member = member;
break;
}
}
}
}
}
}
}
RemoteMethods = remoteMethods.GetFindArray(value => value.Member != null);
LogMembers = logMembers.Length != 0 && (modelAttribute.CacheType != AutoCSer.Sql.Cache.Whole.Event.Type.Unknown && modelAttribute.CacheType != AutoCSer.Sql.Cache.Whole.Event.Type.CreateMemberKey) ? logMembers.ToArray() : EmptyArray <SqlModel.Generator.LogMember> .Array;
if ((LogMembers.Length | RemoteMethods.Length) != 0)
{
//create(true);
IsRemoteMember = RemoteMethods.Length != 0 && TcpStaticServer.Generator.RemoteMemberTypes.Add(Type);
CSharpTypeDefinition definition = new CSharpTypeDefinition(Type, true, false);
_code_.Length = 0;
create(false);
Coder.Add(definition.Start + _partCodes_["SERVER"] + definition.End);
TcpStaticServer.Generator.AddClientCode(new TcpStaticServer.Generator.ClientCode {
Type = Type, Attribute = serverAttribute, Code = definition.Start + _partCodes_["CLIENT"] + definition.End, SegmentationCode = definition.Start + _partCodes_["CLIENTCALL"] + definition.End
});
}
}
}
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
MemberIndex identity = Identity = null;
int isIdentityCase = SqlStreamTypeCount = NowTimeArraySize = 0;
LeftArray <MemberIndex> members = default(LeftArray <MemberIndex>), primaryKeys = default(LeftArray <MemberIndex>), indexMembers = default(LeftArray <MemberIndex>);
LeftArray <CountMember> counterMembers = default(LeftArray <CountMember>);
LeftArray <MemberIndex> nowTimeMembers = default(LeftArray <MemberIndex>);
LeftArray <LogMember> logMembers = new LeftArray <LogMember>();
LeftArray <string> strings = default(LeftArray <string>);
IsLogProxyMember = false;
foreach (MemberIndex member in MemberIndex.GetMembers(Type, Attribute.MemberFilters))
{
if (!member.IsIgnore)
{
AutoCSer.Sql.MemberAttribute attribute = member.GetAttribute <AutoCSer.Sql.MemberAttribute>(false);
bool isMember = attribute == null || attribute.IsSetup;
if (Attribute.LogServerName != null)
{
AutoCSer.Sql.LogAttribute logAttribute = member.GetAttribute <AutoCSer.Sql.LogAttribute>(false);
if (logAttribute != null)
{
LogMember logMember = new LogMember {
Member = member, Attribute = logAttribute, MemberAttribute = attribute
};
logMembers.Add(logMember);
if (logMember.IsProxy)
{
IsLogProxyMember = true;
}
if (!logAttribute.IsMember)
{
isMember = false;
}
}
}
if (isMember)
{
members.Add(member);
if (attribute != null)
{
if (attribute.IsMemberIndex)
{
indexMembers.Add(member);
}
if (attribute.IsNowTime && member.MemberSystemType == typeof(DateTime))
{
nowTimeMembers.Add(member);
if (member.MemberIndex >= NowTimeArraySize)
{
NowTimeArraySize = member.MemberIndex + 1;
}
}
if (attribute.PrimaryKeyIndex != 0)
{
primaryKeys.Add(member);
}
if (attribute.IsIdentity)
{
Identity = member;
}
}
if (Identity == null)
{
if (isIdentityCase == 0 && member.MemberName == AutoCSer.Sql.Field.IdentityName)
{
identity = member;
isIdentityCase = 1;
}
else if (identity == null && member.MemberName.Length == AutoCSer.Sql.Field.IdentityName.Length && member.MemberName.ToLower() == AutoCSer.Sql.Field.IdentityName)
{
identity = member;
}
}
AutoCSer.Sql.CountAttribute countAttribute = member.GetAttribute <AutoCSer.Sql.CountAttribute>(false);
if (countAttribute != null)
{
counterMembers.Add(new CountMember {
Member = member, Attribute = countAttribute
});
}
if (member.MemberSystemType == typeof(string) && (attribute == null || (attribute.MaxStringLength == 0 && !attribute.IsIgnoreMaxStringLength)))
{
strings.Add(member.MemberName);
}
}
}
}
if (Identity == null)
{
Identity = identity;
}
if (Attribute.LogServerName == null)
{
LogMembers = NullValue <LogMember> .Array;
}
else
{
LogMembers = logMembers.ToArray();
if (!Attribute.IsDefaultSerialize && Attribute.IsLogMemberMap)
{
AutoCSer.BinarySerialize.SerializeAttribute dataSerialize = Type.Type.customAttribute <AutoCSer.BinarySerialize.SerializeAttribute>();
if (dataSerialize != null && !dataSerialize.IsMemberMap)
{
Messages.Message("数据库日志流处理类型 " + Type.FullName + " 序列化不支持成员位图");
}
}
foreach (LogMember member in LogMembers)
{
if (member.Attribute.CountType != null)
{
++SqlStreamTypeCount;
}
}
}
CounterMembers = counterMembers.ToArray();
NowTimeMembers = nowTimeMembers.ToArray();
if (strings.Length != 0)
{
Messages.Message(Type.FullName + " 字符串字段缺少最大长度限制 " + string.Join(",", strings.ToArray()));
}
WebPaths.Length = 0;
ListArray <WebPathType> types;
if (webPathTypes == null)
{
webPathTypes = new Dictionary <Type, ListArray <WebPathType> >();
foreach (Type nextType in AutoParameter.Types)
{
AutoCSer.WebView.PathAttribute webPath = nextType.customAttribute <AutoCSer.WebView.PathAttribute>();
if (webPath != null && webPath.Type != null && webPath.MemberName != null)
{
FieldInfo[] fields = nextType.GetFields(BindingFlags.Instance | BindingFlags.Public);
if (fields.Length != 0)
{
if (!webPathTypes.TryGetValue(webPath.Type, out types))
{
webPathTypes.Add(webPath.Type, types = new ListArray <WebPathType>());
}
int memberIndex = fields.Length;
types.Add(new WebPathType {
MemberType = nextType, Attribute = webPath, Members = fields.getArray(value => new MemberIndex(value, --memberIndex))
});
}
}
}
}
if (webPathTypes.TryGetValue(Type, out types))
{
foreach (WebPathType webPath in types)
{
MemberIndex[] fields = webPath.CheckMembers(ref members);
if (fields != null)
{
WebPaths.Add(new WebPathType {
MemberType = webPath.MemberType, Attribute = webPath.Attribute, Members = fields
});
}
}
}
dataPrimaryKey.Run(Type, PrimaryKeys = primaryKeys.ToArray());
if (Attribute.IsUpdateMemberMap)
{
if (Identity == null)
{
UpdateMembers = members.GetFindArray(value => Array.IndexOf(PrimaryKeys, value) < 0);
}
else
{
UpdateMembers = members.GetFindArray(value => value != Identity);
}
if (indexMembers.Length != 0)
{
indexMembers.Remove(value => Array.IndexOf(UpdateMembers, value) >= 0);
}
if (indexMembers.Length == 0)
{
indexMembers.Set(UpdateMembers);
}
else
{
indexMembers.Add(UpdateMembers);
}
}
else
{
UpdateMembers = NullValue <MemberIndex> .Array;
}
IndexMembers = indexMembers.ToArray();
create(true);
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
if ((Attribute.IsAbstract || Type.Type.IsSealed || !Type.Type.IsAbstract) && !Type.Type.IsInterface)
{
defaultServerName = Attribute.ServerName;
defaultServer = null;
defaultType = null;
if (defaultServerName != null)
{
HashString nameKey = defaultServerName;
if (!servers.TryGetValue(nameKey, out defaultServer))
{
servers.Add(nameKey, defaultServer = new Server());
}
defaultServer.Attribute.Name = defaultServerName;
defaultServer.Types.Add(defaultType = new ServerType {
Type = Type, Attribute = Attribute
});
if (Attribute.IsServer)
{
defaultServer.AttributeType = Type;
defaultServer.Attribute.CopyFrom(Attribute);
}
}
RemoteLinkType remoteLinkType = null;
if (Attribute.ServerName != null)
{
if (Attribute.IsRemoteLinkType)
{
remoteLinkType = new RemoteLinkType {
Type = Type, ParameterType = Type
}
}
;
else if (Attribute.IsRemoteLink)
{
remoteLinkType = GetRemoteLinkType(Type);
}
}
LeftArray <RemoteMethod> remoteMethods = new LeftArray <RemoteMethod>(0);
foreach (MethodIndex method in MethodIndex.GetMethods <AutoCSer.Net.TcpStaticServer.MethodAttribute>(Type, Attribute.GetMemberFilters, false, Attribute.IsAttribute, Attribute.IsBaseTypeAttribute))
{
next(new TcpMethod {
Method = method, MethodType = Type
});
if (remoteLinkType != null && !method.Method.IsGenericMethodDefinition)
{
AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute remoteAttribute = method.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(false);
if (remoteAttribute != null && remoteAttribute.IsClientRemoteMember)
{
MethodParameter[] parameters = method.Parameters;
if (parameters.Length >= 1 && parameters[0].ParameterType.Type == remoteLinkType.ParameterType)
{
remoteMethods.Add(new RemoteMethod {
Type = Type, Method = method, MethodParameters = parameters, Attribute = remoteAttribute
});
}
}
}
}
if (remoteLinkType != null)
{
remoteLinkType.RemoteMethods = remoteMethods.ToArray();
LeftArray <RemoteMember> remoteMembers = new LeftArray <RemoteMember>(0);
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.NonPublicInstanceProperty, true, false))
{
if (member.CanGet)
{
AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute remoteAttribute = member.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
if (member.IsField || ((PropertyInfo)member.Member).GetIndexParameters().Length == 0)
{
remoteMembers.Add(new RemoteMember {
Member = member, Attribute = remoteAttribute
});
}
}
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.NonPublicInstance, false, true, false))
{
if (!member.Method.IsGenericMethodDefinition)
{
AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute remoteAttribute = member.GetSetupAttribute <AutoCSer.Net.TcpStaticServer.RemoteMemberAttribute>(false);
if (remoteAttribute != null)
{
remoteMembers.Add(new RemoteMember {
Method = member, Attribute = remoteAttribute
});
}
}
}
remoteLinkType.RemoteMembers = remoteMembers.ToArray();
RemoteLinkBuilder cacheBuilder = new RemoteLinkBuilder();
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.TcpStaticServer.RemoteLinkAttribute>(Type, AutoCSer.Metadata.MemberFilters.NonPublicInstance, true, false))
{
cacheBuilder.Push(member);
}
remoteLinkType.RemoteLinks = cacheBuilder.Caches.ToArray();
if (remoteLinkType.IsRemoteLink)
{
defaultServer.RemoteLinkTypes.Add(remoteLinkType);
}
}
if (!Type.Type.IsGenericType)
{
foreach (MemberIndexInfo member in StaticMemberIndexGroup.Get <AutoCSer.Net.TcpStaticServer.MethodAttribute>(Type, Attribute.GetMemberFilters, false, Attribute.IsAttribute, Attribute.IsBaseTypeAttribute))
{
if (member.IsField)
{
FieldInfo field = (FieldInfo)member.Member;
TcpMethod getMethod = new TcpMethod
{
Method = new Metadata.MethodIndex(field, true),
MemberIndex = member,
MethodType = Type
};
if (!getMethod.Attribute.IsOnlyGetMember)
{
getMethod.SetMethod = new TcpMethod {
Method = new Metadata.MethodIndex(field, false), MemberIndex = member, MethodType = Type
};
}
next(getMethod);
if (getMethod.SetMethod != null)
{
next(getMethod.SetMethod);
}
}
else if (member.CanGet)
{
PropertyInfo property = (PropertyInfo)member.Member;
TcpMethod getMethod = new TcpMethod
{
Method = new Metadata.MethodIndex(property, true),
MemberIndex = member,
MethodType = Type
};
if (member.CanSet && !getMethod.Attribute.IsOnlyGetMember)
{
getMethod.SetMethod = new TcpMethod {
Method = new Metadata.MethodIndex(property, false), MemberIndex = member, MethodType = Type
};
}
next(getMethod);
if (getMethod.SetMethod != null)
{
next(getMethod.SetMethod);
}
}
}
}
serverTypes.Empty();
}
}
/// <summary>
/// 表达式成员集合
/// </summary>
/// <param name="type"></param>
/// <param name="memberNodeTypeName"></param>
internal ExpressionMemberGroup(ExtensionType type, string memberNodeTypeName)
{
this.type = type;
this.memberNodeTypeName = memberNodeTypeName;
LeftArray <Expression> members = new LeftArray <Expression>(0);
nodeTypeNames.Clear();
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref members, new Expression {
Attribute = attribute, Member = member, IntputParameters = member.IsField ? EmptyArray <ExpressionParameter> .Array : ExpressionParameter.Get(MethodParameter.Get(((PropertyInfo)member.Member).GetGetMethod(true), EmptyArray <Type> .Array))
});
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref members, new Expression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
Members = members.ToArray();
if (memberNodeTypeName == null)
{
LeftArray <StaticExpression> staticMembers = new LeftArray <StaticExpression>(0);
foreach (MemberIndex member in MemberIndex.GetStaticMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Static, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref staticMembers, new StaticExpression {
Attribute = attribute, Member = member, IntputParameters = EmptyArray <ExpressionParameter> .Array
});
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Static, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref staticMembers, new StaticExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
StaticMembers = staticMembers.ToArray();
}
else
{
StaticMembers = EmptyArray <StaticExpression> .Array;
}
if ((IsMember &= (Members.Length | StaticMembers.Length) != 0) && memberNodeTypeName == null)
{
foreach (Expression member in Members)
{
member.CheckGenericMemberGroup();
}
foreach (StaticExpression member in StaticMembers)
{
member.CheckGenericMemberGroup();
}
}
}
/// <summary>
/// Search the given IMemberDatabase for matches to this query and put
/// results into the results array provided. The capacity of the results
/// array determines how many results are returned.
/// </summary>
/// <param name="db">Database to search</param>
/// <param name="results">PartialArray to contain results, sized for the count desired.</param>
/// <returns>True if results were added, False otherwise</returns>
public bool TryFindMembers(IMemberDatabase db, ref PartialArray <Symbol> results)
{
// Ensure strings must be found again so that benchmarks are realistic
ForceReresolve();
// Clear results from a previous query
results.Clear();
// If there was no query, return with no results
if (String.IsNullOrEmpty(SymbolName))
{
return(false);
}
// Get required members from database
StringStore strings = db.StringStore;
ItemTree declaredMembers = db.DeclaredMembers;
MemberIndex index = db.Index;
// Map strings to the local StringStore. Stop immediately if any values aren't found.
if (!ResolveStringsTo(strings))
{
return(false);
}
// Cache whether this query needs details to match
bool usesDetails = !this.Parameters8.IsEmpty() || this.Type != SymbolType.Any || this.Modifiers != SymbolModifier.None;
int[] matches;
int matchesIndex, matchesCount;
if (SplitSymbolName8.Count == 1)
{
// Find the set of symbols with names in range. If no symbols in index, return nothing
if (!index.TryGetMatchesInRange(SymbolNameSuffixIdentifiers, out matches, out matchesIndex, out matchesCount))
{
return(false);
}
// If there was just one name part searched for, all matches count
for (int i = matchesIndex; i < matchesIndex + matchesCount; ++i)
{
if ((usesDetails ? MatchesDetailed(declaredMembers, strings, db, matches[i]) : Matches(declaredMembers, strings, matches[i])))
{
results.Add(new Symbol(db, matches[i]));
if (results.IsFull)
{
return(true);
}
}
}
}
else
{
// Find all entries with exactly the second-to-last name
if (!index.TryGetMatchesInRange(SymbolNamePrefixIdentifiers[SymbolNamePrefixIdentifiers.Length - 1], out matches, out matchesIndex, out matchesCount))
{
return(false);
}
for (int i = matchesIndex; i < matchesIndex + matchesCount; ++i)
{
int currentMatchIndex = matches[i];
// First, do all previous name parts in the query match?
int currentAncestorIndex = currentMatchIndex;
int namePartIndex = SymbolNamePrefixIdentifiers.Length - 2;
for (; namePartIndex >= 0; --namePartIndex)
{
currentAncestorIndex = declaredMembers.GetParent(currentAncestorIndex);
int currentAncestorNameIdentifier = declaredMembers.GetNameIdentifier(currentAncestorIndex);
if (!SymbolNamePrefixIdentifiers[namePartIndex].Contains(currentAncestorNameIdentifier))
{
break;
}
}
if (namePartIndex != -1)
{
continue;
}
// If this was a full match, are we out of namespaces?
if (IsFullNamespace)
{
currentAncestorIndex = declaredMembers.GetParent(currentAncestorIndex);
SymbolType symbolAboveFullNameType = db.GetMemberType(currentAncestorIndex);
if (!symbolAboveFullNameType.IsAboveNamespace())
{
return(false);
}
}
// Next, find children of this item which match the last part typed
int leafId = declaredMembers.GetFirstChild(currentMatchIndex);
while (leafId > 0)
{
if ((usesDetails ? MatchesDetailed(declaredMembers, strings, db, leafId) : Matches(declaredMembers, strings, leafId)))
{
results.Add(new Symbol(db, leafId));
if (results.IsFull)
{
return(true);
}
}
leafId = declaredMembers.GetNextSibling(leafId);
}
}
}
return(results.Count > 0);
}
