public void InvokeInParallel(IServiceContext serviceContext, bool inheritThreadLocals, params Runnable[] runnables) { CountDownLatch latch = new CountDownLatch(runnables.Length); ParamHolder <Exception> throwableHolder = new ParamHolder <Exception>(); IForkState forkState = inheritThreadLocals ? ThreadLocalCleanupController.CreateForkState() : null; Thread[] threads = new Thread[runnables.Length]; for (int a = runnables.Length; a-- > 0;) { Runnable catchingRunnable = new CatchingRunnable(forkState, runnables[a], latch, throwableHolder, ThreadLocalCleanupController); Thread thread = new Thread(delegate() { catchingRunnable.Run(); }); thread.IsBackground = true; threads[a] = thread; } foreach (Thread thread in threads) { thread.Start(); } latch.Await(TimeSpan.FromMilliseconds(Timeout)); if (throwableHolder.Value != null) { throw RuntimeExceptionUtil.Mask(throwableHolder.Value, "Error occured while invoking runnables"); } }
public Object ProcessServiceResult(Object result, IList <IObjRef> objRefs, IList <Object> entities, Type expectedType, Object[] serviceRequestArgs, Attribute annotation) { IPagingResponse pagingResponse = (IPagingResponse)result; QueryResultType queryResultType = QueryResultType.REFERENCES; if (annotation is FindAttribute) { queryResultType = ((FindAttribute)annotation).ResultType; } switch (queryResultType) { case QueryResultType.BOTH: pagingResponse.RefResult = objRefs; pagingResponse.Result = entities; break; case QueryResultType.ENTITIES: pagingResponse.RefResult = null; pagingResponse.Result = entities; break; case QueryResultType.REFERENCES: pagingResponse.RefResult = objRefs; pagingResponse.Result = null; break; default: throw RuntimeExceptionUtil.CreateEnumNotSupportedException(queryResultType); } return(pagingResponse); }
protected void ValidateDocument(XDocument doc) { try { validator.Validate(doc); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error during xml document validation"); } }
protected void CallMethod(Object entity, String message) { try { Method.Invoke(entity, EMPTY_ARGS); } catch (Exception e) { Type entityType = EntityMetaDataProvider.GetMetaData(entity.GetType()).EntityType; throw RuntimeExceptionUtil.Mask(e, "Error occured while handling " + message + " method of entity type " + entityType.FullName); } }
public virtual void IfZCmp(CompareOperator compareOperator, Label label) { switch (compareOperator) { case CompareOperator.EQ: gen.Emit(OpCodes.Brfalse, label); break; case CompareOperator.NE: gen.Emit(OpCodes.Brtrue, label); break; default: throw RuntimeExceptionUtil.CreateEnumNotSupportedException(compareOperator); } }
public override Object GetValue(Object obj) { if (Getter == null) { return(null); } try { return(Getter.Invoke(obj, EMPTY_ARGS)); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while calling '" + Getter + "' on object '" + obj + "' of type '" + obj.GetType().ToString() + "'"); } }
public override Object GetValue(Object obj) { try { return(getDelegate(obj)); } catch (Exception e) { if (getDelegate == null) { throw new NotSupportedException(); } throw RuntimeExceptionUtil.Mask(e, "Error occured while calling '" + Getter + "' on object '" + obj + "' of type '" + obj.GetType().ToString() + "'"); } }
public virtual void IfCmp(Type type, CompareOperator compareOperator, Label label) { switch (compareOperator) { case CompareOperator.EQ: gen.Emit(OpCodes.Beq, label); break; case CompareOperator.NE: gen.Emit(OpCodes.Bne_Un, label); break; default: throw RuntimeExceptionUtil.CreateEnumNotSupportedException(compareOperator); } }
public override void SetValue(Object obj, Object value) { try { setDelegate(obj, value); } catch (Exception e) { if (setDelegate == null) { throw new NotSupportedException(); } throw RuntimeExceptionUtil.Mask(e, "Error occured while calling '" + Setter + "' on object '" + obj + "' of type '" + obj.GetType().ToString() + "' with argument '" + value + "'"); } }
protected void LogBytecodeOutput(String typeName, String bytecodeOutput) { #if SILVERLIGHT DirectoryInfo outputFileDir = new DirectoryInfo(TraceDir + Path.DirectorySeparatorChar + GetType().FullName); outputFileDir.Create(); String formattedName = outputFileDir.FullName + Path.DirectorySeparatorChar + typeName + ".txt"; try { using (FileStream outputFile = new FileStream(formattedName, FileMode.Create, FileAccess.Write, FileShare.Read)) #else // the following code allows to write to directories with a length > 260 chars char sep = System.IO.Path.DirectorySeparatorChar; String dirName = LongPath.CreateDir(TraceDir + sep + GetType().FullName); String formattedName = dirName + sep + typeName + ".txt"; try { // Create a file with generic write access SafeFileHandle fileHandle = LongPath.CreateFile(formattedName, FileAccess.ReadWrite, FileShare.ReadWrite, FileMode.OpenOrCreate); try { using (FileStream outputFile = new FileStream(fileHandle, FileAccess.Write)) #endif { System.IO.StreamWriter fw = new System.IO.StreamWriter(outputFile); try { fw.Write(bytecodeOutput); } finally { fw.Close(); } } #if SILVERLIGHT #else } finally { fileHandle.Close(); } #endif } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occurred while trying to write to '" + formattedName + "'"); } }
public override void SetValue(Object obj, Object value) { if (Setter == null) { throw new NotSupportedException("No setter configured for property " + Name); } Object[] args = { value }; try { Setter.Invoke(obj, args); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while calling '" + Setter + "' on object '" + obj + "' of type '" + obj.GetType().ToString() + "' with argument '" + value + "'"); } }
public ValueHolderContainerEntry(Type targetType, RelationMember[] members, IBytecodeEnhancer bytecodeEnhancer, IPropertyInfoProvider propertyInfoProvider, IMemberTypeProvider memberTypeProvider) { entries = new ValueHolderEntry[members.Length]; try { for (int relationIndex = members.Length; relationIndex-- > 0;) { RelationMember member = members[relationIndex]; ValueHolderEntry vhEntry = new ValueHolderEntry(targetType, member, bytecodeEnhancer, propertyInfoProvider, memberTypeProvider); entries[relationIndex] = vhEntry; } } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while processing type '" + targetType.FullName + "'"); } }
protected Object ReadFromStreamLogBeforeException(Stream se, Encoding encoding) { StringBuilder sb = new StringBuilder(); try { StreamReader streamReader = new ExtendedStreamReader(se, sb);; return(ReadFromReader(streamReader)); } catch (XmlTypeNotFoundException e) { throw e; } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, sb.ToString()); } }
protected Object CreateEntityIntern(IEntityMetaData metaData, bool doEmptyInit) { try { if (metaData.EnhancedType == null) { EntityMetaDataRefresher.RefreshMembers(metaData); } EntityFactoryConstructor constructor = GetConstructorEntry(metaData.EnhancedType); Object entity = constructor.CreateEntity(); PostProcessEntity(entity, metaData); return(entity); } catch (Exception e) { if (BytecodePrinter != null) { throw RuntimeExceptionUtil.Mask(e, BytecodePrinter.ToPrintableBytecode(metaData.EnhancedType)); } throw; } }
protected ConstructorInfo GetEmbeddedParamConstructor(Type embeddedType, Type parentObjectType) { ConstructorInfo constructor = typeToEmbbeddedParamConstructorMap.Get(embeddedType); if (constructor == null) { try { constructor = embeddedType.GetConstructor(new Type[] { parentObjectType }); } catch (Exception e) { if (BytecodePrinter != null) { throw RuntimeExceptionUtil.Mask(e, BytecodePrinter.ToPrintableBytecode(embeddedType)); } throw; } typeToEmbbeddedParamConstructorMap.Put(embeddedType, constructor); } return(constructor); }
protected Object ReadFromStreamLogAfterException(Stream se, Encoding encoding) { long position = se.Position; StreamReader streamReader = null; try { streamReader = new StreamReader(se, encoding); return(ReadFromReader(streamReader)); } catch (XmlTypeNotFoundException e) { throw e; } catch (Exception e) { long newPosition = se.Position; se.Seek(position, SeekOrigin.Begin); byte[] buffer = new byte[newPosition - position]; se.Read(buffer, 0, buffer.Length); String xmlContent = new String(encoding.GetChars(buffer)); throw RuntimeExceptionUtil.Mask(e, xmlContent); } }
public void PostProcessCreatedType(Type newType) { foreach (Entry <String, IValueResolveDelegate> entry in initializeStaticFields) { FieldInfo[] fields = ReflectUtil.GetDeclaredFieldInHierarchy(newType, entry.Key); if (fields.Length == 0) { throw new Exception("Field not found: '" + newType.FullName + "." + entry.Key); } Object value = entry.Value.Invoke(entry.Key, newType); foreach (FieldInfo field in fields) { try { field.SetValue(null, value); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while setting field: " + field); } } } initializeStaticFields.Clear(); }
public void HandleCollectionChange(INotifyPropertyChangedSource obj, Object sender, NotifyCollectionChangedEventArgs evnt) { IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData(); Object bases = null; bool parentChildProperty = false; RelationMember[] relationMembers = metaData.RelationMembers; for (int relationIndex = relationMembers.Length; relationIndex-- > 0;) { Object valueDirect = ((IValueHolderContainer)obj).Get__ValueDirect(relationIndex); if (!Object.ReferenceEquals(valueDirect, sender)) { continue; } if (relationMembers[relationIndex].GetAnnotation(typeof(ParentChild)) != null) { bases = obj; parentChildProperty = true; } else { bases = sender; } break; } if (bases == null) { foreach (PrimitiveMember primitiveMember in metaData.PrimitiveMembers) { Object valueDirect = primitiveMember.GetValue(obj); if (!Object.ReferenceEquals(valueDirect, sender)) { continue; } bases = obj; parentChildProperty = true; break; } } if (bases == null) { throw new Exception("Must never happen"); } ICacheModification cacheModification = this.CacheModification; bool oldCacheModification = cacheModification.Active; bool cacheModificationUsed = false; try { switch (evnt.Action) { case NotifyCollectionChangedAction.Add: case NotifyCollectionChangedAction.Remove: case NotifyCollectionChangedAction.Replace: if (evnt.OldItems != null) { foreach (Object oldItem in evnt.OldItems) { HandleRemovedItem(obj, oldItem, parentChildProperty); } } if (evnt.NewItems != null) { foreach (Object newItem in evnt.NewItems) { HandleAddedItem(obj, newItem, parentChildProperty); } } break; #if !SILVERLIGHT case NotifyCollectionChangedAction.Move: // Nothing to do in that case break; #endif case NotifyCollectionChangedAction.Reset: throw new NotSupportedException("Reset is not allowed in a managed collection"); default: throw RuntimeExceptionUtil.CreateEnumNotSupportedException(evnt.Action); } IList <ICollectionChangeExtension> extensions = collectionChangeExtensions.GetExtensions(obj.GetType()); for (int a = 0, size = extensions.Count; a < size; a++) { extensions[a].CollectionChanged(obj, evnt); } } finally { if (!oldCacheModification) { SetToBeUpdated(obj, true); } if (cacheModificationUsed) { cacheModification.Active = oldCacheModification; } } }
protected EntityConfig ReadEntityConfig(XElement entityTag, IMap <String, ILinkConfig> nameToLinkMap) { String entityTypeName = XmlConfigUtil.GetRequiredAttribute(entityTag, XmlConstants.CLASS); try { Type entityType = XmlConfigUtil.GetTypeForName(entityTypeName); Type realType = ProxyHelper.GetRealType(entityType); EntityConfig entityConfig = new EntityConfig(entityType, realType); bool localEntity = !entityTag.Name.Equals(XmlConstants.EXTERNAL_ENTITY); entityConfig.Local = localEntity; IMap <String, IList <XElement> > attributeMap = null; IMap <String, IList <XElement> > entityDefs = XmlConfigUtil.ChildrenToElementMap(entityTag); if (entityDefs.ContainsKey(XmlConstants.TABLE.LocalName)) { String specifiedTableName = XmlConfigUtil.GetRequiredAttribute(entityDefs.Get(XmlConstants.TABLE.LocalName)[0], XmlConstants.NAME); entityConfig.TableName = specifiedTableName; } if (entityDefs.ContainsKey(XmlConstants.PERMISSION_GROUP.LocalName)) { String permissionGroupName = XmlConfigUtil.GetRequiredAttribute(entityDefs.Get(XmlConstants.PERMISSION_GROUP.LocalName)[0], XmlConstants.NAME); entityConfig.PermissionGroupName = permissionGroupName; } if (entityDefs.ContainsKey(XmlConstants.SEQ.LocalName)) { String sequenceName = XmlConfigUtil.GetRequiredAttribute(entityDefs.Get(XmlConstants.SEQ.LocalName)[0], XmlConstants.NAME); entityConfig.SequenceName = sequenceName; } if (attributeMap.ContainsKey(XmlConstants.DESCRIMINATOR.LocalName)) { String descriminatorName = XmlConfigUtil.GetRequiredAttribute(entityDefs.Get(XmlConstants.DESCRIMINATOR.LocalName)[0], XmlConstants.NAME); entityConfig.DescriminatorName = descriminatorName; } if (entityDefs.ContainsKey(XmlConstants.ATTR.LocalName)) { attributeMap = XmlConfigUtil.ToElementMap(entityDefs.Get(XmlConstants.ATTR.LocalName)[0].Elements()); } bool versionRequired = true; if (attributeMap != null) { IMap <String, MemberConfig> allIdMemberConfigs = new HashMap <String, MemberConfig>(); if (attributeMap.ContainsKey(XmlConstants.ID.LocalName)) { MemberConfig idMemberConfig = ReadUniqueMemberConfig(XmlConstants.ID.LocalName, attributeMap); entityConfig.IdMemberConfig = idMemberConfig; allIdMemberConfigs.Put(idMemberConfig.Name, idMemberConfig); } else if (attributeMap.ContainsKey(XmlConstants.ID_COMP.LocalName)) { XElement memberElement = attributeMap.Get(XmlConstants.ID_COMP.LocalName)[0]; IMemberConfig idMemberConfig = ReadCompositeMemberConfig(memberElement, allIdMemberConfigs); entityConfig.IdMemberConfig = idMemberConfig; } else if (!localEntity) { throw new ArgumentException("ID member name has to be set on external entities"); } if (attributeMap.ContainsKey(XmlConstants.ALT_ID.LocalName)) { IList <XElement> altIds = attributeMap.Get(XmlConstants.ALT_ID.LocalName); for (int j = altIds.Count; j-- > 0;) { XElement memberElement = altIds[j]; MemberConfig memberConfig = ReadMemberConfig(memberElement); memberConfig.AlternateId = true; entityConfig.AddMemberConfig(memberConfig); allIdMemberConfigs.Put(memberConfig.Name, memberConfig); } } if (attributeMap.ContainsKey(XmlConstants.ALT_ID_COMP.LocalName)) { IList <XElement> altIdsComp = attributeMap.Get(XmlConstants.ALT_ID_COMP.LocalName); for (int j = altIdsComp.Count; j-- > 0;) { XElement memberElement = altIdsComp[j]; CompositeMemberConfig memberConfig = ReadCompositeMemberConfig(memberElement, allIdMemberConfigs); memberConfig.AlternateId = true; entityConfig.AddMemberConfig(memberConfig); } } if (attributeMap.ContainsKey(XmlConstants.VERSION.LocalName)) { MemberConfig versionMemberConfig = ReadUniqueMemberConfig(XmlConstants.VERSION.LocalName, attributeMap); entityConfig.VersionMemberConfig = versionMemberConfig; } else if (attributeMap.ContainsKey(XmlConstants.NO_VERSION.LocalName)) { versionRequired = false; } else if (!localEntity) { throw new ArgumentException("Version member name has to be set on external entities"); } if (attributeMap.ContainsKey(XmlConstants.CREATED_BY.LocalName)) { MemberConfig createdByMemberConfig = ReadUniqueMemberConfig(XmlConstants.CREATED_BY.LocalName, attributeMap); entityConfig.CreatedByMemberConfig = createdByMemberConfig; } if (attributeMap.ContainsKey(XmlConstants.CREATED_ON.LocalName)) { MemberConfig createdOnMemberConfig = ReadUniqueMemberConfig(XmlConstants.CREATED_ON.LocalName, attributeMap); entityConfig.CreatedOnMemberConfig = createdOnMemberConfig; } if (attributeMap.ContainsKey(XmlConstants.UPDATED_BY.LocalName)) { MemberConfig updatedByMemberConfig = ReadUniqueMemberConfig(XmlConstants.UPDATED_BY.LocalName, attributeMap); entityConfig.UpdatedByMemberConfig = updatedByMemberConfig; } if (attributeMap.ContainsKey(XmlConstants.UPDATED_ON.LocalName)) { MemberConfig updatedOnMemberConfig = ReadUniqueMemberConfig(XmlConstants.UPDATED_ON.LocalName, attributeMap); entityConfig.UpdatedOnMemberConfig = updatedOnMemberConfig; } if (attributeMap.ContainsKey(XmlConstants.BASIC.LocalName)) { IList <XElement> basicAttrs = attributeMap.Get(XmlConstants.BASIC.LocalName); for (int j = basicAttrs.Count; j-- > 0;) { XElement memberElement = basicAttrs[j]; MemberConfig memberConfig = ReadMemberConfig(memberElement); entityConfig.AddMemberConfig(memberConfig); } } if (attributeMap.ContainsKey(XmlConstants.IGNORE.LocalName)) { IList <XElement> ignoreAttrs = attributeMap.Get(XmlConstants.IGNORE.LocalName); for (int j = ignoreAttrs.Count; j-- > 0;) { XElement ignoreElement = ignoreAttrs[j]; MemberConfig memberConfig = ReadMemberConfig(ignoreElement); memberConfig.Ignore = true; entityConfig.AddMemberConfig(memberConfig); } } if (attributeMap.ContainsKey(XmlConstants.RELATION.LocalName)) { IList <XElement> relationAttrs = attributeMap.Get(XmlConstants.RELATION.LocalName); for (int j = relationAttrs.Count; j-- > 0;) { XElement relationElement = relationAttrs[j]; IRelationConfig relationConfig = ReadRelationConfig(relationElement, nameToLinkMap); entityConfig.AddRelationConfig(relationConfig); } } } entityConfig.VersionRequired = versionRequired; return(entityConfig); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while processing mapping for entity: " + entityTypeName); } }
public override Object ConvertValueToType(Type expectedType, Object value, Object additionalInformation) { if (expectedType == null) { return(value); } if (value == null) { if (expectedType.IsValueType) { return(Activator.CreateInstance(expectedType)); } return(null); } if (expectedType.IsAssignableFrom(value.GetType())) { return(value); } Object sourceValue = value; while (true) { Type sourceClass = sourceValue.GetType(); IDedicatedConverter dedicatedConverter = converters.GetExtension(sourceClass, expectedType); if (dedicatedConverter == null) { break; } Object targetValue; try { targetValue = dedicatedConverter.ConvertValueToType(expectedType, sourceClass, sourceValue, additionalInformation); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while converting value: " + sourceValue); } if (targetValue == null) { if (expectedType.IsValueType) { throw new Exception("It is not allowed that an instance of " + typeof(IDedicatedConverter).FullName + " returns null like " + dedicatedConverter + " did for conversion from '" + sourceClass.FullName + "' to '" + expectedType + "'"); } return(null); } if (expectedType.IsAssignableFrom(targetValue.GetType())) { return(targetValue); } if (targetValue.GetType().Equals(sourceValue.GetType())) { throw new Exception("It is not allowed that an instance of " + typeof(IDedicatedConverter).FullName + " returns a value of the same type (" + targetValue.GetType().FullName + ") after conversion like " + dedicatedConverter + " did"); } sourceValue = targetValue; } if (expectedType.IsArray && sourceValue != null && sourceValue.GetType().IsArray) { // try to convert item by item of the array Array sourceArray = (Array)sourceValue; int size = sourceArray.GetLength(0); Type expectedComponentType = expectedType.GetElementType(); Array targetValue = Array.CreateInstance(expectedComponentType, size); for (int a = sourceArray.GetLength(0); a-- > 0;) { Object sourceItem = sourceArray.GetValue(a); Object targetItem = ConvertValueToType(expectedComponentType, sourceItem); targetValue.SetValue(targetItem, a); } return(targetValue); } return(DefaultConversionHelper.ConvertValueToType(expectedType, sourceValue, additionalInformation)); }
protected Type EnhanceTypeIntern(Type originalType, String newTypeNamePrefix, IList <IBytecodeBehavior> pendingBehaviors, IEnhancementHint hint) { if (pendingBehaviors.Count == 0) { return(originalType); } WeakReference originalTypeR = typeToExtendedType.GetWeakReferenceEntry(originalType); if (originalTypeR == null) { throw new Exception("Must never happen"); } String lastTypeHandleName = newTypeNamePrefix; newTypeNamePrefix = newTypeNamePrefix.Replace('.', '/'); StringBuilder sw = new StringBuilder(); try { Type currentType = originalType; if (currentType.IsInterface) { currentType = typeof(Object); } for (int a = 0, size = pendingBehaviors.Count; a < size; a++) { Type newCurrentType = pendingBehaviors[a].GetTypeToExtendFrom(originalType, currentType, hint); if (newCurrentType != null) { currentType = newCurrentType; } } int iterationCount = 0; List <BytecodeBehaviorState> pendingStatesToPostProcess = new List <BytecodeBehaviorState>(); Type currentContent = currentType; //BytecodeClassLoader.ReadTypeAsBinary(currentType); while (pendingBehaviors.Count > 0) { iterationCount++; NewType newTypeHandle = NewType.GetObjectType(newTypeNamePrefix + "$A" + iterationCount); lastTypeHandleName = newTypeHandle.ClassName; IBytecodeBehavior[] currentPendingBehaviors = ListUtil.ToArray(pendingBehaviors); pendingBehaviors.Clear(); if (currentPendingBehaviors.Length > 0 && Log.DebugEnabled) { Log.Debug("Applying behaviors on " + newTypeHandle.ClassName + ": " + Arrays.ToString(currentPendingBehaviors)); } BytecodeEnhancer This = this; Type fCurrentContent = currentContent; BytecodeBehaviorState acquiredState = null; Type newContent = BytecodeBehaviorState.SetState(originalType, currentType, newTypeHandle, BeanContext, hint, delegate() { acquiredState = (BytecodeBehaviorState)BytecodeBehaviorState.State; return(This.ExecutePendingBehaviors(fCurrentContent, sw, currentPendingBehaviors, pendingBehaviors)); }); if (newContent == null) { if (pendingBehaviors.Count > 0) { // "fix" the iterationCount to have a consistent class name hierarchy iterationCount--; continue; } return(currentType); } Type newType = newContent;// BytecodeClassLoader.LoadClass(newTypeHandle.InternalName, newContent); extendedTypeToType.Add(newType, originalTypeR); pendingStatesToPostProcess.Add(acquiredState); currentContent = newContent; currentType = newType; } for (int a = 0, size = pendingStatesToPostProcess.Count; a < size; a++) { pendingStatesToPostProcess[a].PostProcessCreatedType(currentType); } return(currentType); } catch (Exception e) { BytecodeClassLoader.Save(); String classByteCode = sw.ToString(); if (classByteCode.Length > 0) { if (TraceDir != null) { LogBytecodeOutput(lastTypeHandleName, classByteCode); } else { throw RuntimeExceptionUtil.Mask(e, "Bytecode:\n" + classByteCode); } } throw; } }
protected PropertyInfoEntry GetPropertyEntry(Type type, SmartCopyMap <Type, PropertyInfoEntry> map, bool isOldIocMode, bool isIocMode) { ParamChecker.AssertParamNotNull(type, "type"); PropertyInfoEntry propertyEntry = map.Get(type); if (propertyEntry != null) { return(propertyEntry); } Object writeLock = map.GetWriteLock(); lock (writeLock) { propertyEntry = map.Get(type); if (propertyEntry != null) { // Concurrent thread might have been faster return(propertyEntry); } HashMap <String, HashMap <Type, HashMap <String, MethodInfo> > > sortedMethods = new HashMap <String, HashMap <Type, HashMap <String, MethodInfo> > >(); MethodInfo[] methods = ReflectUtil.GetDeclaredMethodsInHierarchy(type); foreach (MethodInfo method in methods) { if (method.DeclaringType.Equals(typeof(Object))) { continue; } if (method.IsStatic) { continue; } try { String propName = GetPropertyNameFor(method); if (propName.Length == 0) { continue; } HashMap <Type, HashMap <String, MethodInfo> > sortedMethod = sortedMethods.Get(propName); if (sortedMethod == null) { sortedMethod = HashMap <Type, HashMap <String, MethodInfo> > .Create(1); sortedMethods.Put(propName, sortedMethod); } ParameterInfo[] parameterInfos = method.GetParameters(); Type propertyType; String prefix; if (parameterInfos.Length == 1) { propertyType = parameterInfos[0].ParameterType; prefix = "set"; } else if (parameterInfos.Length == 0) { propertyType = method.ReturnType; prefix = "get"; } else { throw new Exception("Method is not an accessor: " + method); } HashMap <String, MethodInfo> methodPerType = sortedMethod.Get(propertyType); if (methodPerType == null) { methodPerType = HashMap <String, MethodInfo> .Create(2); sortedMethod.Put(propertyType, methodPerType); } methodPerType.Put(prefix, method); } catch (Exception e) { throw RuntimeExceptionUtil.Mask(e, "Error occured while processing " + method); } } HashMap <String, HashMap <String, MethodInfo> > filteredMethods = FilterOverriddenMethods(sortedMethods, type); HashMap <String, IPropertyInfo> propertyMap = new HashMap <String, IPropertyInfo>(0.5f); foreach (MapEntry <String, HashMap <String, MethodInfo> > propertyData in filteredMethods) { String propertyName = propertyData.Key; HashMap <String, MethodInfo> propertyMethods = propertyData.Value; MethodInfo getter = propertyMethods.Get("get"); MethodInfo setter = propertyMethods.Get("set"); if (isIocMode) { if (setter == null || (!setter.IsPublic && !AnnotationUtil.IsAnnotationPresent <AutowiredAttribute>(setter, false) && !AnnotationUtil.IsAnnotationPresent <PropertyAttribute>(setter, false))) { continue; } } MethodPropertyInfo propertyInfo = new MethodPropertyInfo(type, propertyName, getter, setter); propertyMap.Put(propertyInfo.Name, propertyInfo); } Type[] interfaces = type.GetInterfaces(); List <Type> typesToSearch = new List <Type>(interfaces); typesToSearch.Add(type); foreach (Type typeToSearch in typesToSearch) { PropertyInfo[] properties = typeToSearch.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public); foreach (PropertyInfo property in properties) { if (property.GetGetMethod() != null && property.GetGetMethod().GetParameters().Length != 0) { continue; } if (property.GetSetMethod() != null && property.GetSetMethod().GetParameters().Length != 1) { continue; } MethodInfo getter = null; MethodInfo setter = null; MethodPropertyInfo propertyInfo = (MethodPropertyInfo)propertyMap.Get(property.Name); if (propertyInfo != null) { getter = propertyInfo.Getter; setter = propertyInfo.Setter; } if (getter == null) { getter = property.GetGetMethod(); } if (setter == null) { setter = property.GetSetMethod(); } if (isIocMode && setter == null) { continue; } propertyInfo = new MethodPropertyInfo(type, property.Name, getter, setter); propertyInfo.PutAnnotations(property); propertyMap.Put(propertyInfo.Name, propertyInfo); } } FieldInfo[] fields = ReflectUtil.GetDeclaredFieldsInHierarchy(type); foreach (FieldInfo field in fields) { if (field.IsStatic) { continue; } if (isOldIocMode) { if (!AnnotationUtil.IsAnnotationPresent <AutowiredAttribute>(field, false) && !AnnotationUtil.IsAnnotationPresent <PropertyAttribute>(field, false)) { continue; } } String propertyName = GetPropertyNameFor(field); IPropertyInfo existingProperty = propertyMap.Get(propertyName); if (existingProperty != null && existingProperty.IsWritable) { // Ignore field injection if the already resolved (method-)property is writable continue; } IPropertyInfo propertyInfo = new FieldPropertyInfo(type, propertyName, field); propertyMap.Put(propertyInfo.Name, propertyInfo); } propertyEntry = new PropertyInfoEntry(propertyMap); map.Put(type, propertyEntry); return(propertyEntry); } }