Unity C# 反射性能优化

原文地址:https://segmentfault.com/a/11...

本篇内容主要讲如何优化获取(设置)对象字段(属性)的反射性能。

先上结论：

1.反射性能很差，比直接调用慢成百上千倍。
2.反射性能优化的思路是绕开反射。
3.反射性能优化方式有：字典缓存(Dictionary Cache)、委托(Delegate.CreateDelegate)、Expression.Lamda、IL.Emit、指针(IntPtr) 等各种方式。
4.性能排名：直接调用 > (IL.Emit == Expression) > 委托 > 指针 > 反射
5.通用性排名：反射 > (委托 == 指针) > (IL.Emit == Expression) > 直接调用
6.综合排名：(委托 == 指针) > (IL.Emit == Expression) > 反射 > 直接调用

IL.Emit本是性能最优方案，但可惜IL2CPP模式不支持JIT 所有动态生成代码的功能都不好用 故IL.Emit无法使用、Expression.Lamda也是同样的原因不可用。
退而求其次选用性能和通用性都不错的委托，由于委托只能优化方法无法用于字段，所以又加上了指针用于操作字段。

性能测试：

以设置对象的属性Name为测试条件(obj.Name = "A")
SetValue方法都调整为通用的SetValue(object target, object value)状态。
除了反射，所有调用方法都创建委托后再调用，省略查找委托缓存的步骤。
在Release模式下，循环多次调用，查看耗时。
如果直接调用耗时约为：1ms，其他方式耗时约为：

直接调用 IL.Emit Expression 委托(Delegate) 反射(MethodInfo)
1ms 1.3ms 1.3ms 2.1ms 91.7ms

指针只操作字段, 不参与该项测试

如果测试条件改为每次获取或设置值都需要通过Dictionary从缓存中查找字段所对应的委托方法后调用，那么时间将大大增加，大部分时间都浪费在了字典查找上，但这也更贴近我们正常使用的情况。

直接调用= IL.Emit Expression 委托(Delegate) 反射(MethodInfo)
1ms 8.8ms 8.8ms 9.7ms 192.5ms

设置string字段测试:

直接调用= IL.Emit Expression 指针 反射(MethodInfo)
1ms 8ms 8ms 9ms 122ms

委托只操作属性, 不参与该项测试

