public static T GetAttribute <T>(ICustomAttributeProvider attributeProvider, bool inherit) where T : Attribute { T[] attributes = GetAttributes <T>(attributeProvider, inherit); return(CollectionUtils.GetSingleItem(attributes, true)); }
public static bool IsPropertyIndexed(PropertyInfo property) { ValidationUtils.ArgumentNotNull(property, "property"); return(!CollectionUtils.IsNullOrEmpty <ParameterInfo>(property.GetIndexParameters())); }
private Expression BuildMethodCall(MethodBase method, Type type, ParameterExpression?targetParameterExpression, ParameterExpression argsParameterExpression) { ParameterInfo[] parametersInfo = method.GetParameters(); Expression[] argsExpression; IList <ByRefParameter> refParameterMap; if (parametersInfo.Length == 0) { argsExpression = CollectionUtils.ArrayEmpty <Expression>(); refParameterMap = CollectionUtils.ArrayEmpty <ByRefParameter>(); } else { argsExpression = new Expression[parametersInfo.Length]; refParameterMap = new List <ByRefParameter>(); for (int i = 0; i < parametersInfo.Length; i++) { ParameterInfo parameter = parametersInfo[i]; Type parameterType = parameter.ParameterType; bool isByRef = false; if (parameterType.IsByRef) { parameterType = parameterType.GetElementType(); isByRef = true; } Expression indexExpression = Expression.Constant(i); Expression paramAccessorExpression = Expression.ArrayIndex(argsParameterExpression, indexExpression); Expression argExpression = EnsureCastExpression(paramAccessorExpression, parameterType, !isByRef); if (isByRef) { ParameterExpression variable = Expression.Variable(parameterType); refParameterMap.Add(new ByRefParameter(argExpression, variable, parameter.IsOut)); argExpression = variable; } argsExpression[i] = argExpression; } } Expression callExpression; if (method.IsConstructor) { callExpression = Expression.New((ConstructorInfo)method, argsExpression); } else if (method.IsStatic) { callExpression = Expression.Call((MethodInfo)method, argsExpression); } else { Expression readParameter = EnsureCastExpression(targetParameterExpression !, method.DeclaringType); callExpression = Expression.Call(readParameter, (MethodInfo)method, argsExpression); } if (method is MethodInfo m) { if (m.ReturnType != typeof(void)) { callExpression = EnsureCastExpression(callExpression, type); } else { callExpression = Expression.Block(callExpression, Expression.Constant(null)); } } else { callExpression = EnsureCastExpression(callExpression, type); } if (refParameterMap.Count > 0) { IList <ParameterExpression> variableExpressions = new List <ParameterExpression>(); IList <Expression> bodyExpressions = new List <Expression>(); foreach (ByRefParameter p in refParameterMap) { if (!p.IsOut) { bodyExpressions.Add(Expression.Assign(p.Variable, p.Value)); } variableExpressions.Add(p.Variable); } bodyExpressions.Add(callExpression); callExpression = Expression.Block(variableExpressions, bodyExpressions); } return(callExpression); }
// Token: 0x06000DA0 RID: 3488 RVA: 0x0004F534 File Offset: 0x0004D734 private Expression BuildMethodCall(MethodBase method, Type type, [Nullable(2)] ParameterExpression targetParameterExpression, ParameterExpression argsParameterExpression) { ParameterInfo[] parameters = method.GetParameters(); Expression[] array; IList <ExpressionReflectionDelegateFactory.ByRefParameter> list; if (parameters.Length == 0) { array = CollectionUtils.ArrayEmpty <Expression>(); list = CollectionUtils.ArrayEmpty <ExpressionReflectionDelegateFactory.ByRefParameter>(); } else { array = new Expression[parameters.Length]; list = new List <ExpressionReflectionDelegateFactory.ByRefParameter>(); for (int i = 0; i < parameters.Length; i++) { ParameterInfo parameterInfo = parameters[i]; Type type2 = parameterInfo.ParameterType; bool flag = false; if (type2.IsByRef) { type2 = type2.GetElementType(); flag = true; } Expression index = Expression.Constant(i); Expression expression = Expression.ArrayIndex(argsParameterExpression, index); Expression expression2 = this.EnsureCastExpression(expression, type2, !flag); if (flag) { ParameterExpression parameterExpression = Expression.Variable(type2); list.Add(new ExpressionReflectionDelegateFactory.ByRefParameter(expression2, parameterExpression, parameterInfo.IsOut)); expression2 = parameterExpression; } array[i] = expression2; } } Expression expression3; if (method.IsConstructor) { expression3 = Expression.New((ConstructorInfo)method, array); } else if (method.IsStatic) { expression3 = Expression.Call((MethodInfo)method, array); } else { expression3 = Expression.Call(this.EnsureCastExpression(targetParameterExpression, method.DeclaringType, false), (MethodInfo)method, array); } MethodInfo methodInfo = method as MethodInfo; if (methodInfo != null) { if (methodInfo.ReturnType != typeof(void)) { expression3 = this.EnsureCastExpression(expression3, type, false); } else { expression3 = Expression.Block(expression3, Expression.Constant(null)); } } else { expression3 = this.EnsureCastExpression(expression3, type, false); } if (list.Count > 0) { IList <ParameterExpression> list2 = new List <ParameterExpression>(); IList <Expression> list3 = new List <Expression>(); foreach (ExpressionReflectionDelegateFactory.ByRefParameter byRefParameter in list) { if (!byRefParameter.IsOut) { list3.Add(Expression.Assign(byRefParameter.Variable, byRefParameter.Value)); } list2.Add(byRefParameter.Variable); } list3.Add(expression3); expression3 = Expression.Block(list2, list3); } return(expression3); }
public static IList CreateAndPopulateList(Type listType, Action <IList, bool> populateList) { ValidationUtils.ArgumentNotNull(listType, "listType"); ValidationUtils.ArgumentNotNull(populateList, "populateList"); IList list; Type collectionType; bool isReadOnlyOrFixedSize = false; if (listType.IsArray) { // have to use an arraylist when creating array // there is no way to know the size until it is finised list = new List <object>(); isReadOnlyOrFixedSize = true; } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>), out collectionType)) { Type readOnlyCollectionContentsType = collectionType.GetGenericArguments()[0]; Type genericEnumerable = ReflectionUtils.MakeGenericType(typeof(IEnumerable <>), readOnlyCollectionContentsType); bool suitableConstructor = false; foreach (ConstructorInfo constructor in listType.GetConstructors()) { IList <ParameterInfo> parameters = constructor.GetParameters(); if (parameters.Count == 1) { if (genericEnumerable.IsAssignableFrom(parameters[0].ParameterType)) { suitableConstructor = true; break; } } } if (!suitableConstructor) { throw new Exception("Read-only type {0} does not have a public constructor that takes a type that implements {1}.".FormatWith(CultureInfo.InvariantCulture, listType, genericEnumerable)); } // can't add or modify a readonly list // use List<T> and convert once populated list = (IList)CreateGenericList(readOnlyCollectionContentsType); isReadOnlyOrFixedSize = true; } else if (typeof(IList).IsAssignableFrom(listType)) { if (ReflectionUtils.IsInstantiatableType(listType)) { list = (IList)Activator.CreateInstance(listType); } else if (listType == typeof(IList)) { list = new List <object>(); } else { list = null; } } else if (listType.IsGenericType && listType.GetGenericTypeDefinition() == typeof(IList <>)) { list = CollectionUtils.CreateGenericList(ReflectionUtils.GetCollectionItemType(listType)); } else { list = null; } if (list == null) { throw new Exception("Cannot create and populate list type {0}.".FormatWith(CultureInfo.InvariantCulture, listType)); } populateList(list, isReadOnlyOrFixedSize); // create readonly and fixed sized collections using the temporary list if (isReadOnlyOrFixedSize) { if (listType.IsArray) { list = ToArray(((List <object>)list).ToArray(), ReflectionUtils.GetCollectionItemType(listType)); } else if (ReflectionUtils.InheritsGenericDefinition(listType, typeof(ReadOnlyCollection <>))) { list = (IList)ReflectionUtils.CreateInstance(listType, list); } } return(list); }