Use example:
PropertyReflector pr = new PropertyReflector();
var anon = new { Colors = new Dictionary() { {100, Color.Red}, {200, Color.Blue} }, SelectedColor = 100};
object o1 = pr.GetValue(anon, “Colors[0].Key”);
object o2 = pr.GetValue(anon, “Colors[1].Value”);
object o3 = pr.GetValue(anon, “SelectedColor”);

The Code:
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;

// Original from: http://blog.guymahieu.com/wp-content/uploads/2007/02/propertyreflector.cs
// Modified to allow IList & IEnumerable for indexed access (ie: MyCollection[1].Name)

namespace Core
{
public class PropertyReflector
{
private const char PropertyNameSeparator = ‘.’;

private static readonly object[] NoParams = new object[0];
private static readonly Type[] NoTypeParams = new Type[0];
private static readonly Regex RegExIndex = new Regex(@”\[(?'index'\d+)\]“);

private IDictionary propertyCache = new Dictionary();
private IDictionary constructorCache = new Dictionary();

public Type GetType(Type targetType, string propertyName)
{
if (propertyName.IndexOf(PropertyNameSeparator) > -1)
{
string[] propertyList = propertyName.Split(PropertyNameSeparator);
for (int i = 0; i -1)
{
string[] propertyList = propertyName.Split(PropertyNameSeparator);
for (int i = 0; i -1)
{
object originalTarget = target;
string[] propertyList = propertyName.Split(PropertyNameSeparator);
for (int i = 0; i < propertyList.Length - 1; i++)
{
propertyName = propertyList[i];
target = GetValueImpl(target, propertyName);
if (target == null)
{
string currentFullPropertyNameString = GetPropertyNameString(propertyList, i);
target = Construct(GetType(originalTarget.GetType(), currentFullPropertyNameString));
SetValue(originalTarget, currentFullPropertyNameString, target);
}
}
propertyName = propertyList[propertyList.Length - 1];
}
SetValueImpl(target, propertyName, value);
}

private static string GetPropertyNameString(string[] propertyList, int level)
{
StringBuilder currentFullPropertyName = new StringBuilder();
for (int j = 0; j 0)
{
currentFullPropertyName.Append(PropertyNameSeparator);
}
currentFullPropertyName.Append(propertyList[j]);
}
return currentFullPropertyName.ToString();
}

private Type GetTypeImpl(Type targetType, string propertyName)
{
return GetPropertyInfo(targetType, propertyName).PropertyType;
}

private object GetValueImpl(object target, string propertyName)
{
Match match = RegExIndex.Match(propertyName);
int index = -1;
if (match.Success)
{
// We have an index, get it and drop the index part “[i]” to get the List property
index = int.Parse(match.Groups["index"].Value);
propertyName = propertyName.Replace(match.Value, string.Empty);
}
PropertyInfo propInfo = GetPropertyInfo(target.GetType(), propertyName);
if (index >= 0 && typeof(IEnumerable).IsAssignableFrom(propInfo.PropertyType))
{
return GetValueForIndexedItem(target, propInfo, index);
}
return propInfo.GetValue(target, NoParams);
}

private object GetValueForIndexedItem(object target, PropertyInfo propInfo, int index)
{
if (typeof(IList).IsAssignableFrom(propInfo.PropertyType))
{
return ((IList)propInfo.GetValue(target, NoParams))[index];
}
else if (typeof(IEnumerable).IsAssignableFrom(propInfo.PropertyType))
{
int i = 0;
foreach (object o in ((IEnumerable)propInfo.GetValue(target, NoParams)))
{
if (index == i)
{
return o;
}
i++;
}
throw new IndexOutOfRangeException(string.Format(”Property ‘{0}’ index ‘{1}’ out of range”, propInfo.Name, index));
}
else
{
throw new ArgumentException(string.Format(”Property ‘{0}’ must implement IList or IEnumerable in order to access an indexed value”, propInfo.Name));
}
}

private void SetValueImpl(object target, string propertyName, object value)
{
GetPropertyInfo(target.GetType(), propertyName).SetValue(target, value, NoParams);
}

private PropertyInfo GetPropertyInfo(Type type, string propertyName)
{
PropertyInfoCache propertyInfoCache = GetPropertyInfoCache(type);
if (!propertyInfoCache.ContainsKey(propertyName))
{
PropertyInfo propertyInfo = GetBestMatchingProperty(propertyName, type);
if (propertyInfo == null)
{
throw new ArgumentException(string.Format(”Unable to find public property named {0} on type {1}”, propertyName, type.FullName), propertyName);

}
propertyInfoCache.Add(propertyName, propertyInfo);
}
return propertyInfoCache[propertyName];
}

private static PropertyInfo GetBestMatchingProperty(string propertyName, Type type)
{
PropertyInfo[] propertyInfos = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);

PropertyInfo bestMatch = null;
int bestMatchDistance = int.MaxValue;
for (int i = 0; i 0 && distance < bestMatchDistance)
{
bestMatch = info;
bestMatchDistance = distance;
}
}
}
return bestMatch;
}

