| private GetIndexParameters ( ) : System.Reflection.ParameterInfo[] | ||
| return | System.Reflection.ParameterInfo[] | |
/// <summary>
///
/// </summary>
/// <param name="property"></param>
/// <returns></returns>
public static string GetMemberID(PropertyInfo property)
{
string memberName;
memberName = "P:" + GetFullNamespaceName(property) +
"." + property.Name.Replace('.', '#').Replace('+', '#');
try
{
if (property.GetIndexParameters().Length > 0)
{
memberName += "(";
int i = 0;
foreach (ParameterInfo parameter in property.GetIndexParameters())
{
if (i > 0)
{
memberName += ",";
}
Type type = parameter.ParameterType;
#if NET_2_0
if (type.ContainsGenericParameters && type.IsGenericParameter)
{
memberName += "`" + type.GenericParameterPosition.ToString();
}
else if (type.FullName != null)
{
memberName += type.FullName;
}
else
{
memberName += type.Name;
}
#else
memberName += type.FullName;
#endif
++i;
}
memberName += ")";
}
}
catch (System.Security.SecurityException) { }
return memberName;
}
internal static InformationApi.PropertyInfo BuildPropInfo(System.Reflection.PropertyInfo f)
{
var fi = new InformationApi.PropertyInfo();
fi.Name = f.Name;
fi.Description = GetDescription(f);
fi.Type = f.PropertyType.Name;
fi.CanGet = f.CanRead;
fi.CanSet = f.CanWrite;
foreach (var pi in f.GetIndexParameters())
{
fi.Indizes.Add(BuildArgInfo(pi));
}
if (!f.PropertyType.IsSimpleType())
{
StructCollector.CollectType(f.PropertyType);
}
fi.ThrowsExceptionInfo = BuildExceptionInfo(f);
//ToDo: continue Funcinfo build!
return(fi);
}
public void PrintProperty(SysRef.PropertyInfo property)
{
if ((_flags & SignaturePrintingFlags.IgnoreMemberOwner) != SignaturePrintingFlags.IgnoreMemberOwner)
{
PrintType(property.DeclaringType);
_builder.Append("::");
}
PrintIdentifier(property.Name);
// Properties
{
var parameters = property.GetIndexParameters();
_builder.Append("(");
for (int i = 0; i < parameters.Length; i++)
{
if (i > 0)
{
_builder.Append(", ");
}
PrintType(parameters[i].ParameterType, false);
}
_builder.Append(")");
}
_builder.Append(" : ");
PrintType(property.PropertyType, false);
}
private static bool IsAValidProperty(PropertyInfo propertyInfo)
{
if (!propertyInfo.CanRead) return false;
if (!propertyInfo.CanWrite) return false;
if (propertyInfo.GetIndexParameters().Length > 0) return false;
return true;
}
/// <summary>
/// Check if the property is not null and can be read and is no indexed.
/// This is done to know if it can be read safely.
/// </summary>
/// <param name="obj">Obj.</param>
/// <param name="prop">Prop.</param>
/// <returns></returns>
private static bool PropertyHasValue(object obj, PropertyInfo prop)
{
if (obj == null || prop == null || !prop.CanRead || prop.GetIndexParameters().Length > 0)
return false;
else
return true;
}
internal static MethodInfo GetPropertySetter(PropertyInfo propertyInfo, Type type)
{
if (propertyInfo.DeclaringType == type) return propertyInfo.GetSetMethod(true);
#if NETSTANDARD1_3
return propertyInfo.DeclaringType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.Single(x => x.Name == propertyInfo.Name
&& x.PropertyType == propertyInfo.PropertyType
&& IsParameterMatch(x.GetIndexParameters(), propertyInfo.GetIndexParameters())
).GetSetMethod(true);
#else
return propertyInfo.DeclaringType.GetProperty(
propertyInfo.Name,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
Type.DefaultBinder,
propertyInfo.PropertyType,
propertyInfo.GetIndexParameters().Select(p => p.ParameterType).ToArray(),
null).GetSetMethod(true);
#endif
}
private static bool HasGetter(PropertyInfo prop)
{
if (!prop.CanRead)
return false;
if (!ArrayUtil.IsNullOrEmpty(prop.GetIndexParameters()))
return false;
return true;
}
public bool CanRead(ReflectedInstance value, Type type, PropertyInfo property)
{
// verify if property is "this[int i]", in real use is: "myList[0]', exclude array objects
// because if array is multidimensional will happen a error when call
// "property.GetValue(obj, new object[] { 0, 0 });" the class "PropertyReaderIndexerInArray" fix it.
var parameters = property.GetIndexParameters();
//
return (parameters.Length == 1)
&& (parameters[0].ParameterType == typeof(int));
}
public static string GetId(PropertyInfo property)
{
var parameters = string.Join(",", property.GetIndexParameters().Select(x => GetTypeName(x.ParameterType)));
if (!string.IsNullOrEmpty(parameters))
{
parameters = "(" + parameters + ")";
}
return string.Format(CultureInfo.InvariantCulture, "P:{0}.{1}{2}", GetTypeName(property.ReflectedType), HashEncode(property.Name), parameters);
}
public static string GetAssetId(PropertyInfo propertyInfo)
{
ParameterInfo[] p = propertyInfo.GetIndexParameters();
if (p.Length == 0)
return string.Format("P:{0}.{1}", GetTypeName(propertyInfo.ReflectedType), propertyInfo.Name);
return string.Format("P:{0}.{1}{2}",
GetTypeName(propertyInfo.ReflectedType),
propertyInfo.Name,
CreateParameterSignature(propertyInfo, p.Select(pr => pr.ParameterType).ToArray()));
}
internal static string ToSignature (PropertyInfo pi)
{
StringBuilder sb = new StringBuilder ();
sb.Append (ToSignature (pi.PropertyType));
sb.Append (" ");
sb.Append (ToSignature (pi.DeclaringType));
sb.Append (".");
sb.Append (pi.Name);
sb.Append (ToSignature ('[', pi.GetIndexParameters (), ']'));
return sb.ToString ();
}
private bool IsCandidateProperty(PropertyInfo property)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
return property.CanWrite &&
property.GetIndexParameters().Length == 0 &&
IsSupportedPropertyType(property.PropertyType);
}
public IEnumerable<MethodValue> GetValues(ReflectedInstance value, Type type, PropertyInfo property)
{
var dictionary = value.Object as IDictionary;
var parameters = property.GetIndexParameters();
foreach (var key in dictionary.Keys)
{
var parameter = new MethodValueParam(parameters[0].Name, parameters[0], key);
yield return new MethodValue(dictionary[key], parameter);
}
}
private static DependencyObject FindParent(Queue <string> queue, DependencyObject current)
{
string propertyName = queue.Dequeue();
object[] indexParameters = new object[0];
if (propertyName.Contains('['))
{
int start = propertyName.IndexOf('[');
int end = propertyName.IndexOf(']');
if (end != propertyName.Length - 1)
{
throw new InvalidOperationException(Resources.IndexedExpressionsMustBeClosed);
}
int length = (end - start) - 1;
indexParameters = propertyName.Substring(start + 1, length).Split(',').Cast <object>().ToArray();
propertyName = propertyName.Substring(0, start);
}
System.Reflection.PropertyInfo property = current.GetType().GetProperty(propertyName);
if (property == null)
{
throw new InvalidOperationException(string.Format(
Resources.PropertyNameDoesNotExist,
propertyName));
}
ParameterInfo[] parameters = property.GetIndexParameters();
if (parameters.Length != indexParameters.Length)
{
throw new InvalidOperationException(string.Format(
Resources.PropertyRequiresIndexArguments,
parameters.Length,
indexParameters.Length));
}
for (int x = 0; x < parameters.Length; x++)
{
indexParameters[x] = Convert.ChangeType(
indexParameters[x],
parameters[x].ParameterType,
CultureInfo.InvariantCulture);
}
DependencyObject parent = (DependencyObject)property.GetValue(current, (indexParameters.Length > 0 ? indexParameters : null));
if (queue.Count > 0)
{
parent = FindParent(queue, parent);
}
return(parent);
}
public override bool UseWhen()
{
_info = PropertyInfoHelper.GetIndexerPropertyInfo(TargetType, ColumnName);
if (_info == null)
return false;
var parameterType = _info.GetIndexParameters().First().ParameterType;
_lookUp = Convert.ChangeType(ColumnName, parameterType);
return true;
}
private static Type[] GetIndexerTypes(PropertyInfo property)
{
var indexerParameters = property.GetIndexParameters();
var result = new Type[indexerParameters.Length];
for (var i = 0; i < indexerParameters.Length; i++)
{
result[i] = indexerParameters[i].ParameterType;
}
return result;
}
public override Boolean Match(PropertyInfo sourceProperty, PropertyInfo targetProperty)
{
if (sourceProperty.Name == "Item")
{
var pp = sourceProperty.GetIndexParameters();
//source["key1"]
if (pp.Length == 1 && pp[0].ParameterType == typeof(String))
{
return true;
}
}
return false;
}
public static System.Func <TSource, TRet> CreateGetter <TSource, TRet>(System.Reflection.PropertyInfo propertyInfo, bool nonPublic)
{
if (propertyInfo == null)
{
throw new System.ArgumentNullException(nameof(propertyInfo));
}
if (propertyInfo.GetIndexParameters().Length > 0)
{
//throw new System.ArgumentException("Cannot create a dynamic getter for anindexed property.", "propertyInfo");
return(null);
}
if (typeof(TSource) != typeof(object) &&
!propertyInfo.DeclaringType.IsAssignableFrom(typeof(TSource)))
{
//throw new System.ArgumentException("The declaring type of the property is not assignable from the type of the instance.", "propertyInfo");
return(null);
}
if (!typeof(TRet).IsAssignableFrom(propertyInfo.PropertyType))
{
//throw new System.ArgumentException("The type of the return value is not assignable from the type of the property.", "propertyInfo");
return(null);
}
//the method call of the get accessor method fails in runtime
//if the declaring type of the property is an interface and TSource is a value type,
//in this case, we should find the property from TSource whose DeclaringType is TSource itself
if (typeof(TSource).GetTypeInfo().IsValueType&& propertyInfo.DeclaringType.GetTypeInfo().IsInterface)
{
propertyInfo = typeof(TSource).GetProperty(propertyInfo.Name);
}
var getMethod = propertyInfo.GetGetMethod(nonPublic);
if (getMethod == null)
{
//if (nonPublic)
//{
// throw new System.ArgumentException("The property does not have a get method.", "propertyInfo");
//}
//throw new System.ArgumentException("The property does not have a public get method.", "propertyInfo");
return(null);
}
return(EmitPropertyGetter <TSource, TRet>(propertyInfo, getMethod));
}
public static ExpressionTypeMemberDescriptor Build(PropertyInfo p)
{
ExpressionTypeMemberDescriptor md = new ExpressionTypeMemberDescriptor
{
Kind = "property",
Name = p.Name,
ReturnType = p.PropertyType.Name,
ReturnExpressionType = p.PropertyType.AssemblyQualifiedName
};
md.Parameters = (
from mdp in p.GetIndexParameters()
select Build(mdp)).ToList();
return md;
}
static StackObject *GetIndexParameters_10(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Reflection.PropertyInfo instance_of_this_method = (System.Reflection.PropertyInfo) typeof(System.Reflection.PropertyInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetIndexParameters();
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
public static System.Action <TTarget, TValue> CreateSetter <TTarget, TValue>(System.Reflection.PropertyInfo propertyInfo, bool nonPublic)
{
if (propertyInfo == null)
{
throw new System.ArgumentNullException(nameof(propertyInfo));
}
if (typeof(TTarget).GetTypeInfo().IsValueType)
{
//throw new System.ArgumentException("The type of the isntance should not be a value type. " + "For a value type, use System.Object instead.", "propertyInfo");
return(null);
}
if (propertyInfo.GetIndexParameters().Length > 0)
{
//throw new System.ArgumentException("Cannot create a dynamic setter for an indexed property.", "propertyInfo");
return(null);
}
if (typeof(TTarget) != typeof(object) &&
!propertyInfo.DeclaringType.IsAssignableFrom(typeof(TTarget)))
{
//throw new System.ArgumentException("The declaring type of the property is not assignable from the type of the isntance.", "propertyInfo");
return(null);
}
if (typeof(TValue) != typeof(object) &&
!propertyInfo.PropertyType.IsAssignableFrom(typeof(TValue)))
{
//throw new System.ArgumentException("The type of the property is not assignable from the type of the value.", "propertyInfo");
return(null);
}
var setMethod = propertyInfo.GetSetMethod(nonPublic);
if (setMethod == null)
{
//if (nonPublic)
//{
// throw new System.ArgumentException("The property does not have a set method.", "propertyInfo");
//}
//throw new System.ArgumentException("The property does not have a public set method.", "propertyInfo");
return(null);
}
return(EmitPropertySetter <TTarget, TValue>(propertyInfo, setMethod));
}
static bool CompareProperty(PropertyInfo expectedPropertyInfo, PropertyInfo actualPropertyInfo, object expected, object actual,
IComparisonContext comparisonContext, bool areEqual)
{
ParameterInfo[] indexes = expectedPropertyInfo.GetIndexParameters();
if (indexes.Length == 0)
{
areEqual = CompareStandardProperty(expectedPropertyInfo, actualPropertyInfo, expected, actual, comparisonContext) &&
areEqual;
}
else
{
areEqual = CompareIndexedProperty(expectedPropertyInfo, expected, actual, indexes, comparisonContext) && areEqual;
}
return areEqual;
}
internal CLSProperty(String name, Type type, MemberInfo[] properties,Boolean isStatic)
{
this.isStatic = isStatic;
this.type = type;
this.pi = (PropertyInfo)properties[0];
this.name = name;
for(int i=0;i<properties.Length;i++)
{
PropertyInfo pi = (PropertyInfo)properties[i];
ParameterInfo[] info = pi.GetIndexParameters();
if(info.Length > 0) //it's an indexed property - we don't support field-style access
{
throw new Exception("Field-style access for indexed property of: " + type.Name +
" not supported -" +
" use get_" + name + " and set_" + name + " functions instead");
}
}
}
public IEnumerable<MethodValue> GetValues(ReflectedInstance value, Type type, PropertyInfo property)
{
//var converted = obj as System.Collections.ICollection;
//var len = converted.Count;
var parameters = property.GetIndexParameters();
var len = 0;
if (!ReflectionUtils.TryGetPropertyValue<int>(value.Object, "Count", out len))
if (!ReflectionUtils.TryGetPropertyValue<int>(value.Object, "Length", out len))
throw new Exception("It could not find the size of the indexed property '" + property.Name + "' to iterate.");
for (int i = 0; i < len; i++)
{
var propValue = property.GetValue(value.Object, new object[] { i });
var parameter = new MethodValueParam(parameters[0].Name, parameters[0], i);
yield return new MethodValue(propValue, parameter);
}
}
public static PropertyInfo LocateMatchingProperty(PropertyInfo property, Type inType)
{
var indexParameters = property.GetIndexParameters();
var indexParameterTypes = new Type[indexParameters.Length];
for (var i = 0; i < indexParameters.Length; i++)
{
indexParameterTypes[i] = indexParameters[i].ParameterType;
}
return inType.GetProperty(
property.Name,
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance,
null,
property.PropertyType,
indexParameterTypes,
null);
}
private static void WriteObject(System.Text.StringBuilder sb, object o)
{
System.Reflection.MemberInfo[] members = o.GetType().GetMembers(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
sb.Append("{");
bool flag = false;
System.Reflection.MemberInfo[] array = members;
for (int i = 0; i < array.Length; i++)
{
System.Reflection.MemberInfo memberInfo = array[i];
bool flag2 = false;
object val = null;
if ((memberInfo.MemberType & System.Reflection.MemberTypes.Field) == System.Reflection.MemberTypes.Field)
{
System.Reflection.FieldInfo fieldInfo = (System.Reflection.FieldInfo)memberInfo;
val = fieldInfo.GetValue(o);
flag2 = true;
}
else if ((memberInfo.MemberType & System.Reflection.MemberTypes.Property) == System.Reflection.MemberTypes.Property)
{
System.Reflection.PropertyInfo propertyInfo = (System.Reflection.PropertyInfo)memberInfo;
if (propertyInfo.CanRead && propertyInfo.GetIndexParameters().Length == 0)
{
val = propertyInfo.GetValue(o, null);
flag2 = true;
}
}
if (flag2)
{
sb.Append("\"");
sb.Append(memberInfo.Name);
sb.Append("\":");
JSONConverter.WriteValue(sb, val);
sb.Append(",");
flag = true;
}
}
if (flag)
{
sb.Length--;
}
sb.Append("}");
}
public PropertyMapInfo(PropertyInfo propertyInfo)
{
this.Name = propertyInfo.Name;
this.PropertyInfo = propertyInfo;
this.PropertyType = propertyInfo.PropertyType;
this.IsNullableT = propertyInfo.PropertyType.IsInheritanceFrom(typeof(Nullable<>));
this.IsIndexedProperty = propertyInfo.GetIndexParameters().Length > 0;
if (this.IsNullableT == true)
{
this.ActualType = propertyInfo.PropertyType.GenericTypeArguments[0];
this.CanBeNull = true;
}
else
{
this.ActualType = propertyInfo.PropertyType;
this.CanBeNull = this.ActualType.IsValueType == false;
}
}
internal PropertyMetadata(PropertyInfo info)
{
PropertyInfo = info;
#if !DataAnnotations_Missing
Validators = ImmutableArray.CreateRange(info.GetCustomAttributes(typeof(ValidationAttribute), true).OfType<ValidationAttribute>());
#endif
IsIndexed = info.GetIndexParameters().Length > 0;
m_GetMethod = PropertyInfo.GetMethod;
m_SetMethod = PropertyInfo.SetMethod;
PropertyType = info.PropertyType;
var name = info.ToString();
Name = name.Substring(name.IndexOf(" ", StringComparison.Ordinal) + 1);
if (IsIndexed)
PropertyChangedEventArgs = new PropertyChangedEventArgs(info.Name + "[]");
else
PropertyChangedEventArgs = new PropertyChangedEventArgs(info.Name);
#if !DataAnnotations_Missing
IsKey = info.GetCustomAttributes(typeof(KeyAttribute), true).Any();
var doNotMap = info.GetCustomAttributes(typeof(NotMappedAttribute), true).Any();
if (!doNotMap)
{
var column = (ColumnAttribute)info.GetCustomAttributes(typeof(ColumnAttribute), true).SingleOrDefault();
MappedColumnName = column != null ? column.Name : Name;
}
var decomposeAttribute = (DecomposeAttribute)(info.GetCustomAttributes(typeof(DecomposeAttribute), true).FirstOrDefault());
if (decomposeAttribute != null)
{
Decompose = true;
DecompositionPrefix = decomposeAttribute.Prefix;
}
IgnoreOnInsert = info.GetCustomAttributes(typeof(IgnoreOnInsertAttribute), true).Any();
IgnoreOnUpdate = info.GetCustomAttributes(typeof(IgnoreOnUpdateAttribute), true).Any();
#endif
}
private bool UseWhenProperty(string firstColumnName)
{
_info = PropertyInfoHelper.GetCaseInsensitivePropertyInfo(
TargetType, firstColumnName);
if (_info != null)
return true;
_info = PropertyInfoHelper.GetIndexerPropertyInfo(
TargetType, firstColumnName);
if (_info == null)
return false;
_isIndexer = true;
var parameterType = _info.GetIndexParameters().First().ParameterType;
_lookUp = Convert.ChangeType(firstColumnName, parameterType);
return true;
}
private string GeneratePropertyCaption(PropertyInfo pi)
{
ParameterInfo[] indexParameters = pi.GetIndexParameters();
if ((indexParameters == null) || (indexParameters.Length == 0))
{
return pi.Name;
}
StringBuilder builder = new StringBuilder(0x100);
builder.Append(pi.Name);
builder.Append('[');
for (int i = 0; i < indexParameters.Length; i++)
{
if (i != 0)
{
builder.Append(", ");
}
builder.Append(indexParameters[i].ParameterType.Name);
}
builder.Append(']');
return builder.ToString();
}
public Indexer(Class declaringType, SR.PropertyInfo tinfo)
{
this.declaringType = declaringType;
ModifierEnum mod = (ModifierEnum)0;
modifiers = mod;
this.FullyQualifiedName = tinfo.Name;
returnType = new ReturnType(tinfo.PropertyType);
this.region = Class.GetRegion();
this.bodyRegion = Class.GetRegion();
LoadXml(declaringType);
// Add parameters
foreach (SR.ParameterInfo pinfo in tinfo.GetIndexParameters())
{
parameters.Add(new Parameter(this, pinfo, node));
}
}
public IEnumerable<MethodValue> GetValues(ReflectedInstance value, Type type, PropertyInfo property)
{
var converted = value.Object as Son;
var len = converted.List.Count;
var parameters = property.GetIndexParameters();
// this[int index]
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(int))
{
for (int i = 0; i < len; i++)
{
var propValue = property.GetValue(value.Object, new object[] { i });
var parameter = new MethodValueParam(parameters[0].Name, parameters[0], i);
yield return new MethodValue(propValue, parameter);
}
}
// this[int index, int index2]
if (parameters.Length == 2 && parameters[0].ParameterType == typeof(int) && parameters[1].ParameterType == typeof(int))
{
for (int i = 0; i < len; i++)
{
var propValue = property.GetValue(value.Object, new object[] { i, 0 });
var parameter1 = new MethodValueParam(parameters[0].Name, parameters[0], i);
var parameter2 = new MethodValueParam(parameters[1].Name, parameters[1], 0);
yield return new MethodValue(propValue, parameter1, parameter2);
}
}
// this[string contains]
if (parameters.Length == 1 && parameters[0].ParameterType == typeof(string))
{
for (int i = 0; i < len; i++)
{
var propValue = property.GetValue(value.Object, new object[] { "list " + i });
var parameter1 = new MethodValueParam(parameters[0].Name, parameters[0], "list " + i);
yield return new MethodValue(propValue, parameter1);
}
}
}
public static bool IsDerivedFrom(this PropertyInfo a_pi, PropertyInfo a_base,
bool a_with_this = false)
{
if (a_pi.Name != a_base.Name)
return false;
if (a_pi.PropertyType != a_base.PropertyType)
return false;
if (!a_pi.GetIndexParameters().Select(p => p.ParameterType).SequenceEqual(
a_base.GetIndexParameters().Select(p => p.ParameterType)))
{
return false;
}
if (a_pi.DeclaringType == a_base.DeclaringType)
return a_with_this;
MethodInfo m1 = a_pi.GetGetMethod(true);
MethodInfo m3 = a_base.GetGetMethod(true);
if ((m1 != null) && (m3 != null))
{
if (m1.GetBaseDefinitions().ContainsAny(m3.GetBaseDefinitions(true)))
return true;
}
else if ((m1 != null) || (m3 != null))
return false;
MethodInfo m2 = a_pi.GetSetMethod(true);
MethodInfo m4 = a_base.GetSetMethod(true);
if ((m2 != null) && (m4 != null))
{
if (m2.GetBaseDefinitions().ContainsAny(m4.GetBaseDefinitions(true)))
return true;
}
else if ((m2 != null) || (m4 != null))
return false;
return false;
}
Property LoadProperty(System.Reflection.PropertyInfo refProperty)
{
bool isStatic =
(refProperty.CanRead && refProperty.GetGetMethod().IsStatic) ||
(refProperty.CanRead && refProperty.GetGetMethod().IsStatic);
System.Reflection.MethodInfo getMethod =
(refProperty.CanRead ? refProperty.GetGetMethod(false) : null);
System.Reflection.MethodInfo setMethod =
(refProperty.CanWrite ? refProperty.GetSetMethod(false) : null);
Property property = new Property
{
Name = refProperty.Name,
IsStatic = isStatic,
PropertyType = GetTypeFullName(refProperty.PropertyType),
GetMethod = (getMethod != null ? LoadMethod(getMethod) : null),
SetMethod = (setMethod != null ? LoadMethod(setMethod) : null),
Attributes = refProperty.Attributes,
};
property.IndexParameters = refProperty.GetIndexParameters().Select(p => LoadParameter(p)).ToList();
return(property);
}
/////////////////////////////////////////////////////////////////////////////////
private PropertySymbol AddPropertyToSymbolTable(PropertyInfo property, AggregateSymbol aggregate)
{
Name name;
bool isIndexer = property.GetIndexParameters() != null && property.GetIndexParameters().Length != 0;
if (isIndexer)
{
name = GetName(SpecialNames.Indexer);
}
else
{
name = GetName(property.Name);
}
PropertySymbol prop = _symbolTable.LookupSym(
name,
aggregate,
symbmask_t.MASK_PropertySymbol) as PropertySymbol;
// If we already had one, see if it matches.
if (prop != null)
{
PropertySymbol prevProp = null;
// We'll have multiple properties with the same name if we have indexers.
// In that case, we need to look at every indexer to see if we find one with
// the matching associated sym that we want.
while (prop != null)
{
if (prop.AssociatedPropertyInfo.IsEquivalentTo(property))
{
return prop;
}
prevProp = prop;
prop = _semanticChecker.SymbolLoader.LookupNextSym(prop, prop.parent, symbmask_t.MASK_PropertySymbol).AsPropertySymbol();
}
prop = prevProp;
if (isIndexer)
{
// We have an indexer for a different property info, so
// create a new symbol for it.
prop = null;
}
}
// If we already had a property but its associated info doesn't match,
// then we repurpose the property that we've found. This can happen
// in the case of generic instantiations.
//
// Note that this is a bit of a hack - the best way to fix this is
// by not depending on the instantiated properties at all, but rather depending
// on their non-instantiated generic form, which can be gotten from the
// parent's generic type definition's member. From there, we'll also need to
// keep track of the instantiation as we move along, so that when we need the
// associated property, we can instantiate it correctly.
//
// This seems far too heavyweight - since we know we will never bind to more
// than one property per payload, lets just blast it each time.
if (prop == null)
{
if (isIndexer)
{
prop = _semanticChecker.GetSymbolLoader().GetGlobalMiscSymFactory().CreateIndexer(name, aggregate, GetName(property.Name), null);
prop.Params = CreateParameterArray(null, property.GetIndexParameters());
}
else
{
prop = _symFactory.CreateProperty(GetName(property.Name), aggregate, null);
prop.Params = BSYMMGR.EmptyTypeArray();
}
}
prop.AssociatedPropertyInfo = property;
prop.isStatic = property.GetGetMethod(true) != null ? property.GetGetMethod(true).IsStatic : property.GetSetMethod(true).IsStatic;
prop.isParamArray = DoesMethodHaveParameterArray(property.GetIndexParameters());
prop.swtSlot = null;
prop.RetType = GetCTypeFromType(property.PropertyType);
prop.isOperator = isIndexer;
// Determine if its an override. We should always have an accessor, unless
// the metadata was bogus.
if (property.GetMethod != null || property.SetMethod != null)
{
MethodInfo accessor = property.GetMethod ?? property.SetMethod; // Must have at least one.
prop.isOverride = accessor.IsVirtual && accessor.IsHideBySig && accessor.GetRuntimeBaseDefinition() != accessor;
prop.isHideByName = !accessor.IsHideBySig;
}
SetParameterDataForMethProp(prop, property.GetIndexParameters());
// Get and set.
MethodInfo methGet = property.GetMethod;
MethodInfo methSet = property.SetMethod;
ACCESS access = ACCESS.ACC_PRIVATE;
if (methGet != null)
{
prop.methGet = AddMethodToSymbolTable(methGet, aggregate, MethodKindEnum.PropAccessor);
// If we have an indexed property, leave the method as a method we can call,
// and mark the property as bogus.
if (isIndexer || prop.methGet.Params.size == 0)
{
prop.methGet.SetProperty(prop);
}
else
{
prop.setBogus(true);
prop.methGet.SetMethKind(MethodKindEnum.Actual);
}
if (prop.methGet.GetAccess() > access)
{
access = prop.methGet.GetAccess();
}
}
if (methSet != null)
{
prop.methSet = AddMethodToSymbolTable(methSet, aggregate, MethodKindEnum.PropAccessor);
// If we have an indexed property, leave the method as a method we can call,
// and mark the property as bogus.
if (isIndexer || prop.methSet.Params.size == 1)
{
prop.methSet.SetProperty(prop);
}
else
{
prop.setBogus(true);
prop.methSet.SetMethKind(MethodKindEnum.Actual);
}
if (prop.methSet.GetAccess() > access)
{
access = prop.methSet.GetAccess();
}
}
// The access of the property is the least restrictive access of its getter/setter.
prop.SetAccess(access);
return prop;
}
private ProtoCore.AST.AssociativeAST.AssociativeNode ParseProperty(PropertyInfo p)
{
if (null == p || SupressesImport(p))
return null;
//Index properties are not parsed as property at this moment.
ParameterInfo[] indexParams = p.GetIndexParameters();
if (null != indexParams && indexParams.Length > 0)
return null;
MethodInfo m = p.GetAccessors(false)[0];
//If this method hides the base class accessor method by signature
if (m.IsHideBySig)
{
//Check if it has a base class
Type baseType = p.DeclaringType.BaseType;
PropertyInfo baseProp = (baseType != null) ? GetProperty(ref baseType, p.Name) : null;
//If this property is also declared in base class, then no need to add this is derived class.
if(null != baseProp && baseProp.DeclaringType != p.DeclaringType)
{
//base class also has this method.
return null;
}
}
ProtoCore.AST.AssociativeAST.VarDeclNode varDeclNode = ParseArgumentDeclaration(p.Name, p.PropertyType);
if(null != varDeclNode)
varDeclNode.IsStatic = m.IsStatic;
return varDeclNode;
}
void OutlineProperty (PropertyInfo pi)
{
ParameterInfo [] idxp = pi.GetIndexParameters ();
MethodBase g = pi.GetGetMethod (true);
MethodBase s = pi.GetSetMethod (true);
MethodBase accessor = g != null ? g : s;
if (pi.CanRead && pi.CanWrite) {
// Get the more accessible accessor
if ((g.Attributes & MethodAttributes.MemberAccessMask) !=
(s.Attributes & MethodAttributes.MemberAccessMask)) {
if (g.IsPublic) accessor = g;
else if (s.IsPublic) accessor = s;
else if (g.IsFamilyOrAssembly) accessor = g;
else if (s.IsFamilyOrAssembly) accessor = s;
else if (g.IsAssembly || g.IsFamily) accessor = g;
else if (s.IsAssembly || s.IsFamily) accessor = s;
}
}
o.Write (GetMethodVisibility (accessor));
o.Write (GetMethodModifiers (accessor));
o.Write (FormatType (pi.PropertyType));
o.Write (" ");
if (idxp.Length == 0)
o.Write (pi.Name);
else {
o.Write ("this [");
OutlineParams (idxp);
o.Write ("]");
}
o.WriteLine (" {");
o.Indent ++;
if (g != null && ShowMember (g)) {
if ((g.Attributes & MethodAttributes.MemberAccessMask) !=
(accessor.Attributes & MethodAttributes.MemberAccessMask))
o.Write (GetMethodVisibility (g));
o.WriteLine ("get;");
}
if (s != null && ShowMember (s)) {
if ((s.Attributes & MethodAttributes.MemberAccessMask) !=
(accessor.Attributes & MethodAttributes.MemberAccessMask))
o.Write (GetMethodVisibility (s));
o.WriteLine ("set;");
}
o.Indent --;
o.Write ("}");
}
public static bool IsIndexer(this System.Reflection.PropertyInfo propertyInfo)
{
return(propertyInfo.GetIndexParameters().Length > 0);
}
//Deep copy with reflection
public static object Copy(this object obj)
{
Object targetDeepCopyObj;
Type targetType = obj.GetType();
//if value type, return directly
if (targetType.IsValueType == true)
{
targetDeepCopyObj = obj;
}
//ref type
else
{
targetDeepCopyObj = System.Activator.CreateInstance(targetType); //new instance
System.Reflection.MemberInfo[] memberCollection = obj.GetType().GetMembers();
foreach (System.Reflection.MemberInfo member in memberCollection)
{
if (member.MemberType == System.Reflection.MemberTypes.Field)
{
System.Reflection.FieldInfo field = (System.Reflection.FieldInfo)member;
Object fieldValue = field.GetValue(obj);
if (fieldValue is ICloneable)
{
field.SetValue(targetDeepCopyObj, (fieldValue as ICloneable).Clone());
}
else
{
field.SetValue(targetDeepCopyObj, Copy(fieldValue));
}
}
else if (member.MemberType == System.Reflection.MemberTypes.Property)
{
System.Reflection.PropertyInfo myProperty = (System.Reflection.PropertyInfo)member;
MethodInfo info = myProperty.GetSetMethod(false);
if (info != null)
{
object propertyValue;
int noOfParameters = myProperty.GetIndexParameters().Count();
//if (noOfParameters == 0)
//{
//Non-Indexed PROPERTY
propertyValue = myProperty.GetValue(obj, null);
//}
//else
//{
//Indexed PROPERTY
//object[] indexArgs = new object[((IList)myProperty).Count];
//for (int i = 0; i < ((IList)myProperty).Count; i++)
//{
// indexArgs[i] = i;
//}
// propertyValue = myProperty.GetValue(obj, new object[] { 0});
//}
if (propertyValue is ICloneable)
{
myProperty.SetValue(targetDeepCopyObj, (propertyValue as ICloneable).Clone(), null);
}
else
{
myProperty.SetValue(targetDeepCopyObj, Copy(propertyValue), null);
}
}
}
}
}
return(targetDeepCopyObj);
}
static private void AppendPropertyInfo(PropertyInfo property, StringBuilder sb)
{
sb.Append(".property ");
foreach (var attribute in property.GetCustomAttributesData())
{
AppendCustomAttributeData(attribute, sb);
sb.Append(" ");
}
foreach (var modreq in property.GetRequiredCustomModifiers())
{
sb.Append("modreq(");
AppendType(modreq, sb);
sb.Append(") ");
}
foreach (var modopt in property.GetOptionalCustomModifiers())
{
sb.Append("modopt(");
AppendType(modopt, sb);
sb.Append(") ");
}
if (property.CanRead && property.CanWrite)
{
sb.Append("readwrite ");
}
else if (property.CanRead)
{
sb.Append("readonly ");
}
else if (property.CanWrite)
{
sb.Append("writeonly ");
}
if (property.Attributes.HasFlag(PropertyAttributes.SpecialName)) sb.Append("specialname ");
if (property.Attributes.HasFlag(PropertyAttributes.RTSpecialName)) sb.Append("rtspecialname ");
var propertyAccesors = property.GetAccessors();
if (propertyAccesors.Length > 0)
{
sb.Append(propertyAccesors[0].IsStatic ? "static " : "instance ");
}
AppendType(property.PropertyType, sb);
sb.Append(" ");
sb.Append(property.Name);
var indexParameters = property.GetIndexParameters();
if (indexParameters.Length > 0)
{
sb.Append("(");
foreach (var indexParameter in indexParameters)
{
AppendParameterInfo(indexParameter, sb);
AppendComma(sb);
}
RemoveTrailingComma(sb);
sb.Append(")");
}
}
private bool IsValidIndexer(PropertyInfo info, string breadCrumb)
{
ParameterInfo[] indexers = info.GetIndexParameters();
if (indexers.Length == 0)
{
return false;
}
if (indexers.Length > 1)
{
throw new Exception("Cannot compare objects with more than one indexer for object " + breadCrumb);
}
if (indexers[0].ParameterType != typeof(Int32))
{
throw new Exception("Cannot compare objects with a non integer indexer for object " + breadCrumb);
}
if (info.ReflectedType.GetProperty("Count") == null)
{
throw new Exception("Indexer must have a corresponding Count property for object " + breadCrumb);
}
if (info.ReflectedType.GetProperty("Count").PropertyType != typeof(Int32))
{
throw new Exception("Indexer must have a corresponding Count property that is an integer for object " + breadCrumb);
}
return true;
}
public override PropertyInfo SelectProperty(BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers)
{
if (match == null || match.Length == 0)
{
throw new ArgumentException("No properties provided", "match");
}
bool flag = returnType != null;
int num = (indexes == null) ? -1 : indexes.Length;
PropertyInfo propertyInfo = null;
int num2 = 2147483646;
int num3 = int.MaxValue;
int num4 = 0;
for (int i = match.Length - 1; i >= 0; i--)
{
PropertyInfo propertyInfo2 = match[i];
ParameterInfo[] indexParameters = propertyInfo2.GetIndexParameters();
if (num < 0 || num == indexParameters.Length)
{
if (!flag || propertyInfo2.PropertyType == returnType)
{
int num5 = 2147483646;
if (num > 0)
{
num5 = Binder.Default.check_arguments_with_score(indexes, indexParameters);
if (num5 == -1)
{
goto IL_10E;
}
}
int derivedLevel = Binder.GetDerivedLevel(propertyInfo2.DeclaringType);
if (propertyInfo != null)
{
if (num2 < num5)
{
goto IL_10E;
}
if (num2 == num5)
{
if (num4 == derivedLevel)
{
num3 = num5;
goto IL_10E;
}
if (num4 > derivedLevel)
{
goto IL_10E;
}
}
}
propertyInfo = propertyInfo2;
num2 = num5;
num4 = derivedLevel;
}
}
IL_10E :;
}
if (num3 <= num2)
{
throw new AmbiguousMatchException();
}
return(propertyInfo);
}
public override PropertyInfo SelectProperty(BindingFlags bindingAttr, PropertyInfo[] match, Type returnType, Type[] indexes, ParameterModifier[] modifiers)
{
if (match == null || match.Length == 0)
{
throw new ArgumentException("No properties provided", "match");
}
bool haveRet = (returnType != null);
int idxlen = (indexes != null) ? indexes.Length : -1;
PropertyInfo result = null;
int i;
int best_score = Int32.MaxValue - 1;
int fail_score = Int32.MaxValue;
int level = 0;
for (i = match.Length - 1; i >= 0; i--)
{
PropertyInfo p = match [i];
ParameterInfo[] args = p.GetIndexParameters();
if (idxlen >= 0 && idxlen != args.Length)
{
continue;
}
if (haveRet && !check_type(p.PropertyType, returnType))
{
continue;
}
int score = Int32.MaxValue - 1;
if (idxlen > 0)
{
score = check_arguments_with_score(indexes, args);
if (score == -1)
{
continue;
}
}
int new_level = GetDerivedLevel(p.DeclaringType);
if (result != null)
{
if (best_score < score)
{
continue;
}
if (best_score == score)
{
if (level == new_level)
{
// Keep searching. May be there's something
// better for us.
fail_score = score;
continue;
}
if (level > new_level)
{
continue;
}
}
}
result = p;
best_score = score;
level = new_level;
}
if (fail_score <= best_score)
{
throw new AmbiguousMatchException();
}
return(result);
}
public static bool IsCandidateProperty(this PropertyInfo propertyInfo, bool needsWrite = true) => !propertyInfo.IsStatic() && (propertyInfo.GetIndexParameters().Length == 0) && propertyInfo.CanRead && (!needsWrite || propertyInfo.CanWrite) && (propertyInfo.GetMethod != null && propertyInfo.GetMethod.IsPublic);
public static bool IsCandidateProperty(this PropertyInfo propertyInfo, bool needsWrite = true, bool publicOnly = true) => !propertyInfo.IsStatic() && propertyInfo.GetIndexParameters().Length == 0 && propertyInfo.CanRead && (!needsWrite || propertyInfo.FindSetterProperty() != null) && propertyInfo.GetMethod != null && (!publicOnly || propertyInfo.GetMethod.IsPublic);
public void toJSON(System.Text.StringBuilder sb, object obj, string format)
{
if (obj == null)
{
sb.Append("null"); return;
}
#region Base
if (obj == null || obj == System.DBNull.Value)
{
sb.Append("null");
return;
}
if (obj is double || obj is float || obj is long || obj is int || obj is short || obj is byte || obj is decimal)
{
sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture.NumberFormat, "{0}", obj);
return;
}
if (obj.GetType().IsEnum)
{
sb.Append((int)obj);
return;
}
if (obj is bool)
{
sb.Append(obj.ToString().ToLower());
return;
}
if (obj is string || obj is Guid)
{
System.Text.StringBuilder sbtemp = new System.Text.StringBuilder();
if (obj is Guid && obj != null)
{
obj = obj.ToString();
}
sbtemp.Append("\"");
string s = obj as string;
if (s == null)
{
sbtemp.Append("\"");
sb.Append(sbtemp.ToString());
return;
}
foreach (char c in s)
{
switch (c)
{
case '\"':
sbtemp.Append("\\\"");
break;
case '\\':
sbtemp.Append("\\\\");
break;
case '\b':
sbtemp.Append("\\b");
break;
case '\f':
sbtemp.Append("\\f");
break;
case '\n':
sbtemp.Append("\\n");
break;
case '\r':
sbtemp.Append("\\r");
break;
case '\t':
sbtemp.Append("\\t");
break;
default:
int i = (int)c;
if (i < 32 || i > 127)
{
sbtemp.Append(c);
// sbtemp.AppendFormat("\\u{0:X04}", i);
}
else
{
sbtemp.Append(c);
}
break;
}
}
sbtemp.Append("\"");
sb.Append(sbtemp.ToString());
return;
}
if (obj is DateTime)
{
sb.Append("\"");
sb.Append(((DateTime)obj).ToString("yyyy-MM-dd HH:mm:ss"));
sb.Append("\"");
/*
* //en-US
* SB.Append("new Date(\"");
* DateTime TDateTime = (DateTime)Obj;
*
* TDateTime = TDateTime.ToLocalTime();
*
* SB.Append(TDateTime.ToString("MMMM, d yyyy HH:mm:ss", new System.Globalization.CultureInfo("en-US", false).DateTimeFormat));
* SB.Append("\")");
*/
return;
}
#endregion Base
#region JsonBase
if (obj is JsonNumber)
{
sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture.NumberFormat, "{0}", obj);
return;
}
if (obj is JsonBoolean)
{
sb.Append(((JsonBoolean)obj).Value.ToLower());
return;
}
if (obj is JsonString)
{
toJSON(sb, obj + "", format);
return;
}
if (obj is JsonDate)
{
toJSON(sb, ((JsonDate)obj).getDate(), format);
return;
}
#endregion JsonBase
#region System.Data
if (obj is System.Data.DataSet)
{
System.Data.DataSet DS = obj as System.Data.DataSet;
sb.Append("{\"Tables\":{");
foreach (System.Data.DataTable DT in DS.Tables)
{
sb.AppendFormat("\"{0}\":", DT.TableName);
toJSON(sb, DT, format);
sb.Append(",");
}
// Remove the trailing comma.
if (DS.Tables.Count > 0)
{
--sb.Length;
}
sb.Append("}}");
return;
}
if (obj is System.Data.DataTable)
{
sb.Append("{\"Rows\":[");
System.Data.DataTable DT = obj as System.Data.DataTable;
foreach (System.Data.DataRow DR in DT.Rows)
{
toJSON(sb, DR, format);
sb.Append(",");
}
// Remove the trailing comma.
if (DT.Rows.Count > 0)
{
--sb.Length;
}
sb.Append("]}");
return;
}
if (obj is System.Data.DataRow)
{
sb.Append("{");
System.Data.DataRow DR = obj as System.Data.DataRow;
foreach (System.Data.DataColumn Column in DR.Table.Columns)
{
sb.AppendFormat("\"{0}\":", Column.ColumnName);
toJSON(sb, DR[Column], format);
sb.Append(",");
}
// Remove the trailing comma.
if (DR.Table.Columns.Count > 0)
{
--sb.Length;
}
sb.Append("}");
return;
}
#endregion System.Data
#region Item Check
System.Reflection.PropertyInfo PI = obj.GetType().GetProperty("Item");
#region Object
if (PI != null && obj.GetType().GetProperty("Keys") != null)
{
System.Reflection.PropertyInfo PIK = obj.GetType().GetProperty("Keys");
object okeys = PIK.GetValue(obj, null);
string[] skeys = null;
if (okeys is string[])
{
skeys = (string[])okeys;
}
if (skeys == null)
{
System.Reflection.MethodInfo MH = okeys.GetType().GetMethod("CopyTo");
System.Reflection.PropertyInfo PIC = okeys.GetType().GetProperty("Count");
int count = 0;
if (PIC != null)
{
count = (int)PIC.GetValue(okeys, null);
}
if (count > 0 && MH != null && MH.GetParameters().Length > 0 && MH.GetParameters()[0].ParameterType == typeof(System.Array))
{
System.Array akeys = System.Array.CreateInstance(typeof(object), count);
MH.Invoke(okeys, new object[] { akeys, 0 });
skeys = new string[count];
int i = 0;
foreach (object key in akeys)
{
if (!(key is string))
{
continue;
}
if (key + "" == "")
{
continue;
}
skeys[i] = key + "";
i++;
}
}
else if (count > 0 && MH != null && MH.GetParameters().Length > 0 && MH.GetParameters()[0].ParameterType == typeof(string[]))
{
skeys = new string[count];
MH.Invoke(okeys, new object[] { skeys, 0 });
}
}
//if (skeys != null && skeys.Length > 0){
sb.Append("{");
int c = 0;
for (int i = 0; skeys != null && i < skeys.Length; i++)
{
string key = skeys[i]; if (key == null)
{
continue;
}
if (c != 0)
{
sb.Append(",");
}
sb.Append("\"" + key + "\":");
toJSON(sb, PI.GetValue(obj, new object[] { key }), format);
c++;
}
sb.Append("}");
//}
return;
}
#endregion Object
else if (PI != null && (obj.GetType().GetProperty("Count") != null || obj.GetType().GetProperty("Length") != null) && PI.GetIndexParameters().Length > 0 && PI.GetIndexParameters()[0].ParameterType == typeof(int))
{
int c = 0;
if (c == 0 && obj.GetType().GetProperty("Count").GetValue(obj, null) != null)
{
c = (int)obj.GetType().GetProperty("Count").GetValue(obj, null);
}
else if (c == 0 && obj.GetType().GetProperty("Length").GetValue(obj, null) != null)
{
c = (int)obj.GetType().GetProperty("Length").GetValue(obj, null);
}
//if (c > 0){
sb.Append("[");
for (int i = 0; i < c; i++)
{
if (i != 0)
{
sb.Append(",");
}
toJSON(sb, PI.GetValue(obj, new object[] { i }), format);
}
sb.Append("]");
// }
return;
}
#endregion Item Check
#region Array
if (obj.GetType().GetProperty("Length") != null && obj.GetType().GetMethod("GetValue", new Type[] { typeof(int) }) != null)
{
int l = (int)obj.GetType().GetProperty("Length").GetValue(obj, null);
//if (l > 0){
sb.Append("[");
for (int i = 0; i < l; i++)
{
if (i != 0)
{
sb.Append(",");
}
toJSON(sb, obj.GetType().GetMethod("GetValue", new Type[] { typeof(int) }).Invoke(obj, new object[] { i }), format);
}
sb.Append("]");
// }
return;
}
#endregion Array
#region other
if (obj is System.Collections.IEnumerable)
{
bool hasItems = false;
System.Collections.IEnumerable e = obj as System.Collections.IEnumerable;
sb.Append("[");
foreach (object val in e)
{
toJSON(sb, val, format);
sb.Append(",");
hasItems = true;
}
// Remove the trailing comma.
if (hasItems)
{
--sb.Length;
}
sb.Append("]");
return;
}
#endregion other
sb.Append("\"" + obj.GetType().FullName + "\"");
}
