We only use editing and paging on this particular grid instance, and it's working. Again, flattening or wrapping the objects is not an issue. we'd end up witn a maintainability nightmare, should the specs ever change, which they tend to do in our shop, and we don't use server-side filtering/sorting/grouping. That's why we went with the jQuery version of your controls, all of that is handled client side.

I'd appreciate any assistance you could offer in helping to resolve the 'Enter' and 'Esc' event issues.

Hey Bob,

Thanks for the feedback & the workaround. Basically I am not saying to change anything in your data model. You can just create new wrapper classes, and fill them based on the collections you already have in place. I would prefer this approach compared to using reflection . Moreover i am not sure if sorting / filtering / groupby, etc. will work fine on the server-side, when you are binding to "complex" properties. 

Thanks,

Angel

Angel,

We're developing in .NET 3.5 using MVC 2. All users run windows 7 or XP SP 3 and we support IE 7 & 8 only.

Could you tell me in which JS file (unminified) and line number the editor key events are handled? Perhaps I can debug it here, and resolve. (We're currently waiting on a custom release to be built for us which you will be delivering the end of this month).

As to the complex objects, your "solution" is not an option for us. We're not going to change our object structures to conform to a 3rd party's limitations.

If anyone else in your user community is having the same issue, here's the fix:

Create a custom action filter, and a generic Complex Object Converter class and create the objects via reflection, using NewtonSoft's JSON library to handle the request params:

1. The Action Filter:

public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            if (filterContext.HttpContext.Request.ContentType.Contains("application/json"))
            {                
                JArray array;
                using (var sr = new StreamReader(filterContext.HttpContext.Request.InputStream))
                {
                    using (JsonTextReader jr = new JsonTextReader(sr))
                    {
                        array = JArray.Load(jr);
                    }
                }
 
                Result = new List<myComplexObject>();
                foreach (JObject jObj in array)
                {
                    var detail = ComplexObjectConverter<myComplexObject>.Convert(jObj);
                    Result.Add(detail);
                }
 
                filterContext.ActionParameters[Param] = Result;
            }
        }

2. The complex object converter:

public class ComplexObjectConverter<T>
    {
        internal static T Convert(JObject jObj)
        {
            T result = (T)Activator.CreateInstance(typeof(T));
 
            var pi = result.GetType().GetProperties();
 
            foreach (KeyValuePair<string, JToken> key in jObj)
            {
                if (key.Key.IndexOf('.') == -1)
                {
                    var p = pi.Single(m => m.Name == key.Key);
                    p.SetValue(result, HandleCast(jObj[key.Key], p.PropertyType), null);
                }
                else
                {
                    var nestedProp = key.Key.Split('.')[0];
                    var member = key.Key.Split('.')[1];
                    var pn = key.Key.Split('.');
                    object o = result;
                    for (int i = 0; i < pn.Length - 1; i++)
                    {
                        o = TypeDescriptor.GetProperties(result)[pn[i]].GetValue(o);
                    }
                    var p = pi.Single(m => m.Name == nestedProp);
                    var nv = p.PropertyType.GetProperties().Single(m => m.Name == member);
                    TypeDescriptor.GetProperties(o)[pn[pn.Length - 1]].SetValue(o, HandleCast(jObj[key.Key], nv.PropertyType));                    
                }
            }
 
            return result;
        }
 
        private static object HandleCast(JToken jToken, Type type)
        {
            if (type == typeof(int))
            {
                return (int)jToken;
            }
            if (type == typeof(string))
            {
                return jToken.ToString();
            }
            if (type == typeof(decimal))
            {
                return (decimal)jToken;
            }
            if (type == typeof(bool))
            {
                return (bool)jToken;
            }
 
            throw new ArgumentException("type not found");
        }

Hopefully, this will help someone else.