从测试结果可以看出
直接调用 > IL.Emit(Expression与IL一致) > 委托(指针与委托互补）> 反射

基本上只要能绕开反射，性能都会有明显的提升。

IL.Emit

优点：性能非常高。
缺点：不支持IL2CPP。

IL.Emit通用工具类:

用法：

var getName = ILUtil.CreateGetValue(type, "Name");
var setName = ILUtil.CreateSetValue(type, "Name");
setName(obj, "A");
string name = (string)getName(obj);

代码：

#region Intro
// Purpose: Reflection Optimize Performance
// Author: ZhangYu
// LastModifiedDate: 2022-06-11
#endregion

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections.Generic;

///  IL.Emit工具 
public static class ILUtil {

    private static Type[] NoTypes = new Type[] { };

    ///  IL动态添加创建新对象方法 
    public static Func CreateCreateInstance(Type classType) {
        DynamicMethod method = new DynamicMethod(string.Empty, typeof(object), null, classType);
        if (classType.IsValueType) {
            // 实例化值类型
            ILGenerator il = method.GetILGenerator(32);
            var v0 = il.DeclareLocal(classType);
            il.Emit(OpCodes.Ldloca_S, v0);
            il.Emit(OpCodes.Initobj, classType);
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Box, classType);
            il.Emit(OpCodes.Ret);
        } else {
            // 实例化引用类型
            ConstructorInfo ctor = classType.GetConstructor(NoTypes);
            ILGenerator il = method.GetILGenerator(16);
            il.Emit(OpCodes.Newobj, ctor);
            il.Emit(OpCodes.Ret);
        }
        return method.CreateDelegate(typeof(Func)) as Func;
    }

    ///  IL动态添加创建新数组方法 
    public static Func CreateCreateArray(Type classType, int length) {
        DynamicMethod method = new DynamicMethod(string.Empty, typeof(Array), new Type[] { typeof(int) }, typeof(Array));
        ILGenerator il = method.GetILGenerator(16);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Newarr, classType.GetElementType());
        il.Emit(OpCodes.Ret);
        return method.CreateDelegate(typeof(Func)) as Func;
    }

    private static Dictionary> createInstanceCache = new Dictionary>();
    private static Dictionary> createArrayCache = new Dictionary>();

    ///  IL动态创建新的实例 
    /// 类型
    public static object CreateInstance(Type classType) {
        Func createMethod = null;
        if (!createInstanceCache.TryGetValue(classType, out createMethod)) {
            createMethod = CreateCreateInstance(classType);
            createInstanceCache.Add(classType, createMethod);
        }
        return createMethod();
    }


    ///  IL动态创建新数组 
    public static Array CreateArray(Type classType, int length) {
        Func createMethod = null;
        if (!createArrayCache.TryGetValue(classType, out createMethod)) {
            createMethod = CreateCreateArray(classType, length);
            createArrayCache.Add(classType, createMethod);
        }
        return createMethod(length);
    }

    ///  IL.Emit动态创建获取字段值的方法 
    private static Func CreateGetField(Type classType, string fieldName) {
        FieldInfo field = classType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public);
        DynamicMethod method = new DynamicMethod(string.Empty, typeof(object), new Type[] { typeof(object) }, classType);
        ILGenerator il = method.GetILGenerator(16); // 默认大小64字节
        il.Emit(OpCodes.Ldarg_0);
        if (classType.IsValueType) il.Emit(OpCodes.Unbox_Any, classType);
        il.Emit(OpCodes.Ldfld, field);
        if (field.FieldType.IsValueType) il.Emit(OpCodes.Box, field.FieldType);
        il.Emit(OpCodes.Ret);
        return method.CreateDelegate(typeof(Func)) as Func;
    }

    ///  IL.Emit动态创建设置字段方法 
    private static Action CreateSetField(Type classType, string fieldName) {
        FieldInfo field = classType.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public);
        DynamicMethod method = new DynamicMethod(string.Empty, null, new Type[] { typeof(object), typeof(object) }, classType);
        ILGenerator il = method.GetILGenerator(32); // 默认大小64字节
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(classType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass, classType);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(field.FieldType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, field.FieldType);
        il.Emit(OpCodes.Stfld, field);
        il.Emit(OpCodes.Ret);
        return method.CreateDelegate(typeof(Action)) as Action;
    }

    ///  IL.Emit动态创建获取属性值的方法 
    private static Func CreateGetProperty(Type classType, string propertyName) {
        PropertyInfo property = classType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
        DynamicMethod method = new DynamicMethod(string.Empty, typeof(object), new Type[] { typeof(object) }, classType);
        ILGenerator il = method.GetILGenerator(32);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(classType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass, classType);
        il.Emit(OpCodes.Call, property.GetGetMethod());
        if (property.PropertyType.IsValueType) il.Emit(OpCodes.Box, property.PropertyType);
        il.Emit(OpCodes.Ret);
        return method.CreateDelegate(typeof(Func)) as Func;
    }

    ///  IL.Emit动态创建设置属性值的方法 
    private static Action CreateSetProperty(Type classType, string propertyName) {
        PropertyInfo property = classType.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public);
        MethodInfo methodInfo = property.GetSetMethod();
        ParameterInfo parameter = methodInfo.GetParameters()[0];
        DynamicMethod method = new DynamicMethod(string.Empty, null, new Type[] { typeof(object), typeof(object) }, classType);
        ILGenerator il = method.GetILGenerator(32);
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(classType.IsValueType ? OpCodes.Unbox : OpCodes.Castclass, classType);
        il.Emit(OpCodes.Ldarg_1);
        il.Emit(parameter.ParameterType.IsValueType ? OpCodes.Unbox_Any : OpCodes.Castclass, parameter.ParameterType);
        il.Emit(OpCodes.Call, methodInfo);
        il.Emit(OpCodes.Ret);
        return method.CreateDelegate(typeof(Action)) as Action;
    }

    ///  IL.Emit动态创建获取字段或属性值的方法 
    /// 对象类型
    /// 字段(或属性)名称
    public static Func CreateGetValue(Type classType, string fieldName) {
        MemberInfo[] members = classType.GetMember(fieldName, BindingFlags.Instance | BindingFlags.Public);
        if (members.Length == 0) {
            string error = "Type [{0}] don't contains member [{1}]";
            throw new Exception(string.Format(error, classType, fieldName));
        }
        Func getValue = null;
        switch (members[0].MemberType) {
            case MemberTypes.Field:
                getValue = CreateGetField(classType, fieldName);
                break;
            case MemberTypes.Property:
                getValue = CreateGetProperty(classType, fieldName);
                break;
            default:
                break;
        }
        return getValue;
    }

    ///  IL.Emit动态创建设置字段值(或属性)值的方法 
    /// 对象类型
    /// 字段(或属性)名称
    public static Action CreateSetValue(Type classType, string fieldName) {
        MemberInfo[] members = classType.GetMember(fieldName, BindingFlags.Instance | BindingFlags.Public);
        if (members.Length == 0) {
            string error = "Type [{0}] does not contain field [{1}]";
            throw new Exception(string.Format(error, classType, fieldName));
        }
        Action setValue = null;
        switch (members[0].MemberType) {
            case MemberTypes.Field:
                setValue = CreateSetField(classType, fieldName);
                break;
            case MemberTypes.Property:
                setValue = CreateSetProperty(classType, fieldName);
                break;
            default:
                break;
        }
        return setValue;
    }

    // Emit Getter 方法缓存字典
    private static Dictionary>> getValueCache = new Dictionary>>();
    // Emit Setter 方法缓存字典
    private static Dictionary>> setValueCache = new Dictionary>>();

    ///  IL 获取对象成员的值(字段或属性) 
    public static object GetValue(object obj, string fieldName) {
        // 查找一级缓存
        Type classType = obj.GetType();
        Dictionary> cache = null;
        if (!getValueCache.TryGetValue(classType, out cache)) {
            cache = new Dictionary>();
            getValueCache.Add(classType, cache);
        }

        // 查找二级缓存
        Func getValue = null;
        if (!cache.TryGetValue(fieldName, out getValue)) {
            getValue = CreateGetValue(classType, fieldName);
            cache.Add(fieldName, getValue);
        }
        return getValue(obj);
    }

    ///  IL 设置对象成员的值(字段或属性) 
    public static void SetValue(object obj, string fieldName, object value) {
        // 查找一级缓存
        Type classType = obj.GetType();
        Dictionary> cache = null;
        if (!setValueCache.TryGetValue(classType, out cache)) {
            cache = new Dictionary>();
            setValueCache.Add(classType, cache);
        }

        // 查找二级缓存
        Action setValue = null;
        if (!cache.TryGetValue(fieldName, out setValue)) {
            setValue = CreateSetValue(classType, fieldName);
            cache.Add(fieldName, setValue);
        }
        setValue(obj, value);
    }

    ///  清理已缓存IL方法 
    public static void ClearCache() {
        createInstanceCache.Clear();
        createArrayCache.Clear();
        getValueCache.Clear();
        setValueCache.Clear();
    }

} 
 
 
 
Expression.Lamda
 
 
优点：性能非常高。
缺点：不支持IL2CPP。
和IL.Emit一样。
 
 
Expression通用工具类:
 
 
用法：
 
 
var wrapper = ExpressionUtil.GetPropertyWrapper(type, "Name");
wrapper.SetValue(obj, "A");
string name = (string)wrapper.GetValue(obj);
 
 
代码：
 
 
using System;
using System.Reflection;
using System.Linq.Expressions;
using System.Collections.Generic;

///  
/// Expression.Lamda 反射加速工具
/// ZhangYu 2022-06-11
/// 
public static class ExpressionUtil {

    public class PropertyWrapper {

        public Func GetValue { get; private set; }
        public Action SetValue { get; private set; }

        public PropertyWrapper(Func getValue, Action setValue) {
            GetValue = getValue;
            SetValue = setValue;
        }

    }

    public static Func CreateGetProperty(Type type, string propertyName) {
        var objectObj = Expression.Parameter(typeof(object), "obj");
        var classObj = Expression.Convert(objectObj, type);
        var classFunc = Expression.Property(classObj, propertyName);
        var objectFunc = Expression.Convert(classFunc, typeof(object));
        Func getValue = Expression.Lambda>(objectFunc, objectObj).Compile();
        return getValue;
    }