private static int CalculateDistance(Type targetObjectType, Type baseType)
{
if (!baseType.IsInterface)
{
Type currType = targetObjectType;
int level = 0;
while (currType != null)
{
if (baseType == currType)
{
return level;
}
currType = currType.BaseType;
level++;
}
}
return -1;
}

private PropertyInfoCache GetPropertyInfoCache(Type type)
{
if (!propertyCache.ContainsKey(type))
{
lock (this)
{
if (!propertyCache.ContainsKey(type))
{
propertyCache.Add(type, new PropertyInfoCache());
}
}
}
return propertyCache[type];
}

private object Construct(Type type)
{
if (!constructorCache.ContainsKey(type))
{
lock (this)
{
if (!constructorCache.ContainsKey(type))
{
ConstructorInfo constructorInfo = type.GetConstructor(NoTypeParams);
if (constructorInfo == null)
{
throw new Exception(string.Format(”Unable to construct instance, no parameterless constructor found in type {0}”, type.FullName));

}
constructorCache.Add(type, constructorInfo);
}
}
}
return constructorCache[type].Invoke(NoParams);
}
}

internal class PropertyInfoCache
{
private IDictionary propertyInfoCache;

public PropertyInfoCache()
{
propertyInfoCache = new Dictionary();
}

public bool ContainsKey(string key)
{
return propertyInfoCache.ContainsKey(key);
}

public void Add(string key, PropertyInfo value)
{
propertyInfoCache.Add(key, value);
}

public PropertyInfo this[string key]
{
get { return propertyInfoCache[key]; }
set { propertyInfoCache[key] = value; }
}
}
}

Hope it helps.

Federico D. Colombo

for /f “tokens=3 delims=. ” %%i in (’svn update’) do set Revision=%%i

FOR /F “delims=: tokens=1,2 ” %%G IN (’svn info –revision HEAD’) DO ^
IF “%%G”==”Last Changed Rev” echo %%H

Do you have complete source available somewhere? I have trouble getting all code snippets glued together.

Thanks,
JN

The code I posted earlier may help.
You can use something else like:

delegate void test();
private void Invoke ( test x )
{
this.Invoke(new MethodInvoker(x));
}

What is weird is that I can write the code above and can’t write:
private void Invoke ( delegate() x )
{
this.Invoke(new MethodInvoker(x));
}
:D

i really think it is stupid that updating the GUI from an async event requires the event handler, a call to begin invoke, a delegate handler, and a function the delegate is for…

Too many steps if you ask me — I had known about the easy way to do this in silverlight, thanks for showing how to do it in Forms!

private void Invoke ( Action anndel )
{
this.Invoke(new MethodInvoker(anndel));
}

void main()
{
Invoke(delegate { this.Text = “x”; txtbox.Text = “y”; });
}

Hope it helps! :D

The modified version of GetValue method I just posted got chopped off it should be:
public object GetValue(object target, string propertyName)
{
if (propertyName.IndexOf(PropertyNameSeparator) > -1)
{
int index = -1;
string[] propertyList = propertyName.Split(PropertyNameSeparator);
for (int i = 0; i = 0)
{
var List = (IList) target;
if (index < List.Count)
{
target = List[index];
}
}
if (target == null)
{
return null;
}
}
return target;
}
else
{
return GetValueImpl(target, propertyName);
}
}
Regards,
Adolfo