/// <summary> /// Initializes a new instance of the <see cref="TypeNodeViewModel"/> class. /// </summary> /// <param name="pType">Type of the port.</param> public TypeNodeViewModel(Type pType) { this.DisplayString = pType.Name; this.Description = "A class sample node."; foreach (PropertyInfo lPropertyInfo in pType.GetProperties()) { if (lPropertyInfo.CanWrite) { PortViewModel lPort = null; lPort = new PortViewModel {Direction = PortDirection.Input, DisplayString = lPropertyInfo.Name, PortType = "Property"}; this.Ports.Add(lPort); } if (lPropertyInfo.CanRead) { PortViewModel lPort = null; lPort = new PortViewModel { Direction = PortDirection.Output, DisplayString = lPropertyInfo.Name, PortType = "Property" }; this.Ports.Add(lPort); } } foreach (EventInfo lEventInfo in pType.GetEvents()) { PortViewModel lPort = new PortViewModel {Direction = PortDirection.Output, PortType = "Event", DisplayString = lEventInfo.Name}; this.Ports.Add(lPort); } }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Executed to build the activation plan. /// </summary> /// <param name="binding">The binding that points at the type whose activation plan is being released.</param> /// <param name="type">The type whose activation plan is being manipulated.</param> /// <param name="plan">The activation plan that is being manipulated.</param> /// <returns> /// A value indicating whether to proceed or interrupt the strategy chain. /// </returns> public override StrategyResult Build(IBinding binding, Type type, IActivationPlan plan) { EventInfo[] events = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); foreach (EventInfo evt in events) { #if !MONO PublishAttribute[] attributes = evt.GetAllAttributes<PublishAttribute>(); #else PublishAttribute[] attributes = ExtensionsForICustomAttributeProvider.GetAllAttributes<PublishAttribute>(evt); #endif foreach (PublishAttribute attribute in attributes) plan.Directives.Add(new PublicationDirective(attribute.Channel, evt)); } MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); var injectorFactory = binding.Components.Get<IInjectorFactory>(); foreach (MethodInfo method in methods) { #if !MONO SubscribeAttribute[] attributes = method.GetAllAttributes<SubscribeAttribute>(); #else SubscribeAttribute[] attributes = ExtensionsForICustomAttributeProvider.GetAllAttributes<SubscribeAttribute>(method); #endif foreach (SubscribeAttribute attribute in attributes) { IMethodInjector injector = injectorFactory.GetInjector(method); plan.Directives.Add(new SubscriptionDirective(attribute.Channel, injector, attribute.Thread)); } } return StrategyResult.Proceed; }
/// <summary> /// EmitEventBridgeType 发射实现了IEventBridge接口的事件桥类型 /// </summary> /// <param name="typeOfEventPublisher">发布事件的类型</param> /// <param name="typeOfEventHandler">包含了事件处理器方法的类型</param> /// <param name="eventHandlerNamePrefix">处理器方法的名称的前缀(即该前缀加上事件名称就得到处理器方法的名称)</param> /// <returns>实现了IEventBridge接口的事件桥类型,其构造参数为:typeOfEventPublisher,typeOfEventHandler</returns> public Type EmitEventBridgeType(Type typeOfEventPublisher, Type typeOfEventHandler ,string eventHandlerNamePrefix) { Dictionary<string, string> eventAndHanlerMapping = new Dictionary<string, string>(); foreach (EventInfo eventInfo in typeOfEventPublisher.GetEvents()) { string handlerName = eventHandlerNamePrefix + eventInfo.Name ; MethodInfo method = typeOfEventHandler.GetMethod(handlerName) ; if (method == null) { throw new Exception(string.Format("Can't find proper handler for {0}.{1} event in {2}!", typeOfEventPublisher, eventInfo.Name, typeOfEventHandler)); } Type[] argTypes = EmitHelper.GetParametersType(method); Type[] eventArgTypes = EmitHelper.GetParametersType(eventInfo.EventHandlerType.GetMethod("Invoke")); if (argTypes.Length != eventArgTypes.Length) { throw new Exception(string.Format("Can't find proper handler for {0}.{1} event in {2}!", typeOfEventPublisher, eventInfo.Name, typeOfEventHandler)); } for (int i = 0; i < argTypes.Length; i++) { if (argTypes[i] != eventArgTypes[i]) { throw new Exception(string.Format("Can't find proper handler for {0}.{1} event in {2}!", typeOfEventPublisher, eventInfo.Name, typeOfEventHandler)); } } eventAndHanlerMapping.Add(eventInfo.Name, handlerName); } return this.EmitEventBridgeType(typeOfEventPublisher, typeOfEventHandler ,eventAndHanlerMapping); }
public void SetupEventSubscriptions(DynamicHubProxyInterceptor interceptor, IDynamicHubProxy proxy, Type proxyType) { var events = proxyType.GetEvents(BindingFlags.Public | BindingFlags.Instance); foreach (var @event in events) _proxy.Subscribe(@event.Name).Data += (tokens) => { if( _events.ContainsKey(@event.Name)) { var eventMethods = _events[@event.Name]; foreach (var eventMethod in eventMethods) { var actualParameters = new List<object>(); var parameters = eventMethod.Method.GetParameters(); for( var parameterIndex=0; parameterIndex<parameters.Length; parameterIndex++ ) { var actualMethod = _toObjectMethod.MakeGenericMethod(parameters[parameterIndex].ParameterType); var actualParameter = actualMethod.Invoke(tokens[parameterIndex], null); actualParameters.Add(actualParameter); } eventMethod.DynamicInvoke(actualParameters.ToArray()); } } }; }
private static void WriteExtensionClass(Type type, TextWriter output) { var usingNamespaces = new SortedSet<string> { type.Namespace, "System.Reactive", "System.Reactive.Linq" }; var builder = new StringBuilder(); builder.AppendLine("namespace EventToObservableReflection"); builder.AppendLine("{"); builder.AppendLine(string.Format("\tpublic static class {0}EventToObservableExtensions", type.Name)); builder.AppendLine("\t{"); foreach (var e in type.GetEvents()) { WriteExtensionMethod(type, e, builder, usingNamespaces); } builder.AppendLine("\t}"); builder.AppendLine("}"); foreach (var ns in usingNamespaces) { output.WriteLine("using {0};", ns); } output.WriteLine(); output.WriteLine(builder.ToString()); output.Flush(); }
public ClassInstance(Type wrappedType, Type objectInstanceType) { _wrappedType = wrappedType; // Create a wrapper for each non-collection property. _classProperties = _wrappedType .GetProperties() .Select(p => ClassMemberIndependent.Intercept(new ClassMemberProperty(p, objectInstanceType))) .Concat<ClassMember>(_wrappedType .GetFields() .Select(f => ClassMemberIndependent.Intercept(new ClassMemberField(f, objectInstanceType)))) .ToList(); _classProperties.AddRange( (from method in _wrappedType.GetMethods() where method.ReturnType == typeof(void) && method.GetParameters().Length == 0 let can = (from p in _classProperties where p.Name == "Can" + method.Name && p.PropertyType == typeof(bool) select p).FirstOrDefault() select new ClassMemberCommand(method, can, objectInstanceType)).ToList()); _propertyDescriptors = new PropertyDescriptorCollection(_classProperties.ToArray()); // Create a pass-through for each event. _classEvents = _wrappedType .GetEvents() .Select(e => new ClassEvent(e)) .ToList(); _eventDescriptors = new EventDescriptorCollection(_classEvents.ToArray()); }
public static void DefineInterface(TypeBuilder typeBuilder, Type interfaceType, Type implementType, Action<ILGenerator, MethodInfo, MethodInfo> ilGenerator) { var proxyMethodBuilder = new ProxyMethodBuilder(typeBuilder); InterfaceMapping mapping = implementType.GetInterfaceMap(interfaceType); for (int i = 0; i < mapping.InterfaceMethods.Length; i++) mapping.TargetMethods[i] = proxyMethodBuilder.DefineMethod(mapping.InterfaceMethods[i], il => ilGenerator(il, mapping.InterfaceMethods[i], mapping.TargetMethods[i])); foreach (PropertyInfo propertyInfo in interfaceType.GetProperties()) { MethodBuilder getMethodBuilder = null; MethodInfo getMethodInfo = propertyInfo.GetGetMethod(); if (getMethodInfo != null) getMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, getMethodInfo); MethodBuilder setMethodBuilder = null; MethodInfo setMethodInfo = propertyInfo.GetSetMethod(); if (setMethodInfo != null) setMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, setMethodInfo); ProxyBuilderHelper.DefineProperty(typeBuilder, propertyInfo, getMethodBuilder, setMethodBuilder); } foreach (EventInfo eventInfo in interfaceType.GetEvents()) { var addMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, eventInfo.GetAddMethod()); var removeMethodBuilder = (MethodBuilder)GetTargetMethodInfo(ref mapping, eventInfo.GetRemoveMethod()); ProxyBuilderHelper.DefineEvent(typeBuilder, eventInfo, addMethodBuilder, removeMethodBuilder); } }
private IEnumerable<EventInfo> GetEventsToProxy(Type contractType) { var declaredEvents = contractType.GetEvents(); var inheritedEvents = contractType.GetInterfaces().SelectMany(i => i.GetEvents()); var eventsToProxy = declaredEvents.Union(inheritedEvents); return eventsToProxy; }
public ProxyTypeDescriptor(Type type) { Meta = TypeMeta.Get(type); ProxyType = typeof(PlatformProxy<>).MakeGenericType(type); _properties = Meta.Members.Select(m => new ProxyPropertyDescriptor(this, m)).ToArray(); _propertyCollection = new PropertyDescriptorCollection(_properties); _events = new EventDescriptorCollection(type.GetEvents().Select(e => new ProxyEventDescriptor(e)).ToArray()); }
public JSClassWrapper(ExecutionContext GLOBAL, Type t) { object thisOb = null; mThisType = t; BindingFlags flags = BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public; string applyMethod = null; object []attributes = t.GetCustomAttributes(false); List<MethodInfo> applying = new List<MethodInfo>(); foreach (object attribute in attributes) { if (attribute is ApplyAttribute) applyMethod = ((ApplyAttribute)attribute).MethodName; } if (t == typeof(Type)) { thisOb = t; flags |= BindingFlags.Instance; } Dictionary<string, List<MethodInfo>> namedMethods = new Dictionary<string, List<MethodInfo>>(); foreach (FieldInfo fieldInfo in mThisType.GetFields(flags)) { this.SetItem(GLOBAL, fieldInfo.Name, new JSNativeField(thisOb, fieldInfo)); } foreach (PropertyInfo propInfo in mThisType.GetProperties(flags)) { this.SetItem(GLOBAL, propInfo.Name, new JSNativeProperty(thisOb, propInfo)); } foreach (MethodInfo methodInfo in mThisType.GetMethods(flags)) { List<MethodInfo> ml; if (applyMethod != null && methodInfo.Name == applyMethod && methodInfo.IsStatic) applying.Add(methodInfo); if (!namedMethods.TryGetValue(methodInfo.Name, out ml)) { ml = new List<MethodInfo>(new MethodInfo[] { methodInfo }); namedMethods[methodInfo.Name] = ml; } else ml.Add(methodInfo); } foreach (EventInfo eventInfo in mThisType.GetEvents(flags)) { this.SetItem(GLOBAL, eventInfo.Name, new JSNativeEvent(GLOBAL, thisOb, eventInfo)); } foreach (KeyValuePair<string, List<MethodInfo>> method in namedMethods) { this.SetItem(GLOBAL, method.Key, new JSNativeMethod(method.Value.ToArray())); } if (applying.Count > 0) { mApplyMethod = new JSNativeMethod(applying.ToArray()); } }
///<summary> /// Retrives a list of names of events that the given type publishes. ///</summary> ///<param name="type"></param> ///<returns></returns> public static ICollection<string> GetEventNames(Type type) { List<string> list = new List<string>(); foreach (EventInfo info in type.GetEvents()) { list.Add(info.Name); } return list; }
private static void InitializeFollowers(IServiceProvider context, Type interfaceType, string followermethodName) { if (!CorrelationResolver.IsInitializingMember(interfaceType, followermethodName, null)) { foreach (EventInfo info in interfaceType.GetEvents()) { CreateFollowerEntry(context, interfaceType, followermethodName, info.Name); } } }
private static void BuildEventFields(Type t, List<FieldInfo> lst) { lst.AddRange( from ei in t.GetEvents(AllBindings) let dt = ei.DeclaringType select dt.GetField(ei.Name, AllBindings) into fi where fi != null select fi); }
private void FindAndRemoveEventHandlerMethods(Type type, IMethodRemover methodRemover) { foreach (EventInfo eInfo in type.GetEvents()) { RemoveMethod(methodRemover, eInfo.GetAddMethod()); RemoveMethod(methodRemover, eInfo.GetRaiseMethod()); RemoveMethod(methodRemover, eInfo.GetRemoveMethod()); RemoveMethod(methodRemover, eInfo.GetAddMethod()); eInfo.GetOtherMethods().ForEach(mi => RemoveMethod(methodRemover, mi)); } }
static void BuildEventFields(Type t, List<FieldInfo> lst) { // Type.GetEvent(s) gets all Events for the type AND it's ancestors // Type.GetField(s) gets only Fields for the exact type. // (BindingFlags.FlattenHierarchy only works on PROTECTED & PUBLIC // doesn't work because Fields are PRIVATE) // NEW version of this routine uses .GetEvents and then uses .DeclaringType // to get the correct ancestor type so that we can get the FieldInfo. lst.AddRange(from ei in t.GetEvents(AllBindings) let dt = ei.DeclaringType select dt.GetField(ei.Name, AllBindings) into fi where fi != null select fi); }
private IList<IEventInfo> GetEventsFor(Type netType) { IList<IEventInfo> events = new List<IEventInfo>(); System.Reflection.EventInfo[] netEvents = netType.GetEvents(BindingFlags.Public | BindingFlags.NonPublic); foreach (System.Reflection.EventInfo netEvent in netEvents) { IEventInfo eventInfo = new EventInfo(); eventInfo.Name = netEvent.Name; events.Add(eventInfo); } return events; }
public REndpoint(string path, Type inInterface, Func<RContext, object> generateService) { GenerateService = generateService; Path = path; Interface = inInterface; if (!Interface.GetCustomAttributes(typeof(RContractProvider)).Any()) throw new ArgumentException("Interface must be decorated with RContractProvider Attribute"); Properties = (from p in Interface.GetProperties() let attrs = p.GetCustomAttributes(typeof(RProperty)) where attrs.Any() select p).ToArray(); //var requiresAuth = Interface.GetCustomAttributes(typeof (RRequireAuth)).FirstOrDefault(); //var requiresRole = Interface.GetCustomAttributes(typeof (RRequireRole)).FirstOrDefault(); //var customAttributes = new [] {requiresAuth, requiresRole}.Where(a => a != null).ToArray(); var propmethods = Properties.SelectMany(prop => { if (prop.CanRead && prop.CanWrite) return new [] { prop.GetMethod, prop.SetMethod }; else if (prop.CanRead) return new [] { prop.GetMethod }; return new [] { prop.SetMethod }; }); Methods = (from m in Interface.GetMethods() let attrs = m.GetCustomAttributes(typeof(ROperation)) where attrs.Any() select m).Concat(propmethods) //.Select(m => new CompiledMethodInfo(m, customAttributes)) .Select(m => new CompiledMethodInfo(m)) .ToArray(); Events = (from m in Interface.GetEvents() let attrs = m.GetCustomAttributes(typeof(REvent)) where attrs.Any() select m).ToArray(); var tmp = Events.Select(evt => evt.EventHandlerType .GetMethod("Invoke") .GetParameters() .ToArray()); foreach (var prms in tmp) { int count = prms.Length; bool obj0 = prms[0].ParameterType == typeof(object); bool obj1 = typeof(EventArgs).IsAssignableFrom(prms[1].ParameterType); if (count != 2 || !obj0 || !obj1) throw new ArgumentException("All REvent's must follow the standard Eventhandler<EventArgs> pattern"); } }
protected static IEnumerable<string> EnumerateMemberNames(Type targetType) { var flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance; var properties = targetType.GetProperties(flags); var methods = targetType.GetMethods(flags) .Where(x => !x.Name.StartsWith("get_", StringComparison.Ordinal) && !x.Name.StartsWith("set_", StringComparison.Ordinal)) // Property accessor .Where(x => !x.Name.StartsWith("add_", StringComparison.Ordinal) && !x.Name.StartsWith("remove_", StringComparison.Ordinal)); // Event accessor var events = targetType.GetEvents(flags); var members = new IEnumerable<MemberInfo>[] { properties, methods, events }.SelectMany(x => x); foreach (var memberName in members.Select(x => x.Name).Distinct()) yield return $"{targetType.Name}.{memberName}"; }
static void BuildEventFields(Type t, List<FieldInfo> lst) { // Type.GetEvent(s) gets all Events for the type AND it's ancestors // Type.GetField(s) gets only Fields for the exact type. // (BindingFlags.FlattenHierarchy only works on PROTECTED & PUBLIC // doesn't work because Fieds are PRIVATE) // NEW version of this routine uses .GetEvents and then uses .DeclaringType // to get the correct ancestor type so that we can get the FieldInfo. foreach (EventInfo ei in t.GetEvents(AllBindings)) { Type dt = ei.DeclaringType; if (dt != null) { FieldInfo fi = dt.GetField(ei.Name, AllBindings); if (fi != null) lst.Add(fi); } } }
protected override System.Collections.Generic.IList<JsonProperty> CreateProperties (Type type, MemberSerialization memberSerialization) { var list = base.CreateProperties (type, memberSerialization); foreach (var eventInfo in type.GetEvents (BindingFlags.Instance | BindingFlags.Public)) { var prop = this.CreateProperty (eventInfo, memberSerialization); prop.Writable = true; list.Add (prop); } var idprop = type.GetProperty ("ID", BindingFlags.Instance | BindingFlags.Public); if (idprop != null) { var prop = this.CreateProperty (idprop, memberSerialization); prop.PropertyName = "$name"; prop.PropertyType = typeof(NameConverter.Info); prop.MemberConverter = new NameConverter (); prop.ValueProvider = new NameConverter.ValueProvider(); list.Add (prop); } return list; }
void InitMembers(Type type) { foreach (Type nestedType in type.GetNestedTypes(flags)) { // We cannot use nestedType.IsVisible - that only checks for public types, // but we also need to load protected types. if (nestedType.IsNestedPublic || nestedType.IsNestedFamily || nestedType.IsNestedFamORAssem) { string name = this.FullyQualifiedName + "." + nestedType.Name; InnerClasses.Add(new ReflectionClass(CompilationUnit, nestedType, name, this)); } } foreach (FieldInfo field in type.GetFields(flags)) { if (!field.IsPublic && !field.IsFamily && !field.IsFamilyOrAssembly) continue; if (!field.IsSpecialName) { Fields.Add(new ReflectionField(field, this)); } } foreach (PropertyInfo propertyInfo in type.GetProperties(flags)) { ReflectionProperty prop = new ReflectionProperty(propertyInfo, this); if (prop.IsPublic || prop.IsProtected) Properties.Add(prop); } foreach (ConstructorInfo constructorInfo in type.GetConstructors(flags)) { if (!constructorInfo.IsPublic && !constructorInfo.IsFamily && !constructorInfo.IsFamilyOrAssembly) continue; Methods.Add(new ReflectionMethod(constructorInfo, this)); } foreach (MethodInfo methodInfo in type.GetMethods(flags)) { if (!methodInfo.IsPublic && !methodInfo.IsFamily && !methodInfo.IsFamilyOrAssembly) continue; if (!methodInfo.IsSpecialName) { Methods.Add(new ReflectionMethod(methodInfo, this)); } } this.AddDefaultConstructorIfRequired = (this.ClassType == ClassType.Struct || this.ClassType == ClassType.Enum); foreach (EventInfo eventInfo in type.GetEvents(flags)) { Events.Add(new ReflectionEvent(eventInfo, this)); } }
public bool HasEventRecipients() { if (null == _thisType) { _thisType = this.GetType(); } foreach (NetRuntimeSystem.Reflection.EventInfo item in _thisType.GetEvents()) { MulticastDelegate eventDelegate = (MulticastDelegate)_thisType.GetType().GetField(item.Name, NetRuntimeSystem.Reflection.BindingFlags.NonPublic | NetRuntimeSystem.Reflection.BindingFlags.Instance).GetValue(this); if ((null != eventDelegate) && (eventDelegate.GetInvocationList().Length > 0)) { return(false); } } return(false); }
void InitMembers(Type type) { foreach (Type nestedType in type.GetNestedTypes(flags)) { if (!nestedType.IsVisible) continue; string name = nestedType.FullName.Replace('+', '.'); InnerClasses.Add(new ReflectionClass(CompilationUnit, nestedType, name, this)); } foreach (FieldInfo field in type.GetFields(flags)) { if (!field.IsPublic && !field.IsFamily) continue; if (!field.IsSpecialName) { Fields.Add(new ReflectionField(field, this)); } } foreach (PropertyInfo propertyInfo in type.GetProperties(flags)) { ReflectionProperty prop = new ReflectionProperty(propertyInfo, this); if (prop.IsPublic || prop.IsProtected) Properties.Add(prop); } foreach (ConstructorInfo constructorInfo in type.GetConstructors(flags)) { if (!constructorInfo.IsPublic && !constructorInfo.IsFamily) continue; Methods.Add(new ReflectionMethod(constructorInfo, this)); } foreach (MethodInfo methodInfo in type.GetMethods(flags)) { if (!methodInfo.IsPublic && !methodInfo.IsFamily) continue; if (!methodInfo.IsSpecialName) { Methods.Add(new ReflectionMethod(methodInfo, this)); } } foreach (EventInfo eventInfo in type.GetEvents(flags)) { Events.Add(new ReflectionEvent(eventInfo, this)); } }
public static bool IsFunctionalInterface(Type iType) { if (!iType.IsGenericTypeDefinition && iType.IsInterface) { // ensure that interface contains only 1 method if (iType.GetFields().Length == 0 && iType.GetEvents().Length == 0 && iType.GetProperties().Length == 0 && iType.GetMethods().Length==1) { // ensure that there is no out params var m = iType.GetMethods()[0]; var mParams = m.GetParameters(); for (int i = 0; i < mParams.Length; i++) if (mParams[i].IsOut) return false; // check in exceptions from functional interfaces if (FunctionalInterfaceExceptions.Contains(iType)) return false; if (iType.IsGenericType && FunctionalInterfaceExceptions.Contains(iType.GetGenericTypeDefinition())) return false; return true; } } return false; }
private static void GenerateMarkdownDocumentForType(Type t, string folder, XDocument xml) { var members = xml.Root.Element("members").Elements("member"); var sb = new StringBuilder(); sb.AppendLine("#" + t.Name); sb.Append(GetMarkdownForType(members, t.FullName)); sb.AppendLine("---"); sb.AppendLine("##Methods: "); foreach (var method in t.GetMethods().Where(m => m.IsPublic)) { var methodParams = method.GetParameters(); var fullMethodName = methodParams.Any() ? method.Name + "(" + string.Join(",", methodParams.Select(pi => pi.ParameterType.FullName)) + ")" : method.Name; Debug.WriteLine(t.FullName + "." + fullMethodName); var current = GetMarkdownForMethod(members, t.FullName + "." + fullMethodName); var result = CheckAndAppendStability(current); sb.Append(result); } sb.AppendLine("---"); sb.AppendLine("##Properties: "); foreach (var property in t.GetProperties()) { var current = GetMarkdownForProperty(members, t.FullName + "." + property.Name); var result = CheckAndAppendStability(current); sb.Append(result); } sb.AppendLine("---"); sb.AppendLine("##Events: "); foreach (var e in t.GetEvents()) { var current = GetMarkdownForEvent(members, t.FullName + "." + e.Name); var result = CheckAndAppendStability(current); sb.Append(result); } sb.AppendLine("---"); var fileName = t.Name + ".md"; var filePath = Path.Combine(folder, t.Name + ".md"); System.IO.File.WriteAllText(filePath, sb.ToString()); }
public static Type ReverseEngineer(System.Type _type, bool includeAttributes, List <MemberTypes> memberTypesFilter) { var memberFilters = System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Instance; if (memberTypesFilter == null) { memberTypesFilter = new List <MemberTypes>(); } //for byref types, just ignore them and use the element type if (_type.IsByRef || _type.IsPointer) { _type = _type.GetElementType(); } string typeName = _type.GetName(); Type type = (from t in DataBase.Current.Set <Type>() where t.Name == typeName && t.NameSpace == _type.Namespace select t).SingleOrDefault <Type>(); if (type != null) { return(type); } //initialize the right Type's subclass //enum if (_type.IsEnum) { type = new Enumeration(); } //interface else if (_type.IsInterface) { type = new Interface(); } //delegate else if (_type.IsSubclassOf(typeof(System.Delegate))) { type = new Delegate(); } //class else if (_type.IsClass) { type = new Class(); } //struct else if (_type.IsValueType && !_type.IsEnum) { type = new Struct(); } type.Name = typeName; type.NameSpace = _type.Namespace; type.IsArray = _type.IsArray; type.IsGenericParameter = _type.IsGenericParameter; type.Access = _type.GetAccessModifier(); type.Module = (from m in DataBase.Current.Set <Module>() where m.Name == _type.Module.Name.Replace(".dll", "") select m).SingleOrDefault <Module>(); if (type.Module == null) { type.Module = new Module(); type.Module.Name = _type.Module.Name.Replace(".dll", ""); type.Module.Version = _type.Module.Assembly.GetName().Version.ToString(); DataBase.Current.Set <Module>().Add(type.Module); } //save now so this doesnt loop on ReverseEngineering other types DataBase.Current.Set <Type>().Add(type); DataBase.Current.SaveChanges(); //generics if (_type.IsGeneric()) { int position = 0; foreach (System.Type _genericArg in _type.GetGenericArguments()) { TypeGenericArgument genericArg = new TypeGenericArgument(); if (_genericArg.IsGenericParameter) { genericArg.Position = _genericArg.GenericParameterPosition; } else { genericArg.Position = position; } genericArg.ArgumentType = ReverseEngineer(_genericArg); genericArg.AppliedTo = type; DataBase.Current.Set <TypeGenericArgument>().Add(genericArg); position++; } } DataBase.Current.SaveChanges(); //enum fields if (_type.IsEnum) { //((Enumeration)type).UnderlyingType = ReverseEngineer(Enum.GetUnderlyingType(_type)); if (memberTypesFilter.Contains(MemberTypes.Field)) { foreach (string _item in Enum.GetNames(_type)) { Field field = new Field(); field.Type = type; field.Name = _item.ToString(); field.IsLiteral = true; field.LiteralValue = Enum.Parse(_type, _item); DataBase.Current.Set <Field>().Add(field); } } } else if (_type.IsClass) { ((Class)type).IsAbstract = _type.IsAbstract; if (_type.BaseType != null) { ((Class)type).Parent = (Class)ReverseEngineer(_type.BaseType); } foreach (System.Type _interface in _type.GetImplementedInterfaces()) { if (((Class)type).ImplementedInterfaces == null) { ((Class)type).ImplementedInterfaces = new System.Collections.Generic.List <Interface>(); } ((Class)type).ImplementedInterfaces.ToList <Interface>().Add((Interface)ReverseEngineer(_interface)); } } //attributes if (includeAttributes) { ReverseEngineerAttributes(_type); } //constructors if (memberTypesFilter.Contains(MemberTypes.Constructor)) { foreach (System.Reflection.ConstructorInfo _constructor in _type.GetConstructors(memberFilters)) { if (_constructor.IsCompilerGenerated()) { continue; } Method constructor = ReverseEngineer(_constructor); DataBase.Current.Set <Method>().Add(constructor); if (includeAttributes) { ReverseEngineerAttributes(_constructor); } } } //fields -- except for enums if (memberTypesFilter.Contains(MemberTypes.Field) && !(type is Enumeration)) { foreach (System.Reflection.FieldInfo _field in _type.GetFields(memberFilters)) { if (_field.IsCompilerGenerated()) { continue; } Field field = ReverseEngineer(_field); DataBase.Current.Set <Field>().Add(field); if (includeAttributes) { ReverseEngineerAttributes(_field); } } } //properties if (memberTypesFilter.Contains(MemberTypes.Property)) { foreach (System.Reflection.PropertyInfo _property in _type.GetProperties(memberFilters)) { Property property; if (_property.IsCompilerGenerated()) { continue; } property = ReverseEngineer(_property); DataBase.Current.Set <Property>().Add(property); if (includeAttributes) { ReverseEngineerAttributes(_property); } } } //methods if (memberTypesFilter.Contains(MemberTypes.Property)) { foreach (System.Reflection.MethodInfo _method in _type.GetMethods(memberFilters)) { if (_method.IsCompilerGenerated()) { continue; } //exclude get and set methods since they are decompiled along with their properties if (_method.Name.StartsWith("get_") || _method.Name.StartsWith("set_")) { continue; } Method method = ReverseEngineer(_method); if (includeAttributes) { ReverseEngineerAttributes(_method); } } } //events if (memberTypesFilter.Contains(MemberTypes.Event)) { foreach (System.Reflection.EventInfo _event in _type.GetEvents(memberFilters)) { if (_event.IsCompilerGenerated()) { continue; } Event even = ReverseEngineer(_event); DataBase.Current.Set <Event>().Add(even); if (includeAttributes) { ReverseEngineerAttributes(_event); } } } //inner types if (memberTypesFilter.Contains(MemberTypes.NestedType)) { foreach (System.Type _nestedType in _type.GetNestedTypes(memberFilters)) { if (_nestedType.IsCompilerGenerated()) { continue; } Type nestedType = ReverseEngineer(_nestedType); nestedType.Access = _nestedType.GetAccessModifier(); nestedType.Container = (Class)type; } } DataBase.Current.SaveChanges(); return(type); }
private bool IsAlsoAnEvent(Type type, string fullName) { bool isEvent = false; const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly; EventInfo[] events = type.GetEvents(bindingFlags); foreach (EventInfo eventInfo in events) { if (eventInfo.EventHandlerType.FullName == fullName) { isEvent = true; break; } } return isEvent; }
private void WriteEvents(XmlWriter writer, Type type) { BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic; if (!this.rep.DocumentInheritedMembers) { bindingFlags = bindingFlags | BindingFlags.DeclaredOnly; } EventInfo[] events = type.GetEvents(bindingFlags); foreach (EventInfo eventInfo in events) { bool IsExcluded = false; //check if the event has an exclude tag if (eventInfo.DeclaringType != eventInfo.ReflectedType) // inherited { IsExcluded = assemblyDocCache.HasExcludeTag(GetMemberName(eventInfo, eventInfo.DeclaringType)); } else { IsExcluded = assemblyDocCache.HasExcludeTag(MemberID.GetMemberID(eventInfo)); } if (!IsExcluded) { MethodInfo addMethod = eventInfo.GetAddMethod(true); if (addMethod != null && MustDocumentMethod(addMethod) && IsEditorBrowsable(eventInfo)) { WriteEvent(writer, eventInfo); } } } }
protected override IEnumerable<string/*!*/>/*!*/ EnumerateClrMembers(Type/*!*/ type) { var basicBindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic; // default indexer: string defaultIndexerName = null; if (!_isSingletonClass) { object[] attrs = type.GetCustomAttributes(typeof(DefaultMemberAttribute), false); if (attrs.Length == 1) { defaultIndexerName = ((DefaultMemberAttribute)attrs[0]).MemberName; } } foreach (MethodInfo method in type.GetMethods(basicBindingFlags | BindingFlags.Static | BindingFlags.Instance)) { if (IsVisible(method, false)) { if (method.IsSpecialName) { var name = RubyUtils.MapOperator(method); if (name != null) { yield return name; } if (method.IsStatic == _isSingletonClass) { if (method.Name.StartsWith("get_")) { var propertyName = method.Name.Substring(4); yield return propertyName; if (propertyName == defaultIndexerName) { yield return "[]"; } } if (method.Name.StartsWith("set_")) { var propertyName = method.Name.Substring(4); yield return propertyName + "="; if (propertyName == defaultIndexerName) { yield return "[]="; } } } } else if (method.IsStatic == _isSingletonClass) { yield return method.Name; } } } var bindingFlags = basicBindingFlags | (_isSingletonClass ? BindingFlags.Static : BindingFlags.Instance); foreach (FieldInfo field in type.GetFields(bindingFlags)) { if (IsVisible(field)) { yield return field.Name; if (IsWriteable(field)) { yield return field.Name + "="; } } } foreach (EventInfo evnt in type.GetEvents(bindingFlags)) { yield return evnt.Name; } }
public Type(System.Type type) { if (type.FullName == "System.Array") { Namespace = "System"; Name = "Array"; Kind = TypeIndexKind.GenericDefinition; GenericParams.Add(new TypeIndex("T", TypeIndexKind.GenericParam)); } else { var ti = FromSystemType(type); if (string.IsNullOrEmpty(ti.Namespace)) { return; } Namespace = ti.Namespace; Name = ti.Name; Kind = ti.Kind; GenericParams = ti.GenericParams; } var ns = GetNamespace(); if (type.IsNested) { var names = Name.Split('.'); var ptype = ns.Types[names[0]]; int i = 1; for (; i < names.Length - 1; i++) { ptype = ptype.Types[names[i]]; } Owner = ptype; Name = names[i]; if (ptype.Types.ContainsKey(Name)) { if (ptype.Types[Name].Kind == TypeIndexKind.General) { ptype.Types.Remove(Name); } else { return; } } ptype.Types.Add(this); } else { if (ns.Types.ContainsKey(Name)) { if (ns.Types[Name].Kind == TypeIndexKind.General) { ns.Types.Remove(Name); } else { return; } } ns.Types.Add(this); } if (type.BaseType != null) { BaseTypes.Add(FromSystemType(type.BaseType)); } var itypes = type.GetInterfaces().ToList(); for (int i = itypes.Count - 1; i >= 0; i--) { for (int j = 0; j < i; j++) { if (itypes[i].IsAssignableFrom(itypes[j])) { itypes.RemoveAt(i); break; } } } foreach (var it in itypes) { BaseTypes.Add(FromSystemType(it)); } foreach (var field in type.GetFields()) { Fields.Add(new Field(field, _type_int)); } if (!type.IsEnum) { foreach (var field in type.GetFields()) { Fields.Add(new Field(field)); } foreach (var property in type.GetProperties()) { Properties.Add(new Property(property)); } foreach (var @event in type.GetEvents()) { Events.Add(new Event(@event)); } var inits = type.GetConstructors().Where(m => !m.IsStatic); Methods.Add(new Method(inits)); //去除基类已定义的函数 var imethodnames = type.GetInterfaces() .SelectMany(t => t.GetMethods()) .Select(m => m.Name) .Distinct(); var methodnames = Properties.SelectMany(p => p.Value.Methodnames) .Union(Events.SelectMany(e => e.Value.Methodnames)) .Union(imethodnames); if (type.BaseType != null) { var bmethodnames = type.BaseType .GetMethods() .Select(m => m.Name) .Distinct(); methodnames = methodnames.Union(bmethodnames); } var methods = type.GetMethods() .Where(m => !(m.IsStatic && m.Name.StartsWith("op_")) && !m.Name.Contains(".")) .GroupBy(m => m.Name) .Where(g => !methodnames.Contains(g.Key)); foreach (var g in methods) { Methods.Add(new Method(g)); } if (Kind == TypeIndexKind.GenericDefinition) { var bti = new TypeIndex("typing", "Generic", TypeIndexKind.GenericDefinition); foreach (var p in GenericParams) { bti.GenericParams.Add(p); } BaseTypes.Add(bti); } var prop = Properties.Select(p => p.Value).FirstOrDefault(p => p.IsIndex); if (prop != null) { var bti = new TypeIndex("typing", "Iterable", TypeIndexKind.GenericDefinition); bti.GenericParams.Add(prop.TypeIndex); BaseTypes.Add(bti); } else if (type.FullName == "System.Array") { var bti = new TypeIndex("typing", "Iterable", TypeIndexKind.GenericDefinition); bti.GenericParams.Add(new TypeIndex("T", TypeIndexKind.GenericParam)); BaseTypes.Add(bti); } if (BaseTypes.Count > 1 && BaseTypes[0].Equals(Object)) { BaseTypes.RemoveAt(0); } //去除基类已定义的事件 var eventnames = type.GetInterfaces() .SelectMany(i => i.GetEvents()) .Select(e => e.Name); if (type.BaseType != null) { eventnames = type.BaseType .GetEvents() .Select(e => e.Name) .Union(eventnames); } foreach (var name in eventnames.Distinct()) { Events.Remove(name); } //去除基类已定义的属性 var propnames = type.GetInterfaces() .SelectMany(i => i.GetProperties()) .Select(p => p.Name); if (type.BaseType != null) { propnames = type.BaseType .GetProperties() .Select(p => p.Name) .Union(propnames); } foreach (var name in propnames.Distinct()) { Properties.Remove(name); } } }
public void WriteInterface(Type type) { if (type == null) return; //TODO: this is unreliable, fix it if (!Mapper.IsPublic (type)) return; writer.WriteStartElement ("interface"); writer.WriteAttributeString ("name", Mapper.GetInterfaceName (type)); /* foreach (MemberInfo mbi in type.GetMembers (relevantBindingFlags)) { switch (mbi.MemberType) { case MemberTypes.Method: if (!((MethodInfo)mbi).IsSpecialName) WriteMethod ((MethodInfo)mbi); break; case MemberTypes.Event: WriteSignal ((EventInfo)mbi); break; case MemberTypes.Property: WriteProperty ((PropertyInfo)mbi); break; default: Console.Error.WriteLine ("Warning: Unhandled MemberType '{0}' encountered while introspecting {1}", mbi.MemberType, type.FullName); break; } } */ foreach (MethodInfo mi in type.GetMethods (relevantBindingFlags)) if (!mi.IsSpecialName) WriteMethod (mi); foreach (EventInfo ei in type.GetEvents (relevantBindingFlags)) WriteSignal (ei); foreach (PropertyInfo pri in type.GetProperties (relevantBindingFlags)) WriteProperty (pri); //TODO: indexers //TODO: attributes as annotations? writer.WriteEndElement (); //this recursion seems somewhat inelegant WriteInterface (type.BaseType); }
public void WriteType(System.Type type) { System.Reflection.TypeInfo typeInfo = type.GetTypeInfo(); if (typeInfo.BaseType != typeof(System.MulticastDelegate) && typeInfo.BaseType != typeof(System.EventArgs) && typeInfo.Namespace.StartsWith("Tizen.NUI")) { if (typeInfo.IsEnum) { WriteEnum(type, null); return; } if (type.Name == "Vector2") { var x = 1; } var staticMethodInfos = type.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly); var instanceMethodInfos = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (var methodInfo in staticMethodInfos) { if (!methodInfo.IsSpecialName) { WriteMethod(type, true, methodInfo); } else if (methodInfo.Name.Substring(0, 3) == "op_") { WriteOperator(type, methodInfo); } } foreach (var methodInfo in instanceMethodInfos) { if (!methodInfo.IsSpecialName) { WriteMethod(type, false, methodInfo); } } System.Reflection.PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (var property in properties) { var accessors = property.GetAccessors(); var setMethod = Array.Find <MethodInfo>(accessors, MatchNameSet); WriteProperty(type, property, setMethod != null); } System.Reflection.EventInfo[] events = type.GetEvents(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); foreach (var ev in events) { WriteEvent(type, ev.Name); } var nestedTypes = type.GetNestedTypes(BindingFlags.Public | BindingFlags.DeclaredOnly); foreach (var subtype in nestedTypes) { if (subtype.GetTypeInfo().IsEnum) { WriteEnum(type, subtype); } } } }
public void Merge(Object ast, System.Type type) { ast.IsAbstract = type.GetCustomAttribute <AbstractAttribute>() != null; ast.IsAlreadyGluonGenerated = typeof(GluonObject).IsAssignableFrom(type); var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).ToList(); foreach (var m in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { if (m.Name == "Create" && m.ReturnType == type) { ast.Constructors.Add(ResolveAsConstructor(m)); methods.Remove(m); } } foreach (var p in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { ast.Properties.Add(Resolve(p)); if (p.GetMethod != null) { methods.Remove(p.GetMethod); } if (p.SetMethod != null) { methods.Remove(p.SetMethod); } } foreach (var e in type.GetEvents(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)) { ast.Events.Add(Resolve(e)); if (e.AddMethod != null) { methods.Remove(e.AddMethod); } if (e.RemoveMethod != null) { methods.Remove(e.RemoveMethod); } } Dictionary <string, int> overloads = new Dictionary <string, int>(); foreach (var m in methods) { var methodNode = Resolve(m); int ordinal = 0; overloads.TryGetValue(m.Name, out ordinal); overloads[m.Name] = ordinal + 1; methodNode.OverloadOrdinal = ordinal; ast.Methods.Add(methodNode); } var impl = type.GetInterfaces().Reverse().ToList(); HashSet <System.Type> indirect = new HashSet <System.Type>(); foreach (var iface in impl) { foreach (var indirectiface in iface.GetInterfaces()) { if (!indirect.Contains(indirectiface)) { indirect.Add(indirectiface); } } } foreach (var sub in indirect) { impl.Remove(sub); } if (impl != null && impl.Count != 0) { ast.BaseType = (Object)Resolve(impl[0]); if (ast.BaseType != null && ast.BaseType.IsPureReference) { ast.BaseType = null; } if (ast.BaseType != null) { for (int i = 1; i < impl.Count; i++) { ast.Interfaces.Add((Object)Resolve(impl[i])); } } else { for (int i = 0; i < impl.Count; i++) { ast.Interfaces.Add((Object)Resolve(impl[i])); } } // TODO Can this error ever happen this way? //for (int i = 0; i < ast.Interfaces.Count; i++) //{ // if (ast.Interfaces[i] == null) // Errors.IncompatibleType(impl[i + (ast.BaseType == null ? 0 : 1)]); //} } }
/// <devdoc> /// Static helper API around reflection to get and cache /// events. This does not recurse to the base class. /// </devdoc> private static EventDescriptor[] ReflectGetEvents(Type type) { if (_eventCache == null) { lock (_internalSyncObject) { if (_eventCache == null) { _eventCache = new Hashtable(); } } } EventDescriptor[] events = (EventDescriptor[])_eventCache[type]; if (events != null) { return events; } lock (_internalSyncObject) { events = (EventDescriptor[])_eventCache[type]; if (events == null) { BindingFlags bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance; TypeDescriptor.Trace("Events : Building events for {0}", type.Name); // Get the type's events. Events may have their add and // remove methods individually overridden in a derived // class, but at some point in the base class chain both // methods must exist. If we find an event that doesn't // have both add and remove, we skip it here, because it // will be picked up in our base class scan. // EventInfo[] eventInfos = type.GetEvents(bindingFlags); events = new EventDescriptor[eventInfos.Length]; int eventCount = 0; for (int idx = 0; idx < eventInfos.Length; idx++) { EventInfo eventInfo = eventInfos[idx]; // GetEvents returns events that are on nonpublic types // if those types are from our assembly. Screen these. // if ((!(eventInfo.DeclaringType.IsPublic || eventInfo.DeclaringType.IsNestedPublic)) && (eventInfo.DeclaringType.Assembly == typeof(ReflectTypeDescriptionProvider).Assembly)) { Debug.Fail("Hey, assumption holds true. Rip this assert."); continue; } MethodInfo addMethod = eventInfo.GetAddMethod(); MethodInfo removeMethod = eventInfo.GetRemoveMethod(); if (addMethod != null && removeMethod != null) { events[eventCount++] = new ReflectEventDescriptor(type, eventInfo); } } if (eventCount != events.Length) { EventDescriptor[] newEvents = new EventDescriptor[eventCount]; Array.Copy(events, 0, newEvents, 0, eventCount); events = newEvents; } #if DEBUG foreach(EventDescriptor dbgEvent in events) { Debug.Assert(dbgEvent != null, "Holes in event array for type " + type); } #endif _eventCache[type] = events; } } return events; }
public static Class From(System.Type type) { Logger.Info($"Creating class from type: {type.FullName}"); var obj = new Class(); obj.Name = type.FullName; obj.IsInterface = type.IsInterface; obj.IsAbstract = type.IsAbstract; if (type.BaseType != null) { obj.Parent = TypeRef.From(type.BaseType); } var ifaces = type.GetInterfaces(); obj.Interfaces.Capacity = ifaces.Length; foreach (var iface in ifaces) { obj.Interfaces.Add(TypeRef.From(iface)); } // No to pass BindingFlags, already gets only the public constructors by default var ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); obj.Constructors.Capacity = ctors.Length; foreach (var ctor in ctors) { obj.Constructors.Add(Function.From(ctor)); } // FIXME Do we need to list static methods too? var methods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); obj.Methods.Capacity = methods.Length; foreach (var method in methods) { // Skip anonymous property accessors (get_Name) if (!method.IsSpecialName) { obj.Methods.Add(Function.From(method)); } } var properties = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); obj.Properties.Capacity = properties.Length; foreach (var property in properties) { obj.Properties.Add(Property.From(property)); } var events = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); obj.Events.Capacity = events.Length; foreach (var evt in events) { obj.Events.Add(Event.From(evt)); } return(obj); }
private static EventInfo findEventInfo(PlTerm memberSpec, Type c, ref Type[] paramz, BindingFlags searchFlags) { if (memberSpec.IsVar) { WarnMissing("findEventInfo IsVar {0} on type {1}", memberSpec, c); return null; } if (memberSpec.IsInteger) { int ordinal = memberSpec.intValue(); var mis = c.GetEvents(BindingFlagsALL); if (ordinal < 0 || ordinal >= mis.Length) return null; return mis[ordinal]; } if (IsTaggedObject(memberSpec)) { var r = tag_to_object(memberSpec[1].Name) as EventInfo; if (r != null) return r; } if (memberSpec.IsCompound) { if (memberSpec.Name == "e") { var arg1 = memberSpec.Arg(0); if (arg1.IsInteger) { Type[] paramzN = null; return findEventInfo(arg1, c, ref paramzN, searchFlags); } } } if (c == null) return null; EventInfo ei = c.GetEvent(memberSpec.Name, searchFlags); if (ei != null) return ei; var members = c.GetEvents(searchFlags); if (members.Length == 0) return null; int arity = (paramz != null) ? paramz.Length : memberSpec.Arity; EventInfo candidate = null; foreach (var info in members) { var infos = info.GetRaiseMethod(); ParameterInfo[] paramTypes = infos.GetParameters(); if (paramTypes.Length == arity) { if (ParamsMatch(paramz, paramTypes)) return info; if (infos.IsStatic) { if (candidate == null) { candidate = info; } } else { if (candidate == null) { candidate = info; } } } } return candidate ?? members[0]; }