    public static Action CreateSetProperty(Type type, string propertyName) {
        var property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
        var objectObj = Expression.Parameter(typeof(object), "obj");
        var objectValue = Expression.Parameter(typeof(object), "value");
        var classObj = Expression.Convert(objectObj, type);
        var classValue = Expression.Convert(objectValue, property.PropertyType);
        var classFunc = Expression.Call(classObj, property.GetSetMethod(), classValue);
        var setProperty = Expression.Lambda>(classFunc, objectObj, objectValue).Compile();
        return setProperty;
    }

    private static Dictionary> cache = new Dictionary>();

    public static PropertyWrapper GetPropertyWrapper(Type type, string propertyName) {
        // 查找一级缓存
        Dictionary wrapperDic = null;
        if (!cache.TryGetValue(type, out wrapperDic)) {
            wrapperDic = new Dictionary();
            cache.Add(type, wrapperDic);
        }

        // 查找二级缓存
        PropertyWrapper wrapper = null;
        if (!wrapperDic.TryGetValue(propertyName, out wrapper)) {
            var getValue = CreateGetProperty(type, propertyName);
            var setValue = CreateSetProperty(type, propertyName);
            wrapper = new PropertyWrapper(getValue, setValue);
            wrapperDic.Add(propertyName, wrapper);
        }
        return wrapper;
    }

    public static void ClearCache() {
        cache.Clear();
    }

}
 
 
 
 
委托(Delegate)
 
 
优点：性能高，通用性强(IL2CPP下也可使用)。
缺点：只能操作方法，无法直接操作字段
 
 
委托通用工具类：
用法：
 
 
var wrapper = DelegateUtil.GetPropertyWrapper(type, "Name");
wrapper.SetValue(obj, "A");
string name = (string)wrapper.GetValue(obj);
 
 
代码：
 
 
using System;
using System.Reflection;
using System.Collections.Generic;

public interface IPropertyWrapper {

    object GetValue(object obj);
    void SetValue(object obj, object value);

}

public class PropertyWrapper : IPropertyWrapper {

    private Func getter;
    private Action setter;

    public PropertyWrapper(PropertyInfo property) {
        getter = Delegate.CreateDelegate(typeof(Func), property.GetGetMethod()) as Func;
        setter = Delegate.CreateDelegate(typeof(Action), property.GetSetMethod()) as Action;
    }

    public V GetValue(T obj) {
        return getter(obj);
    }

    public void SetValue(T obj, V value) {
        setter(obj, value);
    }

    public object GetValue(object obj) {
        return GetValue((T)obj);
    }

    public void SetValue(object obj, object value) {
        SetValue((T)obj, (V)value);
    }

}

///  委托工具类 ZhangYu 2022-06-10 
public static class DelegateUtil {

    private static Dictionary> cache = new Dictionary>();

    ///  获取属性包装器 
    public static IPropertyWrapper GetPropertyWrapper(Type type, string propertyName) {
        if (string.IsNullOrEmpty(propertyName)) throw new Exception("propertyName is null");
        // 查找类型
        Dictionary proCache = null;
        if (!cache.TryGetValue(type, out proCache)) {
            proCache = new Dictionary();
            cache.Add(type, proCache);
        }

        // 查找属性
        IPropertyWrapper wrapper = null;
        if (!proCache.TryGetValue(propertyName, out wrapper)) {
            PropertyInfo property = type.GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance);
            if (property == null) throw new Exception(type.Name + " type no property:" + propertyName);
            Type wrapperType = typeof(PropertyWrapper<,>).MakeGenericType(type, property.PropertyType);
            wrapper = Activator.CreateInstance(wrapperType, property) as IPropertyWrapper;
            proCache.Add(propertyName, wrapper);
        }
        return wrapper;
    }

    ///  清理缓存 
    public static void ClearCache() {
        cache.Clear();
    }

}
 
 
 
 
指针
 
 
优点：性能高，通用性好(IL2CPP下也可使用)。
缺点：暂时不知道怎样用指针操作属性(方法)。
 
 
指针通用工具类：
 
 
using System;
using System.Reflection;
using System.Collections.Generic;
using System.Runtime.InteropServices;
#if !ENABLE_MONO
using Unity.Collections.LowLevel.Unsafe;
#endif

///  指针工具 ZhangYu 2022-06-10 
public static class PointerUtil {

    public class FieldWrapper {

        public string fieldName;
        public Type fieldType;
        public bool isValueType;
        public TypeCode typeCode;
        public int offset;
        private static bool is64Bit = Environment.Is64BitProcess;

        #region Instance Function
        ///  获取字段值 
        public unsafe object GetValue(object obj) {
            // 检查参数
            CheckObjAndFieldName(obj, fieldName);

            // 查找对象信息
            Type type = obj.GetType();

            // 获取值
            IntPtr ptr = GetPointer(obj) + offset;
            object value = null;
            switch (typeCode) {
                case TypeCode.Boolean:
                    value = *(bool*)ptr;
                    break;
                case TypeCode.Char:
                    value = *(char*)ptr;
                    break;
                case TypeCode.SByte:
                    value = *(sbyte*)ptr;
                    break;
                case TypeCode.Byte:
                    value = *(byte*)ptr;
                    break;
                case TypeCode.Int16:
                    value = *(short*)ptr;
                    break;
                case TypeCode.UInt16:
                    value = *(ushort*)ptr;
                    break;
                case TypeCode.Int32:
                    value = *(int*)ptr;
                    break;
                case TypeCode.UInt32:
                    value = *(uint*)ptr;
                    break;
                case TypeCode.Int64:
                    value = *(long*)ptr;
                    break;
                case TypeCode.UInt64:
                    value = *(ulong*)ptr;
                    break;
                case TypeCode.Single:
                    value = *(float*)ptr;
                    break;
                case TypeCode.Double:
                    value = *(double*)ptr;
                    break;
                case TypeCode.Decimal:
                    value = *(decimal*)ptr;
                    break;
                case TypeCode.DateTime:
                    value = *(DateTime*)ptr;
                    break;
                case TypeCode.DBNull:
                case TypeCode.String:
                case TypeCode.Object:
                    if (isValueType) {
                        value = GetStruct(ptr, fieldType);
                    } else {
                        value = GetObject(ptr);
                    }
                    break;
                default:
                    break;
            }
            return value;
        }

