public static IEnumerable <MemberInfo> GetMembersFromType(System.Type tp, bool includeNonPublic)
{
const BindingFlags BINDING = BindingFlags.Public | BindingFlags.Instance;
const BindingFlags PRIV_BINDING = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly;
const MemberTypes MASK = MemberTypes.Field | MemberTypes.Property | MemberTypes.Method;
if (tp == null)
{
yield break;
}
foreach (var m in tp.GetMembers(BINDING))
{
if ((m.MemberType & MASK) != 0)
{
yield return(m);
}
}
if (includeNonPublic)
{
while (tp != null)
{
foreach (var m in tp.GetMembers(PRIV_BINDING))
{
if ((m.MemberType & MASK) != 0)
{
yield return(m);
}
}
tp = tp.BaseType;
}
}
}
public static string Generate(Type type)
{
const string format = "{0}::{1}-{2}#{3}";
if (type == null)
throw new ArgumentNullException("type");
var hashCode = type.GetHashCode();
var attributes =
type.GetMembers().SelectMany(x => x.GetCustomAttributes(true)).Concat(type.GetCustomAttributes(true));
var nonPublicMembers = type.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance);
var statics = type.GetMembers(BindingFlags.Static | BindingFlags.Public);
var items = type.GetMembers().Concat(attributes).Concat(nonPublicMembers).Concat(statics).ToArray();
var typeCode = items.First().GetHashCode();
typeCode = items.Skip(1).Aggregate(typeCode, (current, item) => current ^ item.GetHashCode());
var asmDate = File.GetLastWriteTime(type.Assembly.Location);
return String.Format(format, hashCode.ToString("X"), typeCode, items.Count(),
asmDate.Ticks.ToString("X"));
}
public TypeDefinition(Type type)
: this()
{
Namespace = type.Namespace;
Name = type.Name;
AddMembers(type.GetMembers(BindingFlags.Public | BindingFlags.Instance));
AddMembers(type.GetMembers(BindingFlags.Public | BindingFlags.Static));
AddMembers(type.GetMembers(BindingFlags.Public | BindingFlags.CreateInstance));
}
static public void DoUpdateGetComponentAttribute(MonoBehaviour pMonobehaviourOwner, object pClass_Anything)
{
// BindingFloags를 일일이 써야 잘 동작한다..
System.Type pType = pClass_Anything.GetType();
MemberInfo[] arrMembers = pType.GetMembers(BindingFlags.Public | BindingFlags.Instance);
UpdateComponentAttribute(pMonobehaviourOwner, pClass_Anything, arrMembers);
arrMembers = pType.GetMembers(BindingFlags.NonPublic | BindingFlags.Instance);
UpdateComponentAttribute(pMonobehaviourOwner, pClass_Anything, arrMembers);
}
internal TypeReflector(Type type)
: base(null){
this.defaultMembers = null;
ArrayList memberLookupTable = new ArrayList(512);
int count = 0;
SimpleHashtable staticMembers = new SimpleHashtable(256);
foreach (MemberInfo member in type.GetMembers(BindingFlags.Public|BindingFlags.Static|BindingFlags.FlattenHierarchy)){
String name = member.Name;
Object ob = staticMembers[name];
if (ob == null){
staticMembers[name] = count++; //Avoid allocating an array until needed
memberLookupTable.Add(member);
}else{
int index = (int)ob;
ob = memberLookupTable[index];
MemberInfo firstMember = ob as MemberInfo;
if (firstMember != null){
MemberInfoList mems = new MemberInfoList(); //Allocate a flexarray of MemberInfo, and turn it into a fixed array when GetMember is called for this name
mems.Add(firstMember);
mems.Add(member);
memberLookupTable[index] = mems;
}else
((MemberInfoList)ob).Add(member);
}
}
this.staticMembers = staticMembers;
SimpleHashtable instanceMembers = new SimpleHashtable(256);
foreach (MemberInfo member in type.GetMembers(BindingFlags.Public|BindingFlags.Instance)){
String name = member.Name;
Object ob = instanceMembers[name];
if (ob == null){
instanceMembers[name] = count++; //Avoid allocating an array until needed
memberLookupTable.Add(member);
}else{
int index = (int)ob;
ob = memberLookupTable[index];
MemberInfo firstMember = ob as MemberInfo;
if (firstMember != null){
MemberInfoList mems = new MemberInfoList();
mems.Add(firstMember);
mems.Add(member);
memberLookupTable[index] = mems;
}else
((MemberInfoList)ob).Add(member);
}
}
this.instanceMembers = instanceMembers;
this.memberLookupTable = memberLookupTable;
this.memberInfos = new MemberInfo[count][];
this.type = type;
this.implementsIReflect = null;
this.hashCode = (uint)type.GetHashCode();
this.next = null;
}
public void LogMembers()
{
Test test = new Test();
System.Type type = test.GetType();
MemberInfo[] info = type.GetMembers();
for (int i = 0; i < info.Length; ++i)
{
// MemberInfo: displays the type and name of the member with a space between them (I.E. "System.single speed")
// MemberInfo.Name: displays the name of the member
// MemberInfo.MemberType: displays the type of member (I.E., field or method)
// MemberInfo.ReflectedType: displays the type that the member belongs to (I.E., the class name)
// MemberInfo.DeclaringType: the type that originally declared the member (either the class from ReflectedType or Object for more global members)
// MemberInfo.Module: the source of the type, usually a DLL
// MemberInfo.MetadataToken: an unique ID for metadata
if (info[i].DeclaringType.Name != "Object" &&
info[i].MemberType == MemberTypes.Field)
{
Debug.Log(info[i].Name + "\nMemberType: " + info[i]);
string typeAsString = GetTypeAsString(info[i]);
members.Add(new MemberInfoTest(info[i].Name, typeAsString, Type.GetType(typeAsString)));
}
}
Debug.Log("");
}
/// <summary>
/// Retrieve the descriptions on the enum type.
/// Then when you pass in the enum type (e.g. Enums.UserTitles), it will retrieve the descriptions for all the
/// individual enums
/// </summary>
/// <param name="enumType">The Enumeration Type</param>
/// <returns>A string list representing all the friendly names</returns>
public static List<string> GetDescriptions(Type enumType)
{
MemberInfo[] memInfo = enumType.GetMembers(BindingFlags.Public | BindingFlags.Static)
.Where(m => m.MemberType == MemberTypes.Field)
.ToArray();
var result = new List<string>();
if (memInfo != null && memInfo.Length > 0)
{
foreach (MemberInfo member in memInfo)
{
object[] attrs = member.GetCustomAttributes(typeof (DescriptionAttribute), false);
if (attrs != null && attrs.Length > 0)
{
result.Add(((DescriptionAttribute) attrs[0]).Description);
}
else
{
result.Add(member.Name);
}
}
}
return result;
}
private static IEnumerable<String> DiscoverValidValuePaths(Type type, int depth)
{
var validMembers = type.GetMembers(BindingFlagsForSearch)
.Where(member => (member.MemberType & MemberTypesToSearch) > 0);
foreach (var member in validMembers)
{
yield return member.Name;
var childType = ExtractMemberType(member);
Type recurseOnType = childType;
// For system collections declare only Count
if (typeof(System.Collections.ICollection).IsAssignableFrom(childType)
&& childType.Namespace.StartsWith("System.Collections"))
{
yield return member.Name + ".Count";
recurseOnType = childType.IsGenericType
? childType.GetGenericArguments().First()
: typeof(Object);
}
else if (childType.IsArray)
{
yield return member.Name + ".Length";
recurseOnType = childType.GetElementType();
}
if (recurseOnType.IsClass && depth > 1 && recurseOnType != typeof(String))
{ //recurse:
var childItems = DiscoverValidValuePaths(recurseOnType, depth - 1);
foreach (var item in childItems)
{
yield return member.Name + "." + item;
}
}
}
}
public EnumConfiguration(Type enumType)
{
_signed = IsSignedEnum(enumType);
_flags = IsFlagsEnum(enumType);
_names = enumType.GetEnumNames();
var members = enumType.GetMembers(BindingFlags.Static | BindingFlags.Public);
Debug.Assert(members.Length == _names.Length);
for (int i = 0; i < members.Length; i++)
{
var a = members[i].GetCustomAttributes<PersistedNameAttribute>().FirstOrDefault();
if (a != null) _names[i] = a.Name;
}
var undertype = enumType.GetEnumUnderlyingType();
var enumValues = enumType.GetEnumValues();
IEnumerable<ulong> enumValuesUlongs;
if (undertype == typeof(int)) enumValuesUlongs = enumValues.Cast<int>().Select(i => (ulong)i);
else if (undertype == typeof(uint)) enumValuesUlongs = enumValues.Cast<uint>().Select(i => (ulong)i);
else if (undertype == typeof(sbyte)) enumValuesUlongs = enumValues.Cast<sbyte>().Select(i => (ulong)i);
else if (undertype == typeof(byte)) enumValuesUlongs = enumValues.Cast<byte>().Select(i => (ulong)i);
else if (undertype == typeof(short)) enumValuesUlongs = enumValues.Cast<short>().Select(i => (ulong)i);
else if (undertype == typeof(ushort)) enumValuesUlongs = enumValues.Cast<ushort>().Select(i => (ulong)i);
else if (undertype == typeof(long)) enumValuesUlongs = enumValues.Cast<long>().Select(i => (ulong)i);
else enumValuesUlongs = enumValues.Cast<ulong>();
_values = enumValuesUlongs.ToArray();
}
public ExistingNamespaceParams (Type t)
{
// Populate our tables.
MemberInfo[] mems = t.GetMembers ();
for (int i = 0; i < mems.Length; i++) {
MemberInfo mi = mems[i];
object[] attrs = mi.GetCustomAttributes (typeof (StructureParameterAttribute),
false);
if (attrs == null || attrs.Length == 0)
continue;
sparams[mi.Name] = ((StructureParameterAttribute) attrs[0]).Kind;
if (sparams[mi.Name] == StructureParameterKind.Structure) {
Type stype = null;
if (mi is PropertyInfo)
stype = (mi as PropertyInfo).PropertyType;
else if (mi is FieldInfo)
stype = (mi as FieldInfo).FieldType;
structtypes[mi.Name] = new UserType (stype);
}
}
}
static SerializableType CompileType(Type type)
{
// at this point, type is a composite type
object[] typeAttributes = type.GetCustomAttributes(typeof(AmqpContractAttribute), true);
if (typeAttributes.Length != 1)
{
throw new NotSupportedException(type.FullName);
}
AmqpContractAttribute contractAttribute = (AmqpContractAttribute)typeAttributes[0];
string descriptorName = contractAttribute.Name;
ulong? descriptorCode = contractAttribute.InternalCode;
if (descriptorName == null && descriptorCode == null)
{
descriptorName = type.FullName;
}
int lastOrder = 0;
SortedList<int, SerialiableMember> memberList = new SortedList<int, SerialiableMember>();
MemberInfo[] memberInfos = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.DeclaringType != type ||
(memberInfo.MemberType != MemberTypes.Field &&
memberInfo.MemberType != MemberTypes.Property))
{
continue;
}
object[] memberAttributes = memberInfo.GetCustomAttributes(typeof(AmqpMemberAttribute), true);
if (memberAttributes.Length != 1)
{
continue;
}
AmqpMemberAttribute attribute = (AmqpMemberAttribute)memberAttributes[0];
SerialiableMember member = new SerialiableMember();
member.Name = attribute.Name ?? memberInfo.Name;
member.Order = attribute.InternalOrder ?? lastOrder;
member.Mandatory = attribute.Mandatory;
member.Accessor = MemberAccessor.Create(memberInfo);
// This will recursively resolve member types
Type memberType = memberInfo.MemberType == MemberTypes.Field ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType;
member.Type = GetType(memberType);
memberList.Add(member.Order, member);
lastOrder = member.Order >= lastOrder ? member.Order + 1 : lastOrder + 1;
}
SerialiableMember[] members = new SerialiableMember[memberList.Count];
for (int i = 0; i < memberList.Count; ++i)
{
members[i] = memberList[i];
}
SerializableType serializableType = SerializableType.Create(type, descriptorName, descriptorCode, members);
return serializableType;
}
private static IEnumerable<string> MemberNames(Type type, bool getFacets)
{
if (type == null)
{
yield break;
}
var members = type.GetMembers();
foreach (var member in members)
{
if (member.MemberType == MemberTypes.Field || member.MemberType == MemberTypes.Property)
{
var propertyType = type.GetProperty(member.Name).PropertyType;
if (typeof(IFacet).IsAssignableFrom(propertyType))
{
if (getFacets)
{
yield return member.Name;
}
}
else
{
if (!getFacets)
{
yield return member.Name;
}
}
}
}
}
/// <summary>Получить список (значение; наименование)</summary>
/// <param name="enumType">Тип перечисления</param>
/// <returns>Список (значение; наименование)</returns>
public static Dictionary<int, string> GetList(Type enumType)
{
int index = 0;
Dictionary<int,string> list = new Dictionary<int, string>();
while (true)
{
string numberStr = index.ToString();
object valueDescription = Enum.Parse(enumType, index.ToString(), true);
string valueStr = valueDescription.ToString();
if (numberStr == valueStr)
{
break;
}
MemberInfo inf = enumType.GetMembers()[10 + index];
dbFieldAtt attribute = Attribute.GetCustomAttribute(inf, typeof(dbFieldAtt)) as dbFieldAtt;
if (attribute != null)
{
list.Add(index++, attribute.Description);
}
}
return list;
}
/// <summary>
/// Given T, the method will return a Dictionary[string,MemberInfo] where
/// string is the field/property name and MemberInfo is the reflected
/// member info of the field/property that will be used for invocation
/// and setting values. The returned Dictionary must encompass the full
/// set of viable properties/fields that can be faked on T.
/// </summary>
/// <returns>The full set of MemberInfos for injection.</returns>
public Dictionary<string, MemberInfo> GetMembers(Type t)
{
return t.GetMembers(BindingFlags)
.Where(m =>
{
if (m.GetCustomAttributes(typeof(CompilerGeneratedAttribute), true).Any())
{
//no compiler generated stuff
return false;
}
var pi = m as PropertyInfo;
if (pi != null)
{
return pi.CanWrite;
}
var fi = m as FieldInfo;
if( fi != null )
{
//No private fields.
//Github Issue #13
return !fi.IsPrivate;
}
return false;
})
.ToDictionary(pi => pi.Name);
}
private void SystemNameSake(System.Type sType, IList <ISignature> signatures, String elementName, String elementPrototype, bool comma)
{
XSharpProjectPackage.Instance.DisplayOutPutMessage("XSharpSignatureHelpSource.SystemNameSake()");
MemberInfo[] members;
// Get Public, Internal, Protected & Private Members, we also get Instance vars, Static members...all that WITHOUT inheritance
members = sType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
| BindingFlags.Static | BindingFlags.DeclaredOnly);
//
bool ctor = false;
foreach (var member in members.Where(x => nameEquals(x.Name, elementName)))
{
if (member.MemberType == MemberTypes.Constructor)
{
ctor = true;
}
XSharpLanguage.MemberAnalysis analysis = new XSharpLanguage.MemberAnalysis(member);
if (analysis.IsInitialized)
{
// But don't add the current one
if (String.Compare(elementPrototype, analysis.Prototype, true) != 0)
{
signatures.Add(CreateSignature(m_textBuffer, analysis.Prototype, "", ApplicableToSpan, comma));
}
}
}
// fill members of parent class,but not for constructorsS
if (sType.BaseType != null && !ctor)
{
SystemNameSake(sType.BaseType, signatures, elementName, elementPrototype, comma);
}
}
public TypeDescription(System.Type type)
{
var ignoredMembers = new string[]
{
"ToString",
"Equals",
"GetHashCode",
"GetType",
"Finalize",
"MemberwiseClone",
".ctor"
};
foreach (var member in
type.GetMembers(
Reflection.BindingFlags.Instance |
Reflection.BindingFlags.Public |
Reflection.BindingFlags.NonPublic
).Where(
member => !ignoredMembers.Any(
ignoredMember => ignoredMember == member.Name
)
)
)
{
var memberType = member.MemberType == Reflection.MemberTypes.Method ?
Type.Function :
Type.Variable;
this.Add(
member.Name,
(int)memberType
);
MemberDescriptions.Add(member.Name, this.GetMemberDescription(member, memberType));
}
}
private static void CreateModuleFromClass(ScriptEngine engine, Type t, string ModuleName)
{
var Module = engine.CreateModule(ModuleName);
foreach (MemberInfo m in t.GetMembers(BindingFlags.Public | BindingFlags.Static)){
if (m.MemberType == MemberTypes.Method){
MethodInfo method = (MethodInfo)m;
Module.SetVariable(m.Name, (AllFunctions)delegate(object[] input){ return method.Invoke(null, input);});
continue;
}
if (m.MemberType == MemberTypes.Property){
MethodInfo method = ((PropertyInfo)m).GetGetMethod();
Module.SetVariable(m.Name, method.Invoke(null, null));
continue;
}
if (m.MemberType == MemberTypes.Field) {
FieldInfo field = (FieldInfo)m;
Module.SetVariable(field.Name, field.GetValue(null));
}
Console.WriteLine("Not supported: " + m.Name + " for module: " + ModuleName);
}
}
public static ClassWrapper CreateFromType (TypeRegistry registry, Type type, string name)
{
ClassWrapper wrapper = new ClassWrapper (registry, type, name);
foreach (MemberInfo info in type.GetMembers (BindingFlags.Public | BindingFlags.Static)) {
switch (info.MemberType) {
case MemberTypes.Method:
if (!wrapper.HasAttribute (info.Name)) {
wrapper.SetAttribute (info.Name, CreateMultiMethod (registry, type, info.Name));
}
break;
case MemberTypes.Field:
wrapper.SetAttribute (info.Name, FieldWrapper.Create (registry, (FieldInfo)info));
break;
case MemberTypes.Property:
wrapper.SetAttribute (info.Name, PropertyWrapper.Create (registry, (PropertyInfo)info));
break;
}
}
registry.AddTypeMapping (type, wrapper, new ObjectTypeMapping (wrapper, registry));
return wrapper;
}
public static string Generate(Type type)
{
MemberInfo[] memberInfos = type.GetMembers();
const string methodString = @"public override string ToString()
{{
return {0};
}}";
const string outer = "GetType().Name + string.Format(\"{{{{{0}}}}}\", {1}{2})";
List<MemberInfo> properties = memberInfos.Where(mi => mi.MemberType == MemberTypes.Property).ToList();
int count = 0;
var inners = new List<string>();
foreach (var property in properties)
{
string inner = string.Format("{0}={{{1}}}", property.Name, count);
inners.Add(inner);
count++;
}
string firstHalf = string.Join(", ", inners);
string secondHalf = string.Join(", ", properties.Select(p => p.Name));
string body = string.Format(outer, firstHalf, "\n\t\t\t\t", secondHalf);
return string.Format(methodString, body);
}
internal static void CollectMembers(Dictionary<string, string> members, Type t) {
foreach (MemberInfo mi in t.GetMembers()) {
if (mi.MemberType != MemberTypes.Constructor) {
members[mi.Name] = mi.Name;
}
}
}
static void AnalyzeType(Type t)
{
TypeInfo typeInfo = t.GetTypeInfo();
AddToOutput($"Type Name: {t.Name}");
AddToOutput($"Full Name: {t.FullName}");
AddToOutput($"Namespace: {t.Namespace}");
Type tBase = typeInfo.BaseType;
if (tBase != null)
{
AddToOutput($"Base Type: {tBase.Name}");
}
AddToOutput("\npublic members:");
foreach (MemberInfo member in t.GetMembers())
{
#if NET46
AddToOutput($"{member.DeclaringType} {member.MemberType} {member.Name}");
#else
AddToOutput($"{member.DeclaringType} {member.Name}");
#endif
}
}
/// <summary>
/// Adds all members to the node's children, grabbing the parameters
/// for methods.
/// </summary>
/// <param name="treeNode"></param>
/// <param name="type"></param>
public static void AddMembers(this TreeNode treeNode, Type type)
{
// Get all members except methods
MemberInfo[] memberInfo = type.GetMembers();
for (int j = 0; j < memberInfo.Length; j++)
{
if (memberInfo[j].ReflectedType.IsPublic && memberInfo[j].MemberType != MemberTypes.Method)
{
TreeNode node = treeNode.Nodes.Add(memberInfo[j].Name);
node.Tag = memberInfo[j].MemberType;
}
}
// Get all methods
MethodInfo[] methodInfo = type.GetMethods();
for (int j = 0; j < methodInfo.Length; j++)
{
TreeNode node = treeNode.Nodes.Add(methodInfo[j].Name);
string parms = "";
ParameterInfo[] parameterInfo = methodInfo[j].GetParameters();
for (int f = 0; f < parameterInfo.Length; f++)
{
parms += parameterInfo[f].ParameterType + " " + parameterInfo[f].Name + ", ";
}
// Knock off remaining ", "
if (parms.Length > 2)
{
parms = parms.Substring(0, parms.Length - 2);
}
node.Tag = parms;
}
}
private static void Initialize(ILocalTextRegistry registry, Type type, string languageID, string prefix)
{
var provider = registry ?? Dependency.Resolve<ILocalTextRegistry>();
foreach (var member in type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly))
{
var fi = member as FieldInfo;
if (fi != null &&
fi.FieldType == typeof(LocalText))
{
var value = fi.GetValue(null) as LocalText;
if (value != null)
{
var initialized = value as InitializedLocalText;
if (initialized != null)
{
provider.Add(languageID, initialized.Key, initialized.InitialText);
}
else
{
provider.Add(languageID, prefix + fi.Name, value.Key);
fi.SetValue(null, new InitializedLocalText(prefix + fi.Name, value.Key));
}
}
}
}
foreach (var nested in type.GetNestedTypes(BindingFlags.Public | BindingFlags.DeclaredOnly))
{
var name = nested.Name;
if (name.EndsWith("_"))
name = name.Substring(0, name.Length - 1);
Initialize(registry, nested, languageID, prefix + name + ".");
}
}
private IList GetMembers (Type type)
{
ArrayList members = new ArrayList ();
members.AddRange (type.GetMembers (BindingFlags));
members.Sort (NameComparer);
return members;
}
void ProcessType(DemoTreeNode parent, System.Type t)
{
foreach (MemberInfo mi in t.GetMembers())
{
parent.AddChild(new DemoTreeNode(mi.Name, mi.ToString()));
}
}
public static ProxyConfiguration Create(Type type)
{
return configurations.GetOrAdd(type, (t) =>
{
object[] args = t.GetCustomAttributes(typeof(ProxyAttribute), true);
ProxyConfiguration config = null;
if (args.Length > 0)
{
config = new ProxyConfiguration(args[0] as ProxyAttribute);
}
else
{
config = new ProxyConfiguration();
}
foreach (var item in type.GetMembers())
{
object[] memberStatus = item.GetCustomAttributes(typeof(ProxyAttribute), true);
if (memberStatus.Length > 0)
{
config.MemberAutoProxyStatus[item.Name] = (memberStatus[0] as ProxyAttribute).DisableAutoProxy;
}
}
if (string.IsNullOrWhiteSpace(config.DllCachedPath))
{
config.DllCachedPath = AppDomain.CurrentDomain.BaseDirectory;
if (!config.DllCachedPath.EndsWith("\\"))
{
config.DllCachedPath += "\\";
}
}
return config;
});
}
public TypeSerializer(Type targetType)
{
var fields = new List<BlobFieldAttribute>();
this.targetType = targetType;
foreach (MemberInfo member in targetType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
BlobFieldAttribute[] attribs = (BlobFieldAttribute[])member.GetCustomAttributes(typeof(BlobFieldAttribute), false);
if (attribs.Length == 0) continue;
BlobFieldAttribute attrib = attribs[0];
switch (member.MemberType)
{
case MemberTypes.Field:
attrib.Serializer = new FieldSerializer((FieldInfo)member);
break;
case MemberTypes.Property:
attrib.Serializer = new PropertySerializer((PropertyInfo)member);
break;
default:
throw new NotImplementedException();
}
fields.Add(attrib);
}
this.fields = fields.ToArray();
}
private static void ProcessType(TreeIter parent, System.Type t)
{
foreach (MemberInfo mi in t.GetMembers())
{
store.AppendValues(parent, mi.Name, mi.ToString());
}
}
private MessagePartDescriptionCollection GetWrappedParts(MessagePartDescription bodyPart)
{
System.Type type = bodyPart.Type;
MessagePartDescriptionCollection descriptions = new MessagePartDescriptionCollection();
foreach (MemberInfo info in type.GetMembers(BindingFlags.Public | BindingFlags.Instance))
{
if (((info.MemberType & (MemberTypes.Property | MemberTypes.Field)) != 0) && !info.IsDefined(typeof(SoapIgnoreAttribute), false))
{
MessagePartDescription description;
System.ServiceModel.Description.XmlName name = new System.ServiceModel.Description.XmlName(info.Name);
description = new MessagePartDescription(name.EncodedName, string.Empty)
{
AdditionalAttributesProvider = description.MemberInfo = info,
Index = description.SerializationPosition = descriptions.Count,
Type = (info.MemberType == MemberTypes.Property) ? ((PropertyInfo)info).PropertyType : ((FieldInfo)info).FieldType
};
if (bodyPart.HasProtectionLevel)
{
description.ProtectionLevel = bodyPart.ProtectionLevel;
}
descriptions.Add(description);
}
}
return(descriptions);
}
public string Generate(Type resource)
{
Schema schema = new Schema();
ResourceBaseAttribute resourceAttr = resource.GetCustomAttribute<ResourceBaseAttribute>();
if (resourceAttr == null)
return null;
// Setting the schema master attributes
schema.Name = resource.Name;
schema.ApsVersion = resourceAttr.ApsVersion;
schema.Implements = resourceAttr.Implements;
schema.Id = resourceAttr.Id;
List<PropertyInfo> properties = new List<PropertyInfo>();
List<PropertyInfo> links = new List<PropertyInfo>();
List<PropertyInfo> structures = new List<PropertyInfo>();
schema.Properties = new Dictionary<string, Property>();
foreach (PropertyInfo property in resource.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetCustomAttribute<SDK.Attributes.RelationAttribute>() != null)
schema.Relations.Add(property.Name, Relation.CreateRelationObject(property));
}
schema.Operations = new Dictionary<string, Operation>();
foreach(MemberInfo method in resource.GetMembers(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance))
{
if (method.GetCustomAttribute<OperationAttribute>() != null)
schema.Operations.Add(method.Name, Operation.CreateOperationObject(method));
}
return JsonConvert.SerializeObject(schema, Formatting.Indented);
}
public static void GenerateMethod(string methodName, Type type, Lua4NetSerializer serializer, Action<List<Type>> OnGetBody)
{
serializer.NewLine(methodName + "(");
List<Type> args = new List<Type>();
if (type.IsGenericType)
args = type.GetGenericArguments().ToList();
else
{
(type.GetMembers()[0] as MethodBase).GetParameters().ToList().ForEach(pi =>
{
args.Add(pi.ParameterType);
}); ;
}
int nNextArgIndex = 0;
while (nNextArgIndex < args.Count)
{
Type arg = args[nNextArgIndex];
serializer.Apppend(GeneratorHelper.GetTypeName(arg) + " arg" + nNextArgIndex.ToString());
++nNextArgIndex;
if (nNextArgIndex <= (args.Count - 1))
serializer.Apppend(",");
}
serializer.Apppend(")");
serializer.BeginBlock("{");
OnGetBody(args);
serializer.EndBlock("}");
}
//反射获取成员
public static void getMember(Type t)
{
foreach (var member in t.GetMembers())
{
Console.WriteLine(member.Name);
}
}
public static void DisplayFixes(System.Type t)
{
object[] fixes = t.GetCustomAttributes(typeof(BugFixAttribute), false);
Console.WriteLine("Displaying fixes for {0}", t);
foreach (BugFixAttribute bugFix in fixes)
{
Console.WriteLine(" {0}", bugFix);
}
foreach (MemberInfo member in t.GetMembers(BindingFlags.Instance |
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Static))
{
object[] memberFixes = member.GetCustomAttributes(typeof(BugFixAttribute), false);
if (memberFixes.Length > 0)
{
Console.WriteLine(" {0}", member.Name);
foreach (BugFixAttribute memberFix in memberFixes)
{
Console.WriteLine(" {0}", memberFix);
}
}
}
}
private void WriteEnum(StreamWriter s, System.Type t)
{
s.WriteLine("public enum " + t.Name + " {");
bool first = true;
foreach (MemberInfo mb in t.GetMembers())
{
if (mb.ToString().Contains(t.Name))
{
if (mb.ToString().Contains("("))
{
continue; // Skip functions
}
string[] possibleType = mb.ToString().Split('.');
if (possibleType.Length > 1)
{
if (!first)
{
s.Write(",\n");
}
first = false;
s.Write("\t" + possibleType[1].Split(' ')[1]);
}
}
}
s.WriteLine();
s.WriteLine("}");
}
public static T Cast <T>(this Object myobj)
{
System.Type objectType = myobj.GetType();
System.Type target = typeof(T);
var x = Activator.CreateInstance(target, false);
var z = from source in objectType.GetMembers().ToList()
where source.MemberType == MemberTypes.Property
select source;
var d = from source in target.GetMembers().ToList()
where source.MemberType == MemberTypes.Property
select source;
List <MemberInfo> members = d.Where(memberInfo => d.Select(c => c.Name)
.ToList().Contains(memberInfo.Name)).ToList();
PropertyInfo propertyInfo;
object value;
foreach (var memberInfo in members)
{
try
{
propertyInfo = typeof(T).GetProperty(memberInfo.Name);
value = myobj.GetType().GetProperty(memberInfo.Name).GetValue(myobj, null);
propertyInfo.SetValue(x, value, null);
}
catch (Exception)
{
}
}
return((T)x);
}
public string GetDisPlayName(object entity)
{
StringBuilder str = new StringBuilder();
if (entity != null)
{
System.Type t = entity.GetType();
System.Reflection.MemberInfo[] memberInfot = t.GetMembers();
foreach (MemberInfo var in memberInfot)
{
if (var.MemberType == MemberTypes.Property)
{
System.Reflection.PropertyInfo propertyInfo = entity.GetType().GetProperty(var.Name);
try
{
string val = propertyInfo.GetValue(entity, null).ToString();
str.Append(var.Name + ":" + val + ",");
}
catch
{
}
}
}
}
return(str.ToString());
}
public AttributedMetaType(Type classType)
{
type = classType;
// associations and members
var associationsList = new List<MetaAssociation>();
var dataMembersList = new List<MetaDataMember>();
var identityMembersList = new List<MetaDataMember>();
foreach (var memberInfo in classType.GetMembers())
{
var association = memberInfo.GetAttribute<AssociationAttribute>();
if (association != null)
{
var dataMember = new AttributedAssociationMetaDataMember(memberInfo, association, this);
var metaAssociation = new AttributedMetaAssociation(memberInfo, association, dataMember);
associationsList.Add(metaAssociation);
dataMember.SetAssociation(metaAssociation);
}
var column = memberInfo.GetAttribute<ColumnAttribute>();
if (column != null)
{
var dataMember = new AttributedColumnMetaDataMember(memberInfo, column, this);
dataMembersList.Add(dataMember);
if (dataMember.IsPrimaryKey)
identityMembersList.Add(dataMember);
}
}
associations = new ReadOnlyCollection<MetaAssociation>(associationsList);
persistentDataMembers = new ReadOnlyCollection<MetaDataMember>(dataMembersList);
identityMembers = new ReadOnlyCollection<MetaDataMember>(identityMembersList);
}
internal static IEnumerable<MemberInfo> GetVisibleMembers(Type type)
{
var unfiltered = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic
| BindingFlags.Instance | BindingFlags.Static);
var result = unfiltered.Filter(IsVisible);
return result;
}
private static IDictionary<string, DdeTableColumn> GetColumnsDictionary(Type type)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
return type.GetMembers<PropertyInfo>().ToDictionary(p => p.Name, p => p.GetValue<VoidType, DdeTableColumn>(null));
}
/// <summary>
/// Adds all members to the node's children, grabbing the parameters
/// for methods.
/// </summary>
/// <param name="treeNode"></param>
/// <param name="type"></param>
private void addMembers(TreeNode treeNode, System.Type type)
{
// Get all members except methods
MemberInfo[] memberInfo = type.GetMembers();
for (int j = 0; j < memberInfo.Length; j++)
{
if (memberInfo[j].ReflectedType.IsPublic && memberInfo[j].MemberType != MemberTypes.Method)
{
TreeNode node = treeNode.Nodes.Add(memberInfo[j].Name);
node.Tag = memberInfo[j].MemberType;
}
}
// Get all methods
MethodInfo[] methodInfo = type.GetMethods();
for (int j = 0; j < methodInfo.Length; j++)
{
TreeNode node = treeNode.Nodes.Add(methodInfo[j].Name);
string parms = "";
ParameterInfo[] parameterInfo = methodInfo[j].GetParameters();
for (int f = 0; f < parameterInfo.Length; f++)
{
parms += parameterInfo[f].ParameterType.ToString() + " " + parameterInfo[f].Name + ", ";
}
// Knock off remaining ", "
if (parms.Length > 2)
{
parms = parms.Substring(0, parms.Length - 2);
}
node.Tag = parms;
}
}
public static MemberInfo[] GetPublicFieldsAndProperties(Type type)
{
return type
.GetMembers(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.MemberType == MemberTypes.Property || mi.MemberType == MemberTypes.Field)
.ToArray();
}
internal SqlCallInfo(AssemblyInventory inventory, ISerializationTypeInfoProvider serializationTypeInfoProvider, Type interfaceType, ISerializationTypeMappingProvider typeMappingProvider)
{
if (inventory == null) {
throw new ArgumentNullException("inventory");
}
if (serializationTypeInfoProvider == null) {
throw new ArgumentNullException("serializationTypeInfoProvider");
}
Debug.Assert(interfaceType != null);
if ((!interfaceType.IsInterface) || (interfaceType.IsGenericTypeDefinition) || (!typeof(IStoredProcedures).IsAssignableFrom(interfaceType))) {
throw new ArgumentException("The interface must inherit from IStoredProcedures", "interfaceType");
}
this.interfaceType = interfaceType;
foreach (Type innerInterface in interfaceType.GetInterfaces()) {
if (innerInterface != typeof(IStoredProcedures)) {
throw new ArgumentException("The interface cannot inherit from other interfaces then IStoredProcedures", "interfaceType");
}
}
foreach (MemberInfo memberInfo in interfaceType.GetMembers(BindingFlags.Instance|BindingFlags.Public|BindingFlags.DeclaredOnly)) {
MethodInfo methodInfo = memberInfo as MethodInfo;
if (methodInfo == null) {
throw new ArgumentException("Only methods are supported on the IStoredProcedures interfaces", "interfaceType");
}
methods.Add(methodInfo, new SqlCallProcedureInfo(inventory, serializationTypeInfoProvider, methodInfo, typeMappingProvider));
}
}
public Resolution Check(Type type)
{
if (type.IsInterface && type.GetMembers().Length == 0) {
// FIXME: I18N
return new Resolution (this, String.Format ("Use a custom attribute to replace the empty interface <code>{0}</code>. Or specify behaviour for this interface.", type.FullName), type.FullName);
}
return null;
}
private static MemberInfo[] GetFieldProperty <T>() where T : class, new()
{
System.Type t = typeof(T);
MemberInfo[] mems = t.GetMembers(BindingFlags.Instance |
BindingFlags.NonPublic |
BindingFlags.Public
);
return(mems);
}
void InitGameNames()
{
GameEnum genum = new GameEnum();
System.Type type = typeof(GameEnum);
System.Reflection.MemberInfo[] minfos = type.GetMembers();
_names = new string[minfos.Length];
for (int i = 0; i < minfos.Length; i++)
{
_names[i] = minfos[i].Name;
}
}
private MemberInfo GetMember(System.Type type, string identifier)
{
MemberInfo[] members = type.GetMembers();
for (int i = 0; i < members.Length; i += 1)
{
if (members[i].Name == identifier)
{
return(members[i]);
}
}
return(null);
}
static StackObject *GetMembers_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Type instance_of_this_method = (System.Type) typeof(System.Type).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetMembers();
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public virtual DecodedObject <object> decodeEnum(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
Type enumClass = null;
foreach (MemberInfo member in objectClass.GetMembers())
{
if (member is System.Type)
{
Type cls = (Type)member;
if (cls.IsEnum)
{
enumClass = cls;
break;
}
}
}
;
System.Reflection.PropertyInfo field = objectClass.GetProperty("Value");
DecodedObject <object> itemValue = decodeEnumItem(decodedTag, field.PropertyType, enumClass, elementInfo, stream);
System.Reflection.FieldInfo param = null;
if (itemValue != null)
{
object result = createInstanceForElement(objectClass, elementInfo);
foreach (FieldInfo enumItem in enumClass.GetFields())
{
if (CoderUtils.isAttributePresent <ASN1EnumItem>(enumItem))
{
ASN1EnumItem meta =
CoderUtils.getAttribute <ASN1EnumItem>(enumItem);
if (meta.Tag.Equals(itemValue.Value))
{
param = enumItem;
break;
}
}
}
invokeSetterMethodForField(field, result, param.GetValue(null), null);
return(new DecodedObject <object>(result, itemValue.Size));
}
else
{
return(null);
}
}
private Dictionary <string, MemberInfo> GetMemberInfoDict(System.Type type)
{
MemberInfo[] mis = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy);
Dictionary <string, MemberInfo> dict = new Dictionary <string, MemberInfo>();
foreach (MemberInfo mi in mis)
{
if (mi.MemberType == MemberTypes.Property || mi.MemberType == MemberTypes.Field)
{
dict[mi.Name] = mi;
}
}
return(dict);
}
void LoadMembers(System.Type refType, Type type, bool loadAttributes)
{
type.Members = new List <Member>();
BindingFlags bindingFlags =
BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
foreach (System.Reflection.MemberInfo refMember in refType.GetMembers(bindingFlags))
{
Member member = LoadMember(refMember, loadAttributes);
if (member != null)
{
type.Members.Add(member);
}
}
}
private Object getStaticMember(string key)
{
var members = ClassType.GetMembers(BindingFlags.Static | BindingFlags.Public);
var target = (from member in members
where ((member.MemberType == MemberTypes.Field ||
member.MemberType == MemberTypes.Property ||
member.MemberType == MemberTypes.Method ||
member.MemberType == MemberTypes.NestedType) &&
member.Name == key)
select member);
Object result = null;
if (target.Any())
{
MemberInfo memberInfo = target.First();
MemberTypes memberTypes = memberInfo.MemberType;
if (memberTypes == MemberTypes.Property)
{
result = new DotnetObject
((memberInfo as PropertyInfo).GetValue(null));
}
else if (memberTypes == MemberTypes.Field)
{
result = new DotnetObject
((memberInfo as FieldInfo).GetValue(null));
}
else if (memberTypes == MemberTypes.NestedType)
{
result = new DotnetClass
{
ClassType = memberInfo as Type
};
}
else
{
result = new DotnetMethod
{
Target = null,
Type = ClassType,
methodName = key
};
}
}
return(result);
}
public void ReflectMembers()
{
ClearMembers();
comps = GetComponents(typeof(Component));
for (int i = 0; i < comps.Length; ++i)
{
// exclude Replicator from the list
if (comps[i].GetType().Name != "Replicator")
{
// save name of component for display purposes
classNames.Add(comps[i].GetType().Name);
// get type of component and save its member info
System.Type type = comps[i].GetType();
MemberInfo[] info = type.GetMembers();
for (int j = 0; j < info.Length; ++j)
{
// MemberInfo: displays the type and name of the member with a space between them (I.E. "System.single speed")
// MemberInfo.Name: displays the name of the member
// MemberInfo.MemberType: displays the type of member (I.E., field or method)
// MemberInfo.ReflectedType: displays the type that the member belongs to (I.E., the class name)
// MemberInfo.DeclaringType: the type that originally declared the member (either the class from ReflectedType or Object for more global members)
// MemberInfo.Module: the source of the type, usually a DLL
// MemberInfo.MetadataToken: an unique ID for metadata
if (info[j].DeclaringType.Name != "Object" &&
info[j].DeclaringType.Name != "Component" &&
info[j].DeclaringType.Name != "MonoBehaviour" && // for extra things like GUILayout
info[j].DeclaringType.Name != "Behaviour" && // for extra things like IsActiveAndEnabled
(info[j].MemberType == MemberTypes.Property ||
info[j].MemberType == MemberTypes.Field))
{
Debug.Log(info[j].Name + "\nMemberType: " + info[j]);
string typeAsString = GetTypeAsString(info[j]);
members.Add(new MyMemberInfo(info[j].Name, typeAsString, Type.GetType(typeAsString), info[j].MemberType.ToString(), classNames[i]));
}
}
}
}
Debug.Log("");
}
private void WriteInterface(StreamWriter s, System.Type t)
{
s.Write("public interface ");
s.Write(t.Name);
if (t.BaseType != typeof(object) && t.BaseType != null)
{
s.Write(" : ");
s.Write(t.BaseType.Name);
}
s.Write(" {\n");
foreach (MemberInfo mb in t.GetMembers())
{
s.Write(mb);
s.Write(";\n");
}
s.WriteLine("}");
}
private void Parse(System.Type aType)
{
object[] attrs;
foreach (MemberInfo info in aType.GetMembers())
{
bool found = false;
attrs = info.GetCustomAttributes(false);
foreach (object attr in attrs)
{
if (TypeValidator.IsCompatible(attr.GetType(), typeof(DevelopmentInformationAttribute)) == true)
{
members.Add(info);
found = true;
break;
}
}
}
}
public static bool PassesRequiredFieldValidation(Object thing, out List <string> _failedFields)
{
bool isValid = true;
int ffIndex = 0;
_failedFields = new List <string>();
Type thingType = thing.GetType();
int count;
MemberInfo[] members = thingType.GetMembers(_BINDINGS);
count = members.Length;
for (int i = 0; i < count; ++i)
{
MemberInfo member = members[i];
if (member.GetCustomAttributes(typeof(RequiredFieldAttribute), false).Length <= 0)
{
continue;
}
bool memberValid = true;
if (member.MemberType == MemberTypes.Field)
{
FieldInfo field = (FieldInfo)member;
memberValid = field.GetValue(thing) != null;
}
else if (member.MemberType == MemberTypes.Property)
{
PropertyInfo property = (PropertyInfo)member;
memberValid = property.GetValue(thing, new object[0] {
}) != null;
}
if (!memberValid)
{
_failedFields[ffIndex] = member.Name;
}
isValid = isValid && memberValid;
}
return(isValid);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
public void Initialize <T>(object data)
{
System.Type t = typeof(T);
MemberInfo[] members = t.GetMembers(BindingFlags.Public | BindingFlags.Instance);
foreach (MemberInfo m in members)
{
if (m.MemberType == MemberTypes.Property)
{
PropertyInfo pi = t.GetProperty(m.Name);
if (pi != null)
{
if (pi.PropertyType.Name.Equals("String"))
{
var ret = (string)pi.GetValue(data, null);
if (ret == null)
{
pi.SetValue(data, "", null);
}
}
else if (pi.PropertyType.Name.Equals("DateTime"))
{
var ret = (DateTime)pi.GetValue(data, null);
if (ret == DateTime.MinValue)
{
pi.SetValue(data, new DateTime(1753, 1, 1, 0, 0, 0), null);
}
}
else if (pi.PropertyType.Name.Equals("Byte"))
{
var ret = (Byte[])pi.GetValue(data, null);
if (ret == null)
{
//pi.SetValue(data, "", null);
}
}
}
}
}
}
internal static MatchType Reflect(System.Type type)
{
MatchType type2 = new MatchType {
type = type
};
MemberInfo[] members = type.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly);
ArrayList list = new ArrayList();
for (int i = 0; i < members.Length; i++)
{
MatchMember member = MatchMember.Reflect(members[i]);
if (member != null)
{
list.Add(member);
}
}
type2.fields = (MatchMember[])list.ToArray(typeof(MatchMember));
return(type2);
}
internal static MemberInfo[] GetBindableMembers(TypeInfo typeInfo)
{
ReflectionSerializerVerifier.AssertEitherExtModelAttribute(typeInfo);
var list = new List <MemberInfo>();
foreach (var mi in typeInfo.GetMembers(BindingFlags.Public | BindingFlags.Instance))
{
if ((mi.MemberType == MemberTypes.Property && ReflectionUtil.TryGetSetter(mi) != null) ||
mi.MemberType == MemberTypes.Field)
{
if (mi.DeclaringType != null && !mi.DeclaringType.GetTypeInfo().IsAssignableFrom(typeof(RdReflectionBindableBase)))
{
list.Add(mi);
}
}
}
return(list.ToArray());
}
protected virtual void CheckAccessibleMembersAreVirtual(System.Type type)
{
MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var member in members)
{
if (member is PropertyInfo)
{
var property = (PropertyInfo)member;
if (property.ShouldBeProxiable())
{
MethodInfo[] accessors = property.GetAccessors(true);
if (accessors != null)
{
foreach (var accessor in accessors)
{
CheckMethodIsVirtual(type, accessor);
}
}
}
}
else if (member is MethodInfo)
{
var methodInfo = (MethodInfo)member;
// avoid the check of properties getter and setter because already checked when the PropertyInfo was found.
if (!IsPropertyMethod(methodInfo) && methodInfo.ShouldBeProxiable())
{
CheckMethodIsVirtual(type, methodInfo);
}
}
else if (member is FieldInfo)
{
var memberField = (FieldInfo)member;
if (memberField.IsPublic || memberField.IsAssembly || memberField.IsFamilyOrAssembly)
{
EnlistError(type, "field " + member.Name + " should not be public nor internal (ecapsulate it in a property).");
}
}
}
}
public bool PredictStaticMember(string input, System.Type type, List <string> list)
{
MemberInfo[] members = type.GetMembers(BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
for (int i = 0; i < members.Length; i += 1)
{
string memberName = members[i].Name;
if (memberName == "GetType" ||
memberName.StartsWith("op_") ||
memberName.StartsWith("get_") ||
memberName.StartsWith("set_") ||
memberName.StartsWith("."))
{
continue;
}
if (input == "" || memberName.StartsWith(input))
{
list.Add(memberName);
}
}
return(members.Length > 0);
}
