GetEvents() публичный метод

public GetEvents ( ) : EventInfo[]
Результат EventInfo[]
Пример #1
0
        /// <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);
        }
Пример #4
0
        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());
                        }
                    }
                };
        }
Пример #5
0
        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();
        }
Пример #6
0
        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;
        }
Пример #9
0
 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());
 }
Пример #10
0
        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());
            }
        }
Пример #11
0
 ///<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);
         }
     }
 }
Пример #13
0
 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);
 }
Пример #14
0
        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));
            }
        }
Пример #15
0
        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);

        }
Пример #16
0
 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;
 }
Пример #17
0
        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");
            }
        }
Пример #18
0
		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);
                }
            }
        }
Пример #20
0
		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));
			}
		}
Пример #22
0
        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);
        }
Пример #23
0
		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));
			}
		}
Пример #24
0
        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;
        }
Пример #25
0
        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());
        }
Пример #26
0
        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);
        }
Пример #27
0
		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;
		}
Пример #28
0
		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);
					}
				}
			}
		}
Пример #29
0
        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;
            }

        }
Пример #30
0
        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);
        }
Пример #32
0
        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);
                    }
                }
            }
        }
Пример #33
0
        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);
            }
Пример #36
0
 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];
 }