/// <summary>
/// 将di属性写入对象（第2次调用后性能 约等于手写）
/// </summary>
/// <returns></returns>
public static void SetProperty(object obj, Dictionary <string, object> di)
{
if (obj != null)
{
var holder = GetHolder(obj.GetType());
foreach (var kp in di)
{
SetHandler setter = null;
holder.Setters.TryGetValue(kp.Key, out setter);
if (setter == null)
{
continue;
}
var property = holder.PropInfos[kp.Key];
Type t = Nullable.GetUnderlyingType(property.PropertyType)
?? property.PropertyType;
try
{
setter(obj, (kp.Value == null) ? null
: Convert.ChangeType(kp.Value, t));
}
catch (Exception ex)
{
throw new ArgumentException(string.Format("属性'{0}' ({1})设置值'{2}' ({3})发生异常",
kp.Key, t.Name, kp.Value, kp.Value == null ? "null" : kp.Value.GetType().Name
), kp.Key, ex);
}
}
}
}
public NameTable(Dictionary <string, Named> baseLvl, TypingPolicies typing, RetrievalPolicies retrieval)
{
_payload = new List <Dictionary <string, Named> >();
_payload.Add(baseLvl);
switch (typing)
{
case TypingPolicies.STRONG:
HandleSettingConflict = EnforceTyping;
break;
case TypingPolicies.WEAK:
HandleSettingConflict = SetValueAndReturnTrue;
break;
}
switch (retrieval)
{
case RetrievalPolicies.STRICT:
HandleDeclareConflict = ReturnFalse;
HandleMissingVariable = PassThrough;
break;
case RetrievalPolicies.LOOSE:
HandleDeclareConflict = SetValueAndReturnTrue;
HandleMissingVariable = ProvideAndReturnTrue;
break;
}
}
internal static Accessors GetAccessors(PropertyInfo member)
{
if (AccessorsCacheCheck.PropertiesDisabled)
{
return(new Accessors(inst => Helpers.GetPropertyValue(member, inst), (inst, v) => member.SetValue(inst, v, null)));
}
Accessors accessors;
lock (Properties)
{
if (Properties.TryGetValue(member, out accessors))
{
return(accessors);
}
}
GetHandler getter = DynamicMethodCompiler.CreateGetHandler(member.ReflectedType, member) ?? (inst => Helpers.GetPropertyValue(member, inst));
SetHandler setter = DynamicMethodCompiler.CreateSetHandler(member.ReflectedType, member) ?? ((inst, v) => member.SetValue(inst, v, null));
accessors = new Accessors(getter, setter);
lock (Properties)
Properties[member] = accessors;
return(accessors);
}
public static void SetProperty(object obj, string name, object value)
{
if (obj == null || string.IsNullOrWhiteSpace(name))
{
return;
}
var holder = GetHolder(obj.GetType());
SetHandler setter = null;
holder.Setters.TryGetValue(name, out setter);
if (setter == null)
{
return;
}
var property = holder.PropInfos[name];
Type t = Nullable.GetUnderlyingType(property.PropertyType)
?? property.PropertyType;
try
{
setter(obj, (value == null) ? null
: Convert.ChangeType(value, t));
}
catch (Exception ex)
{
throw new ArgumentException(string.Format("属性'{0}' ({1})设置值'{2}' ({3})发生异常",
name, t.Name, value, value == null ? "null" : value.GetType().Name
), name, ex);
}
}
public List <string> FillCardPoolWithSets(int setsAmount, SetHandler setHandler)
{
List <string> ret = new List <string>();
this.upgrades = new List <Upgrade>();
List <string> packagesList = new List <string>();
foreach (var package in setHandler.Sets)
{
packagesList.Add(package.Key);
}
packagesList = packagesList.OrderBy(x => GameHandler.randomGenerator.Next()).ToList();
for (int i = 0; i < setsAmount && i < packagesList.Count(); i++)
{
ret.Add(packagesList[i]);
for (int j = 0; j < setHandler.Sets[packagesList[i]].Count(); j++)
{
this.upgrades.Add((Upgrade)setHandler.Sets[packagesList[i]][j].DeepCopy());
}
}
this.FillSpareParts();
this.FillTokens();
this.GenericMinionPollSort();
return(ret);
}
public MemberMap(PropertyInfo propertyInfo)
{
MemberInfo = propertyInfo;
Type = propertyInfo.PropertyType;
Getter = createGetHandler(propertyInfo);
Setter = createSetHandler(propertyInfo);
}
internal static Accessors GetAccessors(FieldInfo member)
{
if (AccessorsCacheCheck.PropertiesDisabled)
{
return(new Accessors(member.GetValue, member.SetValue));
}
Accessors accessors;
lock (Fields)
{
if (Fields.TryGetValue(member, out accessors))
{
return(accessors);
}
}
GetHandler getter = DynamicMethodCompiler.CreateGetHandler(member.ReflectedType, member) ?? member.GetValue;
SetHandler setter = DynamicMethodCompiler.CreateSetHandler(member.ReflectedType, member) ?? member.SetValue;
accessors = new Accessors(getter, setter);
lock (Fields)
Fields[member] = accessors;
return(accessors);
}
public static SetHandler CreateSetHandler(Type type, PropertyInfo propertyInfo)
{
lock (AppInfo.SetDictionary)
{
if (AppInfo.SetDictionary.ContainsKey(propertyInfo))
{
return(AppInfo.SetDictionary[propertyInfo]);
}
else
{
MethodInfo setMethodInfo = propertyInfo.GetSetMethod(true);
DynamicMethod dynamicSet = CreateSetDynamicMethod(type);
ILGenerator setGenerator = dynamicSet.GetILGenerator();
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldarg_1);
Unbox(setMethodInfo.GetParameters()[0].ParameterType, setGenerator);
setGenerator.Emit(OpCodes.Call, setMethodInfo);
setGenerator.Emit(OpCodes.Ret);
SetHandler setHandler = (SetHandler)dynamicSet.CreateDelegate(typeof(SetHandler));
AppInfo.SetDictionary.Add(propertyInfo, setHandler);
return(setHandler);
}
}
}
public MemberMap(FieldInfo fieldInfo)
{
MemberInfo = fieldInfo;
Type = fieldInfo.FieldType;
Getter = createGetHandler(fieldInfo);
Setter = createSetHandler(fieldInfo);
}
public FieldAccessor(FieldInfo fieldInfo) : base(fieldInfo.Name, fieldInfo.FieldType)
{
_fieldInfo = fieldInfo;
_getHandler = DelegateFactory.CreateGet(fieldInfo);
_setHandler = DelegateFactory.CreateSet(fieldInfo);
_isInternal = _fieldInfo.IsPrivate || _fieldInfo.IsFamily;
}
private void PredProcess(string name, SetHandler set, string path)
{
CheckDirectory(set, path, ProcessEncrypt, name);
while (IsFileLocked(Path.Combine(this.path.SourcePath, path, name)))
{
;
}
}
private void CheckDirectory(SetHandler Set, string directoryName, ProcessHandler process, string fileName)
{
if (!Directory.Exists(Path.Combine(path.SourcePath, directoryName)))
{
Set("ErrorDirectory");
process(fileName);
}
}
public InterpolateFromCurrent(InterpolateHandler InterpolateFunction, ITimer timer,
SetHandler SetCallback, GetHandler GetCallback)
{
this.InterpolateFunction = InterpolateFunction;
this.timer = timer;
timer.SubscribeToTicked(TimerTicked);
timer.SubscribeToFinished(TimerFinished);
Set = SetCallback;
Get = GetCallback;
}
public GameHandler()
{
this.players = new List <Player>();
this.pool = new MinionPool();
this.pool.FillGenericMinionPool();
this.setHandler = new SetHandler();
this.pairsHandler = new PairsHandler();
this.combatOutputCollector = new CombatOutputCollector();
this.shopRarities = new RarityBreakdown(4, 3, 2, 1);
}
public override void OnInspectorGUI()
{
SetHandler _target = target as SetHandler;
EditorGUILayout.BeginVertical();
GUIContent setLabel = new GUIContent("Running Set");
EditorGUILayout.PropertyField(serializedObject.FindProperty("runningSet"), setLabel);
EditorGUILayout.HelpBox("Current object count: " + _target.runningSet.Count.ToString(), MessageType.Info);
EditorGUILayout.EndVertical();
}
public AttributeInfo()
{
this.columnIndex = 0;
this.columnName = "";
this.columnType = DbType.Object;
this.primaryKey = false;
this.autoIncrement = false;
this.nullable = true;
this.property = null;
this.setPropertyHandler = null;
}
private DateTimeResolutionResult ParseEachUnit(string text)
{
var ret = new DateTimeResolutionResult();
// handle "daily", "weekly"
var match = this.config.PeriodicRegex.Match(text);
if (match.Success)
{
// @TODO refactor to pass match
if (!this.config.GetMatchedDailyTimex(text, out string timex))
{
return(ret);
}
ret = SetHandler.ResolveSet(ref ret, timex);
return(ret);
}
// handle "each month"
var exactMatch = this.config.EachUnitRegex.MatchExact(text, trim: true);
if (exactMatch.Success)
{
var sourceUnit = exactMatch.Groups["unit"].Value;
if (string.IsNullOrEmpty(sourceUnit))
{
sourceUnit = exactMatch.Groups["specialUnit"].Value;
}
if (!string.IsNullOrEmpty(sourceUnit) && this.config.UnitMap.ContainsKey(sourceUnit))
{
// @TODO refactor to pass match
if (!this.config.GetMatchedUnitTimex(sourceUnit, out string timex))
{
return(ret);
}
// "handle every other month"
if (exactMatch.Groups["other"].Success)
{
timex = timex.Replace("1", "2");
}
ret = SetHandler.ResolveSet(ref ret, timex);
}
}
return(ret);
}
public static void SetPropertyValue(Object obj, PropertyInfo property, Object value)
{
//创建Set委托
SetHandler setter = DynamicMethodCompiler.CreateSetHandler(obj.GetType(), property);
//先获取该私有成员的数据类型
Type type = property.PropertyType;
//通过数据类型转换
value = TypeUtils.ConvertForType(value, type);
//将值设置到对象中
setter(obj, value);
}
public static void SetFieldValue(Object obj, FieldInfo field, Object value)
{
//创建Set委托
SetHandler setter = DynamicMethodCompiler.CreateSetHandler(obj.GetType(), field);
//先获取该私有成员的数据类型
Type type = field.FieldType;
//通过数据类型转换
value = TypeUtils.ConvertForType(value, type);
//将值设置到对象中
setter(obj, value);
}
/// <summary>
/// Initializes the property and generates the implementation for getter and setter methods.
/// </summary>
public FastPropertyInfo(PropertyInfo property)
{
this.property = property;
if (property.CanWrite)
{
setValueImpl = DynamicMethodCompiler.CreateSetHandler(property.DeclaringType, property);
}
if (property.CanRead)
{
getValueImpl = DynamicMethodCompiler.CreateGetHandler(property.DeclaringType, property);
}
}
/// <summary>
/// Initializes the property and generates the implementation for getter and setter methods.
/// </summary>
public FastPropertyInfo(PropertyInfo property)
{
this.property = property;
if (property.CanWrite)
{
setValueImpl = DynamicMethodCompiler.CreateSetHandler(property.DeclaringType, property);
}
if (property.CanRead)
{
getValueImpl = DynamicMethodCompiler.CreateGetHandler(property.DeclaringType, property);
}
}
GetCachedSetFieldHandlerDelegate(Type type, FieldInfo fieldInfo)
{
int intCachedKey = fieldInfo.GetHashCode();//type.ToString() + "|F|" + fieldInfo.Name;
if (_fieldSetDelegates.ContainsKey(intCachedKey))
{
return((SetHandler)_fieldSetDelegates[intCachedKey]);
}
SetHandler returnValue = CreateSetHandler(type, fieldInfo);
lock (_fieldSetDelegates)
{
_fieldSetDelegates[intCachedKey] = returnValue;
}
return(returnValue);
}
GetCachedSetPropertyHandlerDelegate(Type type, PropertyInfo propertyInfo)
{
int intCachedKey = propertyInfo.GetHashCode();//type.ToString() + "|P|" + propertyInfo.Name;
if (_propertySetDelegates.ContainsKey(intCachedKey))
{
return((SetHandler)_propertySetDelegates[intCachedKey]);
}
SetHandler returnValue = CreateSetHandler(type, propertyInfo);
lock (_propertySetDelegates)
{
_propertySetDelegates[intCachedKey] = returnValue;
}
return(returnValue);
}
private DateTimeResolutionResult ParseEach(IDateTimeExtractor extractor, IDateTimeParser parser, string text, DateObject refDate)
{
var ret = new DateTimeResolutionResult();
List <ExtractResult> ers = null;
var success = false;
// remove key words of set type from text
var match = config.SetEachRegex.Match(text);
if (match.Success)
{
var trimmedText = text.Remove(match.Index, match.Length);
ers = extractor.Extract(trimmedText, refDate);
if (ers.Count == 1 && ers.First().Length == trimmedText.Length)
{
success = true;
}
}
// remove suffix 's' and "on" if existed and re-try
match = this.config.SetWeekDayRegex.Match(text);
if (match.Success)
{
var trimmedText = text.Remove(match.Index, match.Length);
trimmedText = trimmedText.Insert(match.Index, config.WeekDayGroupMatchString(match));
ers = extractor.Extract(trimmedText, refDate);
if (ers.Count == 1 && ers.First().Length == trimmedText.Length)
{
success = true;
}
}
if (success)
{
var pr = parser.Parse(ers[0], refDate);
ret = SetHandler.ResolveSet(ref ret, pr.TimexStr);
}
return(ret);
}
public static void SetValue(BusinessObject obj, PropertyInfo proInfo, object value)
{
string key = obj.AATableName + proInfo.Name;
try
{
SetHandler setHandler = null;
if (lstSetHandler.TryGetValue(key, out setHandler) == false)
{
setHandler = ABCDynamicMethodCompiler.CreateSetHandler(obj.GetType(), proInfo);
lstSetHandler.Add(key, setHandler);
}
setHandler(obj, value);
}
catch (System.Exception ex)
{
proInfo.SetValue(obj, value, null);
}
}
public static void SetValue(BusinessObject obj, String strColName, object value)
{
string key = obj.AATableName + strColName;
try
{
SetHandler setHandler = null;
if (lstSetHandler.TryGetValue(key, out setHandler) == false)
{
Type type = obj.GetType();
PropertyInfo proInfo = BusinessObjectHelper.GetProperty(obj.AATableName, strColName);
if (proInfo == null)
{
proInfo = type.GetProperty(strColName);
}
setHandler = ABCDynamicMethodCompiler.CreateSetHandler(type, proInfo);
lstSetHandler.Add(key, setHandler);
}
if (value is String && value.ToString().Replace("'", "").ToUpper() == "TRUE")
{
value = true;
}
else if (value is String && value.ToString().Replace("'", "").ToUpper() == "FALSE")
{
value = false;
}
setHandler(obj, value);
}
catch (System.Exception ex)
{
PropertyInfo proInfo = obj.GetType().GetProperty(strColName);
if (proInfo == null)
{
// Utilities.ABCLogging.LogNewMessage( "ABCDataLib" , "" , "SetValue" , obj.GetType().Name+" not contain "+strColName , "FAILE" );
return;
}
proInfo.SetValue(obj, value, null);
}
}
private DateTimeResolutionResult ParseEachUnit(string text)
{
var ret = new DateTimeResolutionResult();
// handle "each month"
var match = this.config.EachUnitRegex.MatchExact(text, trim: true);
if (match.Success)
{
var sourceUnit = match.Groups["unit"].Value;
if (!string.IsNullOrEmpty(sourceUnit) && this.config.UnitMap.ContainsKey(sourceUnit))
{
if (this.config.GetMatchedUnitTimex(sourceUnit, out string timexStr))
{
ret = SetHandler.ResolveSet(ref ret, timexStr);
}
}
}
return(ret);
}
private DateTimeResolutionResult ParseEachDuration(string text, DateObject refDate)
{
var ret = new DateTimeResolutionResult();
var ers = this.config.DurationExtractor.Extract(text, refDate);
if (ers.Count != 1 || string.IsNullOrWhiteSpace(text.Substring(ers[0].Start + ers[0].Length ?? 0)))
{
return(ret);
}
var afterStr = text.Substring(ers[0].Start + ers[0].Length ?? 0);
if (this.config.EachPrefixRegex.IsMatch(afterStr))
{
var pr = this.config.DurationParser.Parse(ers[0], DateObject.Now);
ret = SetHandler.ResolveSet(ref ret, pr.TimexStr);
return(ret);
}
return(ret);
}
/// <summary>
/// Creates new <see cref="PropertyBinder"/>, bject that copies value of a
/// property from one object to another object each time the value
/// changes.
/// </summary>
/// <param name="source">Source object</param>
/// <param name="target">Target object</param>
/// <param name="sourceField">Field of the <paramref name="source"/> that is bound to <paramref name="targetField"/></param>
/// <param name="targetField">Field of the <paramref name="target"/> that recieves updated values of from <paramref name="sourceField"/></param>
public PropertyBinder(INotifyPropertyChanged source, object target, string sourceField, string targetField, Dictionary <KeyValuePair <Type, string>, GetHandler> getCache, Dictionary <KeyValuePair <Type, string>, SetHandler> setCache)
{
Source = source;
Target = target;
SourceField = sourceField;
TargetField = targetField;
Source.PropertyChanged += Source_PropertyChanged;
KeyValuePair <Type, string> keyGet = new KeyValuePair <Type, string>(source.GetType(), sourceField);
KeyValuePair <Type, string> keySet = new KeyValuePair <Type, string>(target.GetType(), targetField);
if (getCache.ContainsKey(keyGet))
{
sourceGetHandler = getCache[keyGet];
}
else
{
PropertyInfo sourceProp = Source.GetType().GetProperty(SourceField);
sourceGetHandler = DynamicMethodCompiler.CreateGetHandler(Source.GetType(), sourceProp); /**/
getCache[keyGet] = sourceGetHandler;
}
if (getCache.ContainsKey(keySet))
{
targetSetHandler = setCache[keySet];
}
if (targetSetHandler == null)
{
PropertyInfo targetProp = Target.GetType().GetProperty(TargetField); /**/
targetSetHandler = DynamicMethodCompiler.CreateSetHandler(Target.GetType(), targetProp); /**/
setCache[keySet] = targetSetHandler;
}
//Debug.Assert(sourceProp != null, "Source property not found");
//Debug.Assert(targetProp != null, "Target property not found");
Source_PropertyChanged(null, new PropertyChangedEventArgs(SourceField));
}
private DateTimeResolutionResult ParserTimeEveryday(string text, DateObject refDate)
{
var ret = new DateTimeResolutionResult();
var ers = this.config.TimeExtractor.Extract(text, refDate);
if (ers.Count != 1)
{
return(ret);
}
var afterStr = text.Replace(ers[0].Text, string.Empty);
var match = this.config.EachDayRegex.Match(afterStr);
if (match.Success)
{
var pr = this.config.TimeParser.Parse(ers[0], DateObject.Now);
ret = SetHandler.ResolveSet(ref ret, pr.TimexStr);
}
return(ret);
}
private DateTimeResolutionResult ParseEach(IDateTimeExtractor extractor, IDateTimeParser parser, string text, DateObject refDate)
{
var ret = new DateTimeResolutionResult();
var ers = extractor.Extract(text, refDate);
var success = false;
foreach (var er in ers)
{
var beforeStr = text.Substring(0, er.Start ?? 0);
var match = this.config.EachPrefixRegex.Match(beforeStr);
if (match.Success && match.Length + er.Length == text.Length)
{
success = true;
}
else if (er.Type == Constants.SYS_DATETIME_TIME || er.Type == Constants.SYS_DATETIME_DATE)
{
// Cases like "every day at 2pm" or "every year on April 15th"
var eachRegex = er.Type == Constants.SYS_DATETIME_TIME ? this.config.EachDayRegex : this.config.EachDateUnitRegex;
match = eachRegex.Match(beforeStr);
if (match.Success && match.Length + er.Length == text.Length)
{
success = true;
}
}
if (success)
{
var pr = parser.Parse(er, refDate);
ret = SetHandler.ResolveSet(ref ret, pr.TimexStr);
break;
}
}
return(ret);
}
// CreateSetDelegate
public static SetHandler CreateSetHandler(Type type, PropertyInfo propertyInfo)
{
string _key = string.Format("{0}.{1}", propertyInfo.DeclaringType, propertyInfo.ToString());
if (s_SetHandlerCache.ContainsKey(_key))
{
return(s_SetHandlerCache[_key] as SetHandler);
}
MethodInfo setMethodInfo = propertyInfo.GetSetMethod(true);
DynamicMethod dynamicSet = CreateSetDynamicMethod(type);
ILGenerator setGenerator = dynamicSet.GetILGenerator();
setGenerator.Emit(OpCodes.Ldarg_0);
setGenerator.Emit(OpCodes.Ldarg_1);
UnboxIfNeeded(setMethodInfo.GetParameters()[0].ParameterType, setGenerator);
setGenerator.Emit(OpCodes.Call, setMethodInfo);
setGenerator.Emit(OpCodes.Ret);
SetHandler _newHandler = (SetHandler)dynamicSet.CreateDelegate(typeof(SetHandler));
s_SetHandlerCache.Add(_key, _newHandler);
return(_newHandler);
}
