AsObject()转换成C#中的实体类

public static class AmfEntityConvert
    {
        delegate object ConvertAction(object data);
        static Dictionary<Type, ConvertAction> dicTypeRelation = new Dictionary<Type, ConvertAction>();
        static AmfEntityConvert()
        {
            dicTypeRelation[typeof(FluorineFx.AMF3.ByteArray)] = new ConvertAction((object data) =>
            {
                byte[] bytes = null;
                if (data != null)
                {
                    bytes = (data as FluorineFx.AMF3.ByteArray).GetBuffer();
                }
                return bytes;
            });
        }
 
        public static T ConvertObject<T>(object asObject)
        {
            if (asObject != null)
            {
                Type type = asObject.GetType();
                if (dicTypeRelation.Keys.Contains(type))
                {
                    return (T)dicTypeRelation[type](asObject);
                }
                else
                {
                    return (T)Convert.ChangeType(asObject, typeof(T));
                }
            }
            return default(T);
        }
 
        public static object ConvertData(Type type, object obj, params object[] pams)
        {
            Type classType = typeof(AmfEntityConvert);
            MethodInfo staticMethod = classType.GetMethod("ConvertObject");
            MethodInfo genericMethod = staticMethod.MakeGenericMethod(type);
            return genericMethod.Invoke(obj, pams);
        }
 
        /// <summary>
        /// 转换ASObject对象为.Net类型对象
        /// </summary>
        /// <param name="pObj"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public static object ConvertEntity(ASObject asObjeect, Type type)
        {
            try
            {
                var tempObj = Activator.CreateInstance(type);
                foreach (var asObj in asObjeect)
                {
                    string key = asObj.Key;
                    object value = asObj.Value;
 
                    MemberInfo[] members = type.GetMember(key);
                    if (null != value && members != null && members.Length > 0)
                    {
                        object newValue = null;
                        Type asValueType = asObj.Value.GetType();
 
                        //.Net类型实体成员
                        MemberInfo member = members[0];
                        Type memberType = null;
                        FieldInfo field = null;
                        PropertyInfo property = null;
                        if (member.MemberType == MemberTypes.Field)
                        {
                            field = type.GetField(member.Name);
                            memberType = field.FieldType;
                        }
                        if (member.MemberType == MemberTypes.Property)
                        {
                            property = type.GetProperty(member.Name);
                            memberType = property.PropertyType;
                        }
 
                        if (property != null || field != null)
                        {
                            //如果是ASObject对象
                            if (asValueType == typeof(ASObject))
                            {
                                newValue = ConvertEntity((ASObject)value, memberType);
                            }
                            //如果是数组集合
                            else if (asValueType == typeof(Object[]))
                            {
                                Type subtype = Assembly.GetAssembly(memberType).GetType(memberType.FullName.Replace("[]", ""), true);
 
                                object[] arrobj = (Object[])value;
                                var objData = Array.CreateInstance(subtype, arrobj.Length);
                                for (int nn = 0; nn < arrobj.Length; nn++)
                                {
                                    FluorineFx.ASObject asData = (FluorineFx.ASObject)arrobj[nn];
 
                                    var val = ConvertEntity(asData, subtype);
                                    objData.SetValue(val, nn);
                                }
                                newValue = objData;
                            }
                            //基本类型
                            else
                            {
                                newValue = ConvertData(memberType, null, value);
                            }
 
                            if (field != null)
                            {
                                field.SetValue(tempObj, Convert.ChangeType(newValue, memberType));
                            }
                            else if (property != null && property.CanWrite)
                            {
                                property.SetValue(tempObj, Convert.ChangeType(newValue, memberType), null);
                            }
                        }
                    }
                }
                return tempObj;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
    }