        ///  给字段赋值 
        public unsafe void SetValue(object obj, object value) {
            // 检查参数
            CheckObjAndFieldName(obj, fieldName);

            // 查找对象信息
            Type type = obj.GetType();

            // 获取值
            IntPtr ptr = GetPointer(obj) + offset;
            switch (typeCode) {
                case TypeCode.Boolean:
                    *(bool*)ptr = (bool)value;
                    break;
                case TypeCode.Char:
                    *(char*)ptr = (char)value;
                    break;
                case TypeCode.SByte:
                    *(sbyte*)ptr = (sbyte)value;
                    break;
                case TypeCode.Byte:
                    *(byte*)ptr = (byte)value;
                    break;
                case TypeCode.Int16:
                    *(short*)ptr = (short)value;
                    break;
                case TypeCode.UInt16:
                    *(ushort*)ptr = (ushort)value;
                    break;
                case TypeCode.Int32:
                    *(int*)ptr = (int)value;
                    break;
                case TypeCode.UInt32:
                    *(uint*)ptr = (uint)value;
                    break;
                case TypeCode.Int64:
                    *(long*)ptr = (long)value;
                    break;
                case TypeCode.UInt64:
                    *(ulong*)ptr = (ulong)value;
                    break;
                case TypeCode.Single:
                    *(float*)ptr = (float)value;
                    break;
                case TypeCode.Double:
                    *(double*)ptr = (double)value;
                    break;
                case TypeCode.Decimal:
                    *(decimal*)ptr = (decimal)value;
                    break;
                case TypeCode.DateTime:
                    *(DateTime*)ptr = (DateTime)value;
                    break;
                case TypeCode.DBNull:
                case TypeCode.String:
                case TypeCode.Object:
                    if (isValueType) {
                        SetStruct(ptr, value);
                    } else {
                        SetObject(ptr, value);
                    }
                    break;
                default:
                    break;
            }

        }
        #endregion

        #region Static Fucntion
        ///  获取对象地址 
        private unsafe static IntPtr GetPointer(object obj) {
        #if ENABLE_MONO
            TypedReference tr = __makeref(obj);
            return *(IntPtr*)*((IntPtr*)&tr + 1);
        #else
            ulong gcHandle;
            IntPtr ptr = (IntPtr)UnsafeUtility.PinGCObjectAndGetAddress(obj, out gcHandle);
            UnsafeUtility.ReleaseGCObject(gcHandle);
            return ptr;
        #endif
        }

        ///  将对象的地址设置到目标地址，有类型判定和引用计数，推荐在堆上操作 
        private unsafe static void SetObject(IntPtr ptr, object value) {
        #if ENABLE_MONO
            object tmp = "";
            TypedReference tr = __makeref(tmp);
            if (is64Bit) {
                long* p = (long*)&tr + 1;
                *p = (long)ptr;
                __refvalue(tr, object) = value;
            } else {
                int* p = (int*)&tr + 1;
                *p = (int)ptr;
                __refvalue(tr, object) = value;
            }
        #else
            UnsafeUtility.CopyObjectAddressToPtr(value, (void*)ptr);
        #endif
        }

        ///  设置Struct 
        private static void SetStruct(IntPtr ptr, object value) {
            Marshal.StructureToPtr(value, ptr, true);
        }

        ///  获取对象 
        private unsafe static object GetObject(IntPtr ptr) {
        #if ENABLE_MONO
            object tmp = "";
            TypedReference tr = __makeref(tmp);
            if (is64Bit) {
                long* p = (long*)&tr + 1;
                *p = (long)ptr;
                return __refvalue(tr, object);
            } else {
                int* p = (int*)&tr + 1;
                *p = (int)ptr;
                return __refvalue(tr, object);
            }
        #else
            return UnsafeUtility.ReadArrayElement((void*)ptr, 0);
        #endif
        }

        ///  获取Struct 
        private static object GetStruct(IntPtr ptr, Type type) {
            return Marshal.PtrToStructure(ptr, type);
        }

        ///  检查参数 
        private static void CheckObjAndFieldName(object obj, string fieldName) {
            if (obj == null) throw new Exception("obj can't be null");
            if (string.IsNullOrEmpty(fieldName)) throw new Exception("FieldName can't be null or empty");
        }

        ///  获取字段地址偏移量 
        public unsafe static int GetFieldOffset(FieldInfo field) {
            return *(short*)(field.FieldHandle.Value + 24);
        }
        #endregion

    }

    ///  缓存 
    private static Dictionary> cache = new Dictionary>();

    public static FieldWrapper GetFieldWrapper(Type type, string fieldName) {
        // 查找一级缓存
        Dictionary wrapperDic = null;
        if (!cache.TryGetValue(type, out wrapperDic)) {
            wrapperDic = new Dictionary();
            cache.Add(type, wrapperDic);
        }

        // 查找二级缓存
        FieldWrapper wrapper = null;
        if (!wrapperDic.TryGetValue(fieldName, out wrapper)) {
            FieldInfo field = type.GetField(fieldName, BindingFlags.Public | BindingFlags.Instance);
            if (field == null) throw new Exception(type.Name + " field is null:" + fieldName);
            wrapper = new FieldWrapper();
            wrapper.fieldName = fieldName;
            wrapper.fieldType = field.FieldType;
            wrapper.isValueType = field.FieldType.IsValueType;
            wrapper.typeCode = Type.GetTypeCode(field.FieldType);
            wrapper.offset = FieldWrapper.GetFieldOffset(field);
            wrapperDic.Add(fieldName, wrapper);
        }
        return wrapper;
    }

    ///  清理缓存数据 
    public static void ClearCache() {
        cache.Clear();
    }

} 
 
 
 
优化方案选择：
 
 
优化方案这么多到底用哪个? 有最好的吗? （可以参考以下建议）
 
 
1.首选IL.Emit方案，性能很好，唯一的缺点是不兼容IL2CPP模式。
 
 
2.次选委托(Delegate.CreateDelegate)方案，在IL2CPP模式下用于替代IL.Emit，由于委托只能操作方法，不能操作字段，所以尽量写成{get; set;}的形式，如果有字段需要操作，那么再加上指针方案(IntPtr)。
 
 
终极优化手段：
 
 
如果以上手段你都尝试过了，依然不满意，作为一个成年人你想鱼和熊掌二者兼得，性能要最高的，通用性也要最好的，还要方便易用，你可以尝试代码生成方案，这个方案唯一的缺点就是你需要不少的时间去做代码生成工具和相关自动化工具的编写，开发成本颇高，可能要一直根据需求长期维护，属于把难题留给了自己，把方便留给了别人，前人栽树后人乘凉，做不好凉凉，做好了后人会："听我说谢谢你，因为有你，温暖了四季..."。
或者你是个技术大佬，喜欢研究技术，这点东西就是个小菜儿，以下是代码生成方案简述:
 
 
代码生成的方案：
优点：性能最高，通用性好(IL2CPP下也可使用)
缺点：实现复杂，费时间。
 
 
通过Unity强大的Editor 自己写一套代码生成工具，把相关需要调用字段(属性)的功能都用代码生成。
 
 
比如我现在正在写一个二进制的数据格式，要实现对象序列化和反序列化的功能，在转换对象的过程中需要调用对象的字段(属性)，假设当前操作的对象类型为:
【UserInfo】
 
 
public class UserInfo {

    public int id;
    public string name;

}
 
 
代码生成的序列化类则为：
【UserInfoSerializer】
 
 
public static class UserInfoSerializer {

    ///  序列化 
    public static byte[] Serialize(UserInfo obj) {
        if (obj == null) return new byte[0];
        BinaryWriter writer = new BinaryWriter();
        writer.WriteInt32(obj.id);
        writer.WriteUnicode(obj.name);
        return writer.ToBytes();
    }

    ///  反序列化 
    public static UserInfo Deserialize(byte[] bytes) {
        if (bytes == null) return null;
        UserInfo obj = new UserInfo();
        if (bytes.Length == 0) return obj;
        BinaryReader reader = new BinaryReader(bytes);
        obj.id = reader.ReadInt32();
        obj.name = reader.ReadUnicode();
        return obj;
    }

}
 
 
测试代码:
 
 
private void SerializeTest() {
    // 初始化对象
    UserInfo user = new UserInfo();
    user.id = 1001;
    user.name = "A";

    // 序列化
    byte[] bytes = UserInfoSerializer.Serialize(user);

    // 反序列化
    UserInfo u = UserInfoSerializer.Deserialize(bytes);

    // 输出数据
    print(u.id);   // 1001
    print(u.name); // "A"
}
 
 
测试代码通过，这个代码生成方案是行得通的，由于是具体类型直接调用，没有任何反射、字典查找、类型转换和装箱拆箱的消耗，性能极好(因为这就是直接调用)，接下来就是要做易用性和自动化处理。
 
 
我们在Unity Editor中需要实现的功能大致如下:
 
 
在Unity中，选中一个我们需要序列化的类，右键菜单 > 生成序列化帮助类，以便调用。
 
 
这种生成最好别对原来的代码进行任何修改，每次生成只参考目标类，生成序列化类，不对目标类进行改动，这样重新生成的时候只要覆盖生成类就好。
 
 
总结:
 
 
有时候看似最笨，最麻烦的方案，反而是最好的，也许这就是返璞归真，重剑无锋，大巧不工吧。
 
 
想要最佳的性能，直接调用才是最好的方案，如何解决直接调用的问题，用代码生成，Unity有着强大的Editor和各种接口，如果有时间和信心，可以尝试一下代码生成方案，但因为可能消耗很多时间，这里就不推荐了，各位根据自己的喜好选择就好。总之先做完，再完善。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(unityc#反射性能优化)

        

            

                
    
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • 深入浅出 -- 系统架构之负载均衡Nginx的性能优化
                        xiaoli8748_软件开发
系统架构系统架构负载均衡nginx
                        
    一、Nginx性能优化到这里文章的篇幅较长了，最后再来聊一下关于Nginx的性能优化，主要就简单说说收益最高的几个优化项，在这块就不再展开叙述了，毕竟影响性能都有多方面原因导致的，比如网络、服务器硬件、操作系统、后端服务、程序自身、数据库服务等，对于性能调优比较感兴趣的可以参考之前《JVM性能调优》中的调优思想。优化一：打开长连接配置通常Nginx作为代理服务，负责分发客户端的请求，那么建议开启H
    
                    
    • 
                    
  • 补充元象二面
                        Redstone Monstrosity
前端面试
                        
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
    
                    
    • 
                    
  • MyBatis 详解
                        阿贾克斯的黎明
javamybatis
                        
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    
                    
    • 
                    
  • Rust是否会取代C/C++？Rust与C/C++的较量
                        AI与编程之窗
源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
                        
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
    
                    
    • 
                    
  • C#动态加载DLL程序集及使用反射创建实例-简记
                        不全
C#相关Asp.netWebFormAsp.netMVCc#Assembly反射程序集
                        
    Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
    
                    
    • 
                    
  • C# 开发教程-入门基础
                        天马3798
教程系列整理c#开发语言
                        
    1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
    
                    
    • 
                    
  • 连接池的性能如何优化？
                        蜡笔小新星
MySQL经验分享学习pythonmysql数据库
                        
    连接池的性能优化是提高数据库访问效率和应用程序响应速度的关键。以下是一些优化连接池性能的策略：1.选择合适的连接池大小连接池的大小应根据应用程序的并发需求和数据库服务器的处理能力来确定。如果连接池太小，可能会导致线程等待连接；如果连接池太大，可能会消耗过多的系统资源。通常，连接池的大小应该设置为应用程序的并发用户数加上一些额外的连接以处理突发请求。2.设置合理的最小和最大连接数最小连接数（mins
    
                    
    • 
                    
  • 系列3：【深入】qiankun动态与按需加载子应用—像电影一样控制出现时机
                        rabbit_it
qiankun学习前端框架前端阿里云
                        
    一、引言：为何需要动态加载在现代前端开发中，性能优化始终是一个关键问题。对于微前端架构而言，管理多个子应用带来了前所未有的灵活性，但也对资源的加载和使用效率提出了更高要求。假设你的微前端项目就像一场电影，而子应用是场景或演员。在不同的情节中，我们只需要特定的场景和演员出现，而不需要所有场景和演员一开始就站在舞台上等待。这时，动态加载和按需加载就成为了关键工具——让需要的内容在正确的时机上场，节省性
    
                    
    • 
                    
  • 9.15初识指针
                        西科Monesy
c语言开发语言
                        
    初识指针什么是指针？指针是一种数据类型，它存储了变量的内存地址。通过指针，程序可以直接访问和操作内存中的数据，而不是通过变量的名称。这使得C语言在内存管理和性能优化方面具有很大的灵活性。内存是什么？内存是电脑上的存储器，计算机中程序的运行都是在内存中进行的。程序中如果有数据需要存储也会申请内存空间。为了有效的使用内存，就把内存划分成一个小小的内存单元，每个内存单元的大小是一个字节。为了能够有效的访
    
                    
    • 
                    
  • Java中的服务端点响应缓存：Spring Cache抽象
                        微赚淘客机器人开发者联盟@聚娃科技
java缓存spring
                        
    Java中的服务端点响应缓存：SpringCache抽象大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java后端服务开发中，缓存是一个重要的性能优化手段。Spring框架提供了一个强大的缓存抽象，允许开发者以统一的方式使用不同的缓存技术。本文将介绍如何在Java应用中使用SpringCache抽象来实现服务端点的响应缓存。响应缓存的重要性响应缓存在服务端点中
    
                    
    • 
                    
  • 2019/05/11
                        kiyoi2017

                        
    张清的日精进第651天习惯每当洗完澡的宠物被检查出不合格的时候，我们经常会条件反射似的认为是不认真，没有责任心。其实这也是一种习惯！为什么会出现一些细节之处总有不合格的现象？因为习惯在这里分成了两种，一种是注重细节，一种是忽略细节。为什么刘冰总监做完的活怎么查都合格！因为她养成了第一种习惯。首先，她确实是一个认真，有责任心的人。但是我相信她在做事的时候并不需要时刻提醒自己需要注重细节，因为她早就养
    
                    
    • 
                    
  • JavaScript 基础 - 第15天
                        +码农快讯+
JavaScript学习笔记javascript前端开发语言
                        
    文章目录JavaScript基础-第15天深浅拷贝浅拷贝深拷贝通过JSON序列化实现js库lodash实现深拷贝通过递归实现深拷贝异常处理throwtry...catchdebugger处理this改变thiscallapplybindthis指向性能优化防抖（debounce）手写防抖函数节流（throttle）手写节流函数JavaScript基础-第15天深浅拷贝浅拷贝浅拷贝：把对象拷贝给一个
    
                    
    • 
                    
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    
                    
    • 
                    
  • 前端性能优化
                        EdmundChen

                        
    要做性能优化，首先我们得知道用户从开始访问站点到看结果的这一段时间到底后花在了哪些地方。这就设计到一个经典问题。在游览器输入地址按下回车键之后到用户看到结果经历了哪些过程，这里简单说一下大的几个过程。（假设是输入的一个域名而非IP）1.通过DNS解析获得网址的对应IP地址2.浏览器拿到IP地址与远程web服务器通过TCP三次握手协商来建立一个TCP/IP连接3.浏览器通过HTTP接发送请求4.服务
    
                    
    • 
                    
  • 功不唐捐，修炼当下
                        白痴旭旭

                        
    功不唐捐出在《法华经》。意思是：你付出的努力和功德，从来不会白白的付出，终有一天，会回到你的身上来。为者常成，行者常至。合抱之木，生于毫末；九层之台，起于累土；千里之行，始于足下。什么都不想，把当下当做道场。全力把眼前的事情做好，任何时候和任何情况下都做到极致的好，极致修炼当下。不断从广度和深度维度丰富自己的知识储备，每种知识通过刻意打怪升级练习的方式把熟练程度达到潜意识的条件反射般自然，我们的技
    
                    
    • 
                    
  • 面试总结1
                        Xl_Lee

                        
    性能优化1.造成tableView卡顿的原因有哪些？1.最常用的就是cell的重用，注册重用标识符如果不重用cell时，每当一个cell显示到屏幕上时，就会重新创建一个新的cell如果有很多数据的时候，就会堆积很多cell。如果重用cell，为cell创建一个ID，每当需要显示cell的时候，都会先去缓冲池中寻找可循环利用的cell，如果没有再重新创建cell2.避免cell的重新布局cell的布
    
                    
    • 
                    
  • 【保姆级】使用Java注解和反射实现JSON字段自动重命名
                        AQin1012
Java出坑必备~java注解后端开发语言
                        
    不知道有没有同学遇到过对接业务方代码非常“独具一格”（不符合通用规范且不愿意配合修改emmmm。。。），于是就只能“被迫”按他的格式来，但是又不想因为他的不规范导致我们自己创建的接收对象也非常的“一言难尽”。。。今天这篇帮你解决这个问题~（老规矩：附完整可执行代码）先给初学Java的同学补下基础，涉及到一些实现这个功能需要的知识点（了解的朋友可以直接跳过~）Java注解（Annotation）Ja
    
                    
    • 
                    
  • 睿乔电缆教您如何查找电缆故障点
                        mrokqlk

                        
    电缆故障的发生伴随电缆的敷设使用而产生，电缆故障的定位随电缆敷设方式的不同，其定位难度在逐步加大。故障性质简单时，采用专用电缆故障定位设备，几十分钟内即可定位，故障特殊时，往往要花费4-5天，甚至更长的时间进行故障定位。下面睿乔电缆教您如何查找电缆故障点！1.低压脉冲法(简称脉冲法)当线路输入一个脉冲电波时，该脉冲便以速度V沿线路传输，当行Lx距离遇到故障点后被反射折回输入端，其往返时间为T，V为
    
                    
    • 
                    
  • SpringBoot3与SpringBoot2的区别
                        bjzhang75
springboot
                        
    文章目录1、JDK环境2、SpringFramework版本3、主要变化和新特性3.1配置变化3.2GraalVM3.3安全性改进3.4性能优化3.4.1启动时间3.4.2内存使用3.5改进的依赖管理3.6全新启动器3.7Kotlin支持SpringBoot3与SpringBoot2的区别1、JDK环境SpringBoot3最低要求JDK17SpringBoot2最低要求JDK82、SpringF
    
                    
    • 
                    
  • 反射弧要长一点
                        想改变的中年大叔

                        
    有些人一点就炸，有些人点了没有反应。前一种人从刺激到反应时间很短，来不及思考；后一种人从刺激到反应时间很长，有足够的时间来思考做出最优的选择。前一种人真性情；后一种人大智慧。前一种人内心简单，容易受挫；后一种人内心强大，逆境依旧坦然。前一种人无法掌握自己；后一种人我命由我不由天。前一种人长远发展靠运气；后一种人长远发展靠自己。让自己的反射弧长一些，长到在面对非常时刻依旧有选择的权利，长到在身体遭受
    
                    
    • 
                    
  • Java-后端程序员个人知识总结
                        金肴羽
java开发语言
                        
    文章目录概要1.编程语言2.数据结构与算法3.数据库知识4.框架和库5.服务器管理6.网络知识7.版本控制8.测试9.安全知识10.系统设计11.编码规范与最佳实践12.持续学习和适应能力概要后端程序员，主要负责应用程序的逻辑、数据库交互、服务器配置以及应用的性能优化等。成为一名优秀的后台程序员，需要掌握以下技能：1.编程语言掌握至少一种后台编程语言JavaPythonHtmlJavaScript
    
                    
    • 
                    
  • 案例分析：如何用设计模式优化性能7
                        是小旭啊
fastapi
                        
    设计模式就是对常用开发技巧进行的总结，它使得程序员之间交流问题，有了更专业、便捷的方式。比如，我们在《02|理论分析：性能优化有章可循，谈谈常用的切入点》中提到，I/O模块使用的是装饰器模式，你就能很容易想到I/O模块的代码组织方式。事实上，大多数设计模式并不能增加程序的性能，它只是代码的一种组织方式。本课时，我们将一一举例讲解和性能相关的几个设计模式，包括代理模式、单例模式、享元模式、原型模式等
    
                    
    • 
                    
  • ELK 架构中 ES 性能优化
                        xianjie0318
elk架构elasticsearch
                        
    1.背景由于目前日志采集流程中,经常遇到用户磁盘IO占用超过90%以上的场景,但是观察其日志量大约在2k~5k之间,整体数据量不大,所以针对该问题进行了一系列的压测和实验验证,最后得出这篇优化建议文档2.压测前期准备2.1制造大量日志该阶段为数据源输入阶段,为了避免瓶颈在数据制造侧,所以需要保证filebeat具有足够的日志制造能力最后效果,filebeat可以达到70kQPS的数据发往logst
    
                    
    • 
                    
  • java高级技术:反射
                        不会编程的阿成
java开发语言
                        
    反射认识反射，获取类获取类中的成分，并对其进行操作作用、应用场景。认识反射，获取类反射：加载类，并允许以编程的方式解剖类中的各种成分（成员变量，方法，构造器等）。反射学什么？学习获取类的信息，操作它们1、反射第一步：加载类，获取类的字节码：Class对象。2、获取类中的构造器：Constructor3、获取类的成员变量：Field对象4、获取类的成员方法:Method对象获取Class对象的三种方
    
                    
    • 
                    
  • 微信小程序中的实时通讯：TCP/UDP 协议实现详解
                        人工智能的苟富贵
前端小程序微信小程序tcp/ipudp
                        
    文章目录前言一、实时通讯的基础知识二、微信小程序中TCP/UDP的支持2.1TCP实现2.2UDP实现三、实现即时通讯的基本架构四、实际开发中的注意事项4.1网络环境问题4.2数据格式与协议设计4.3消息重发机制五、实时通讯中的性能优化5.1减少不必要的通信5.2数据压缩5.3异步通信与心跳机制六、使用场景七、总结前言在现代应用程序中，实时通讯已成为用户体验的关键组成部分。无论是在线聊天、游戏、还
    
                    
    • 
                    
  • Focus Corona第4天作业#何一味Corona渲染课
                        Focus_8490

                        
    本课做皮革和地毯皮革，漫反射加合成贴图，加衰减遮罩，模拟高光的感觉注意，纹理贴图前面要加个颜色校正，以方便改亮度和饱合=============================================================================================================================================
    
                    
    • 
                    
  • 可能我的反射弧长
                        悟空掉毛

                        
    今年工作有调整，我需要有下手，平时要好的一个小妹妹说到我部门工作，大家一起做有兴趣的事情，我觉得很开心。和喜欢的人做喜欢的事，发挥自己的特长，把工作和爱好融为一体，这感觉不要太好！可是前天她突然告诉我姐姐，我不想调动了，我现在的部门也挺好的，也有点呆习惯了，不想打破惯性了，真的非常抱歉。我说没关系，你有这样的想法，我很理解，毕竟新的部门有很多的未知，新的工作也有很多不确定，尊重你的选择。可是今天早
    
                    
    • 
                    
  • 单例模式以及反射对单例模式的破坏及防御
                        CodeDunkster
单例模式javajavascript
                        
    单例模式（SingletonPattern）是一种确保类在应用程序生命周期内只存在一个实例的设计模式。它不仅提供了全局访问点，还能节省内存、控制实例的生命周期。但常见的单例模式实现方式如饿汉式、懒汉式、双重校验锁、静态内部类等，虽然设计良好，但都容易被Java的反射机制所破坏。本文将介绍这些单例实现方式的优缺点、反射如何破坏它们的唯一性，以及如何防御这种破坏。1.单例模式的常见实现方式1.1饿汉式
    
                    
    • 
                    
  • 设计模式-单例模式
                        SAO&asuna
设计模式学习设计模式单例模式开发语言
                        
    文章目录1.为什么要学习单例模式2.单例模式的类型2.1饿汉式单例2.2懒汉式单例2.2.1一般实现2.2.2sync.once实现2.2.3sync.Mutex实现2.2.4原子引用2.2.5极致性能优化3单例模式的优缺点1.为什么要学习单例模式单例模式，就是在整个进程的过程中，只会存在一个实例。这样做的好处主要是两个：访问控制：访问控制也就是只有这一个口子可以得到该实例，一般是通过全局变量达到
    
                    
    • 
                                
  • Java开发中，spring mvc 的线程怎么调用？
                                    小麦麦子
springmvc
                                    
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 
 
问题： 
    在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
    
                                
    • 
                                
  • maven依赖范围
                                    bitcarter
maven
                                    
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 
 
2.compile 只有编译和打包时才会依赖 
 
3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 
 
4.runtime 运行时依赖，编译不依赖 
 
5.默认compile 
 
依赖范围compile是支持传递的，test不支持传递 
 
1.传递的意思是项目A，引用
    
                                
    • 
                                
  • Jaxb org.xml.sax.saxparseexception : premature end of file
                                    darrenzhu
xmlprematureJAXB
                                    
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： 
org.xml.sax.saxparseexception : premature end of file 
很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
    
                                
    • 
                                
  • CSS Specificity
                                    周凡杨
html权重Specificitycss
                                    
      
有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity   
CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。   
    规则： 
  
  HTML标签的权重是1

  Class 的权重是10

  Id 的权重是100


    
                                
    • 
                                
  • java与servlet
                                    g21121
servlet
                                    
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 
下面是java官方网站上对servlet的介绍：  java官网对于servlet的解释 写道   
Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
    
                                
    • 
                                
  • eclipse中安装maven插件
                                    510888780
eclipsemaven
                                    
    1.首先去官网下载 Maven： 
http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 
下载完成之后将其解压， 
我将解压后的文件夹：apache-maven-3.2.3， 
并将它放在 D:\tools目录下， 
即 maven 最终的路径是：D:\tools\apache-mave
    
                                
    • 
                                
  • jpa@OneToOne关联关系
                                    布衣凌宇
jpa
                                    
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 
Nruser实体类 
//***************************************************************** 
@Entity 
@Table(name="nruser") 
@DynamicInsert @Dynam
    
                                
    • 
                                
  • 我的spring学习笔记11-Spring中关于声明式事务的配置
                                    aijuans
spring事务配置
                                    
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
    
                                
    • 
                                
  • java 动态代理简单实现
                                    antlove
javahandlerproxydynamicservice
                                    
    dynamicproxy.service.HelloService 
package dynamicproxy.service;

public interface HelloService {
	public void sayHello();
}
 
  
dynamicproxy.service.impl.HelloServiceImpl 
package dynamicp
    
                                
    • 
                                
  • JDBC连接数据库
                                    百合不是茶
JDBC编程JAVA操作oracle数据库
                                    
          
    如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中; 
  
JDBC链接数据库的代码和固定写法; 
  
  
1,加载oracle数据库的驱动; 
    &nb
    
                                
    • 
                                
  • 单例模式中的多线程分析
                                    bijian1013
javathread多线程java多线程
                                    
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 
饿汉式： 
package com.bijian.study;

public class Singleton {

	private Singleton() {
	}

	// 注意这是private 只供内部调用
	private static
    
                                
    • 
                                
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性
                                    bijian1013
JavaScriptprototype
                                    
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
    
                                
    • 
                                
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource
                                    bit1129
dataSource
                                    
    MyBatis内置了数据源的支持，如： 
  
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<data
    
                                
    • 
                                
  • 我程序中用到的urldecode和base64decode,MD5
                                    bitcarter
cMD5base64decodeurldecode
                                    
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： 
 

string Base64Decode(const char* Data,int DataByte,int& OutByte)
{
    //解码表
    const char DecodeTable[] =
    {
        0, 0, 0, 0, 0, 0
    
                                
    • 
                                
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密
                                    ronin47

                                    
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
    
                                
    • 
                                
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素
                                    bylijinnan
java
                                    
    

public class MinOfShiftedArray {

	/**
	 * Q69 旋转数组的最小元素
	 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。
	 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。
	 */
	publ
    
                                
    • 
                                
  • 看博客，应该是有方向的
                                    Cb123456
反省看博客
                                    
    看博客，应该是有方向的: 
 我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客. 
 我刚突然想到的: 
 1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。 
 2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的. 
  
 为什么要写
    
                                
    • 
                                
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖
                                    comsci
开源项目
                                    
     
 
     为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。 
 
      所以，为避免这种不确定性风险，我
    
                                
    • 
                                
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ）
                                    cwqcwqmax9
sql
                                    
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 
 
 
 
 
Web翻页优化实例 
 提交时间: 2004-6-18 15:37:49      回复    发消息  
 
 
环境： 
Linux ve
    
                                
    • 
                                
  • Hibernat and Ibatis
                                    dashuaifu
Hibernateibatis
                                    
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
    
                                
    • 
                                
  • 备份MYSQL脚本
                                    dcj3sjt126com
mysql
                                    
    #!/bin/sh
# this shell to backup mysql
#[email protected] (QQ:1413161683 DuChengJiu)

_dbDir=/var/lib/mysql/
_today=`date +%w`
_bakDir=/usr/backup/$_today
[ ! -d $_bakDir ] && mkdir -p 
    
                                
    • 
                                
  • iOS第三方开源库的吐槽和备忘
                                    dcj3sjt126com
ios
                                    
    转自 
ibireme的博客       做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。       目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。       首先整理了一份 
Github上排名靠
    
                                
    • 
                                
  • html wlwmanifest.xml
                                    eoems
htmlxml
                                    
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 
 
步骤： 
 
加入到function.php 
 
remove_action('wp_head', 'wp_generator'); 
//wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog 
 
remov
    
                                
    • 
                                
  • 浅谈Java定时器发展
                                    hacksin
java并发timer定时器
                                    
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 
Timer与ScheduleThreadPoolExecutor对比： 
1. 
  
 Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
    
                                
    • 
                                
  • 移动端页面侧边导航滑入效果
                                    ini
jqueryWebhtml5cssjavascirpt
                                    
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： 
<!DOCTYPE html>
<h
    
                                
    • 
                                
  • AspectJ+Javasist记录日志
                                    kane_xie
aspectjjavasist
                                    
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。 
  
@Override
public String get(String key) {
//	long start = System.currentTimeMillis();
//	System.out.println("Be
    
                                
    • 
                                
  • redis学习笔记
                                    MJC410621
redisNoSQL
                                    
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 
1，处理超大量的数据 
2，运行在便宜的PC服务器集群上， 
3，击碎了性能瓶颈。 
1)对数据高并发读写。 
2)对海量数据的高效率存储和访问。 
3)对数据的高扩展性和高可用性。 
 
redis支持的类型： 
 
Sring 类型 
set name lijie 
get name lijie 
set na
    
                                
    • 
                                
  • 使用redis实现分布式锁
                                    qifeifei

                                    
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下： 
  
public Long setnx(final byte[] key, final byte[] value) {
	checkIsInMulti();
	client.setnx(key, value);
	ret
    
                                
    • 
                                
  • BI并非万能，中层业务管理报表要另辟蹊径
                                    张老师的菜
大数据BI商业智能信息化
                                    
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。 
       BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
    
                                
    • 
                                
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题
                                    wudixiaotie
function
                                    
    1.在~/.bashrc最后加入 
[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" 
 2.重新启动terminal输入： 
  
rvm use ruby-2.2.1 --default 
 把当前安装的ruby版本设为默
    
                                
    •