Here are the examples of the csharp api System.Type.GetConstructor(System.Type[]) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
1711 Examples
19
View Source File : ModEntry.cs
License : GNU General Public License v3.0
Project Creator : aedenthorn
License : GNU General Public License v3.0
Project Creator : aedenthorn
public override void Entry(IModHelper helper)
{
config = Helper.ReadConfig<ModConfig>();
if (!config.EnableMod)
return;
PMonitor = Monitor;
PHelper = helper;
Helper.Events.GameLoop.GameLaunched += GameLoop_GameLaunched;
Helper.Events.GameLoop.SaveLoaded += GameLoop_SaveLoaded;
Helper.Events.GameLoop.DayStarted += GameLoop_DayStarted;
tilesTexture = Helper.Content.Load<Texture2D>("replacedets/tiles.png");
waterTexture = Helper.Content.Load<Texture2D>("replacedets/water.png");
var harmony = new Harmony(ModManifest.UniqueID);
ConstructorInfo ci = typeof(Farm).GetConstructor(new Type[] { typeof(string), typeof(string) });
harmony.Patch(
original: ci,
postfix: new HarmonyMethod(typeof(ModEntry), nameof(Farm_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farm), "_UpdateWaterBowl"),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(_UpdateWaterBowl_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Pet), nameof(Pet.setAtFarmPosition)),
prefix: new HarmonyMethod(typeof(ModEntry), nameof(setAtFarmPosition_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Game1), nameof(Game1.loadForNewGame)),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(loadForNewGame_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.checkForAction)),
prefix: new HarmonyMethod(typeof(ModEntry), nameof(checkForAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.placementAction)),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(placementAction_Postfix))
);
var hm = new HarmonyMethod(typeof(ModEntry), nameof(performRemoveAction_Prefix));
hm.priority = Priority.First;
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.performRemoveAction)),
prefix: hm
);
hm = new HarmonyMethod(typeof(ModEntry), nameof(performToolAction_Postfix));
hm.priority = Priority.First;
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.performToolAction)),
postfix: hm
);
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.draw), new Type[] { typeof(SpriteBatch), typeof(int), typeof(int), typeof(float), typeof(float) }),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.Object_draw_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.draw), new Type[] { typeof(SpriteBatch), typeof(int), typeof(int), typeof(float) }),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.Object_draw_Postfix2))
);
}
19
View Source File : TypeExtend.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
public static Func<TArg, TRes> CreateFunc<TArg, TRes>(TypeInfo callInfo, string methodName, TypeInfo argInfo, TypeInfo resInfo)
{
var typeConstructor = resInfo.GetConstructor(Type.EmptyTypes);
if (typeConstructor == null)
throw new ArgumentException($"类型{callInfo.FullName}没有无参构造函数");
var innerMethod = callInfo.GetMethod(methodName);
if (innerMethod == null)
throw new ArgumentException($"类型{callInfo.FullName}没有名称为{methodName}的方法");
if (innerMethod.ReturnType != resInfo)
throw new ArgumentException($"类型{callInfo.FullName}的方法{methodName}返回值不为{resInfo.FullName}");
var args = innerMethod.GetParameters();
if (args.Length != 1)
throw new ArgumentException($"类型{callInfo.FullName}的方法{methodName}参数不是一个");
if (args[0].ParameterType != argInfo)
throw new ArgumentException($"类型{callInfo.FullName}的方法{methodName}唯一参数不为{argInfo.FullName}");
//构造匿名方法
var callMethod = new DynamicMethod(methodName, typeof(TRes), new[] { typeof(TArg) });
//构造动态IL(方法内部实现)
var il = callMethod.GetILGenerator();
il.Emit(OpCodes.Nop);
//1 参数类型转换
il.Emit(OpCodes.Ldarg, 0);
il.Emit(OpCodes.Castclreplaced, argInfo);
var arg = il.DeclareLocal(argInfo);
il.Emit(OpCodes.Stloc, arg);
//2 调用对象构造
il.Emit(OpCodes.Newobj, typeConstructor);
var call = il.DeclareLocal(callInfo);
il.Emit(OpCodes.Stloc, call);
//3 方法调用
il.Emit(OpCodes.Ldloc, call);
il.Emit(OpCodes.Ldloc, arg);
il.Emit(OpCodes.Callvirt, innerMethod);
var ret = il.DeclareLocal(innerMethod.ReturnType);
//4 返回值转换
il.Emit(OpCodes.Stloc, ret);
il.Emit(OpCodes.Ldloc, ret);
il.Emit(OpCodes.Castclreplaced, typeof(TRes).GetTypeInfo());
var res = il.DeclareLocal(resInfo);
//5 返回
il.Emit(OpCodes.Stloc, res);
il.Emit(OpCodes.Ldloc, res);
il.Emit(OpCodes.Ret);
//返回动态委托
return callMethod.CreateDelegate(typeof(Func<TArg, TRes>)) as Func<TArg, TRes>;
}
19
View Source File : Utility.Reflection.cs
License : MIT License
Project Creator : 7Bytes-Studio
License : MIT License
Project Creator : 7Bytes-Studio
public static bool HasConstructor(Type type,params Type[] types)
{
return null!=type.GetConstructor(types);
}
19
View Source File : TokenTypes.Keywords.cs
License : MIT License
Project Creator : adamant
License : MIT License
Project Creator : adamant
private static Func<TextSpan, T> CompileFactory<T>(Type tokenType)
where T : IToken
{
var spanParam = Expression.Parameter(typeof(TextSpan), "span");
var newExpression = Expression.New(tokenType.GetConstructor(new[] { typeof(TextSpan) }), spanParam);
var factory =
Expression.Lambda<Func<TextSpan, T>>(
newExpression, spanParam);
return factory.Compile();
}
19
View Source File : EntityCache.cs
License : Apache License 2.0
Project Creator : aadreja
License : Apache License 2.0
Project Creator : aadreja
internal static T CloneObjectWithIL<T>(T enreplacedy)
{
Type mainType = typeof(T);
if (!CachedCloneIL.TryGetValue(mainType, out Delegate cloneIL))
{
// Create ILGenerator
DynamicMethod dymMethod = new DynamicMethod("DoClone", mainType, new Type[] { mainType }, true);
ConstructorInfo cInfo = mainType.GetConstructor(new Type[] { });
ILGenerator generator = dymMethod.GetILGenerator();
LocalBuilder lbf = generator.DeclareLocal(mainType);
//lbf.SetLocalSymInfo("_temp");
generator.Emit(OpCodes.Newobj, cInfo); //create new instance of object
generator.Emit(OpCodes.Stloc_0); //load in memory
Type type = mainType;
while (type != null && type != typeof(object))
{
foreach (FieldInfo field in type.GetFields(BindingFlags.Instance
| BindingFlags.Public
| BindingFlags.NonPublic))
{
// Load the new object on the eval stack... (currently 1 item on eval stack)
generator.Emit(OpCodes.Ldloc_0);
// Load initial object (parameter) (currently 2 items on eval stack)
generator.Emit(OpCodes.Ldarg_0);
// Replace value by field value (still currently 2 items on eval stack)
generator.Emit(OpCodes.Ldfld, field);
// Store the value of the top on the eval stack into the object underneath that value on the value stack.
// (0 items on eval stack)
generator.Emit(OpCodes.Stfld, field);
}
type = type.BaseType;
}
// Load new constructed obj on eval stack -> 1 item on stack
generator.Emit(OpCodes.Ldloc_0);
// Return constructed object. --> 0 items on stack
generator.Emit(OpCodes.Ret);
cloneIL = dymMethod.CreateDelegate(typeof(Func<T, T>));
CachedCloneIL.Add(mainType, cloneIL);
}
return ((Func<T, T>)cloneIL)(enreplacedy);
}
19
View Source File : Function.cs
License : GNU Affero General Public License v3.0
Project Creator : 3CORESec
License : GNU Affero General Public License v3.0
Project Creator : 3CORESec
private void initConfig()
{
_alerts = new List<ISender>();
config = JsonConvert.DeserializeObject<Config>(File.ReadAllText("config.json"));
if (string.IsNullOrEmpty(config.SlackPath))
config.SlackPath = Environment.GetEnvironmentVariable("SLACKPATH");
if (string.IsNullOrEmpty(config.WebhookChannel))
config.WebhookChannel = Environment.GetEnvironmentVariable("WEBHOOKCHANNEL");
if (string.IsNullOrEmpty(config.WebHookToken))
config.WebHookToken = Environment.GetEnvironmentVariable("WEBHOOKTOKEN");
if (string.IsNullOrEmpty(config.PostUrl))
config.PostUrl = Environment.GetEnvironmentVariable("POSTURL");
var type = typeof(ISender);
var types = AppDomain.CurrentDomain.Getreplacedemblies()
.SelectMany(s => s.GetTypes())
.Where(p => type.IsreplacedignableFrom(p) && !p.IsInterface && !p.IsAbstract);
types.ToList().ForEach(type => {
ConstructorInfo ctor = type.GetConstructor(new[] { typeof(Storage<SessionLog>), typeof(Config), typeof(IMemoryCache) });
ISender instance = ctor.Invoke(new object[] { _storage, config, memoryCache }) as ISender;
_alerts.Add(instance);
});
}
19
View Source File : ExecutionObserverInjector.cs
License : MIT License
Project Creator : AElfProject
License : MIT License
Project Creator : AElfProject
public static TypeDefinition ConstructCounterProxy(ModuleDefinition module, string nmspace)
{
var observerType = new TypeDefinition(
nmspace, nameof(ExecutionObserverProxy),
TypeAttributes.Sealed | TypeAttributes.Abstract | TypeAttributes.Public | TypeAttributes.Clreplaced,
module.ImportReference(typeof(object))
);
var observerField = new FieldDefinition(
"_observer",
FieldAttributes.Private | FieldAttributes.Static,
module.ImportReference(typeof(IExecutionObserver)
)
);
// Counter field should be thread static (at least for the test cases)
observerField.CustomAttributes.Add(new CustomAttribute(
module.ImportReference(typeof(ThreadStaticAttribute).GetConstructor(new Type[]{}))));
observerType.Fields.Add(observerField);
observerType.Methods.Add(ConstructProxySetObserverMethod(module, observerField));
observerType.Methods.Add(ConstructProxyBranchCountMethod(module, observerField));
observerType.Methods.Add(ConstructProxyCallCountMethod(module, observerField));
return observerType;
}
19
View Source File : ICollectionResolverTest_TypeIsCollection.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void GenerICollectionImpl_SameItemTypeColloctionCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_GenerICollection_Int_SameItemTypeColloctionCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(int));
constructor.Is(typeof(_GenerICollection_Int_SameItemTypeColloctionCtor).GetConstructor(new Type[] { typeof(List<int>) }));
isImplGenerICollec.IsTrue();
}
19
View Source File : ZeroDiscover.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
public static Func<TRes> CreateFunc<TRes>(TypeInfo callInfo, string methodName, TypeInfo resInfo)
{
ConstructorInfo constructor = callInfo.GetConstructor(Type.EmptyTypes);
if (constructor == (ConstructorInfo)null)
throw new ArgumentException("类型" + callInfo.FullName + "没有无参构造函数");
MethodInfo method = callInfo.GetMethod(methodName);
if (method == (MethodInfo)null)
throw new ArgumentException("类型" + callInfo.FullName + "没有名称为" + methodName + "的方法");
if (method.ReturnType != (Type)resInfo)
throw new ArgumentException("类型" + callInfo.FullName + "的方法" + methodName + "返回值不为" + resInfo.FullName);
if ((uint)method.GetParameters().Length > 0U)
throw new ArgumentException("类型" + callInfo.FullName + "的方法" + methodName + "参数不为空");
DynamicMethod dynamicMethod = new DynamicMethod(methodName, typeof(TRes), (Type[])null);
ILGenerator ilGenerator = dynamicMethod.GetILGenerator();
ilGenerator.Emit(OpCodes.Nop);
ilGenerator.Emit(OpCodes.Newobj, constructor);
LocalBuilder local1 = ilGenerator.DeclareLocal((Type)callInfo);
ilGenerator.Emit(OpCodes.Stloc, local1);
ilGenerator.Emit(OpCodes.Ldloc, local1);
ilGenerator.Emit(OpCodes.Callvirt, method);
LocalBuilder local2 = ilGenerator.DeclareLocal(method.ReturnType);
ilGenerator.Emit(OpCodes.Stloc, local2);
ilGenerator.Emit(OpCodes.Ldloc, local2);
ilGenerator.Emit(OpCodes.Castclreplaced, (Type)typeof(TRes).GetTypeInfo());
LocalBuilder local3 = ilGenerator.DeclareLocal((Type)resInfo);
ilGenerator.Emit(OpCodes.Stloc, local3);
ilGenerator.Emit(OpCodes.Ldloc, local3);
ilGenerator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(typeof(Func<TRes>)) as Func<TRes>;
}
19
View Source File : ICollectionResolverTest_TypeIsCollection.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void ICollectionImpl_ObjecreplacedemTypeColloctionCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_ICollection_ObjecreplacedemTypeColloctionCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(object));
constructor.Is(typeof(_ICollection_ObjecreplacedemTypeColloctionCtor).GetConstructor(new Type[] { typeof(List<object>) }));
}
19
View Source File : Cloner.cs
License : GNU General Public License v3.0
Project Creator : Adam-Wilkinson
License : GNU General Public License v3.0
Project Creator : Adam-Wilkinson
public static bool TryClone<T>(T toClone, out T newObject)
{
if (toClone.GetType().IsValueType)
{
newObject = toClone;
return true;
}
if (toClone is ICloneable cloneable)
{
newObject = (T)cloneable.Clone();
return true;
}
Debug.WriteLine(toClone.GetType());
if (Cloners.TryGetValue(toClone.GetType(), out IObjectCloner cloner))
{
newObject = (T)cloner.Clone(toClone);
return true;
}
if (toClone.GetType().GetConstructor(Type.EmptyTypes) == null)
{
newObject = (T)Activator.CreateInstance(toClone.GetType());
return false;
}
newObject = default;
return false;
}
19
View Source File : StringToVxColorConverter.cs
License : MIT License
Project Creator : Aaltuj
License : MIT License
Project Creator : Aaltuj
public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(InstanceDescriptor) && value is VxColor)
{
VxColor obj = value as VxColor;
ConstructorInfo ctor = typeof(VxColor).GetConstructor(new Type[] { typeof(string) });
if (ctor != null)
{
return new InstanceDescriptor(ctor, new object[] { obj.Value });
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
19
View Source File : Serializer.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
static Func<T, Dictionary<string, string>> CompileSerializer()
{
var o_t = typeof(T);
var o = Expression.Parameter(o_t, "original");
var o_get_object_data = o_t.GetMethod("GetObjectData");
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Variable(d_t, "d"); // define object variable
var d_init = Expression.MemberInit(Expression.New(d_t)); // object ctor
var d_add = d_t.GetMethod("Add"); // add method
var fc_t = typeof(IFormatterConverter);// typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(typeof(System.Runtime.Serialization.FormatterConverter))); //Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_get_enumerator = info_t.GetMethod("GetEnumerator");
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(SerializationInfoEnumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_name = Expression.Property(enumerator, "Name");
var enumerator_value = Expression.Property(enumerator, "Value");
var mi_to_string = typeof(Object).GetMethod("ToString", new Type[0]);
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { d, fc, info, ctx },
Expression.replacedign(d, d_init),
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.Call(o, o_get_object_data, info, ctx),
Expression.Block(new[] { enumerator },
Expression.replacedign(enumerator, Expression.Call(info, info_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_move_next), // test
Expression.IfThen(
Expression.NotEqual(enumerator_value, Expression.Constant(null)),
Expression.Call(d, d_add, enumerator_name, Expression.Call(enumerator_value, mi_to_string))
),
Expression.Break(exit_loop)), // if false
exit_loop)),
d); // return
// compile
return Expression.Lambda<Func<T, Dictionary<string, string>>>(body, o)
.Compile();
}
19
View Source File : ModEntry.cs
License : GNU General Public License v3.0
Project Creator : aedenthorn
License : GNU General Public License v3.0
Project Creator : aedenthorn
public override void Entry(IModHelper helper)
{
context = this;
Config = Helper.ReadConfig<ModConfig>();
if (!Config.EnableMod)
return;
AMFPatches.Initialize(this);
Helper.Events.GameLoop.GameLaunched += GameLoop_GameLaunched;
Helper.Events.GameLoop.SaveLoaded += GameLoop_SaveLoaded;
Helper.Events.GameLoop.UpdateTicking += GameLoop_UpdateTicking;
Helper.Events.Input.ButtonPressed += Input_ButtonPressed;
Helper.Events.Player.InventoryChanged += Player_InventoryChanged;
myRand = new Random();
var harmony = HarmonyInstance.Create(ModManifest.UniqueID);
harmony.Patch(
original: AccessTools.Method(typeof(MeleeWeapon), "doAnimateSpecialMove"),
prefix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches.doAnimateSpecialMove_Prefix))
);
ConstructorInfo ci = typeof(MeleeWeapon).GetConstructor(new Type[] { typeof(int) });
harmony.Patch(
original: ci,
postfix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches.MeleeWeapon_Postfix))
);
ci = typeof(MeleeWeapon).GetConstructor(new Type[] { });
harmony.Patch(
original: ci,
postfix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches.MeleeWeapon_Postfix))
);
ci = typeof(MeleeWeapon).GetConstructor(new Type[] { typeof(int), typeof(int) });
harmony.Patch(
original: ci,
postfix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches.MeleeWeapon_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(MeleeWeapon), nameof(MeleeWeapon.drawInMenu), new Type[] { typeof(SpriteBatch), typeof(Vector2), typeof(float), typeof(float), typeof(float), typeof(StackDrawType), typeof(Color), typeof(bool) }),
prefix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches.drawInMenu_Prefix)),
postfix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches.drawInMenu_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(BaseEnchantment), "_OnDealDamage"),
prefix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches._OnDealDamage_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(BaseEnchantment), "_OnMonsterSlay"),
prefix: new HarmonyMethod(typeof(AMFPatches), nameof(AMFPatches._OnMonsterSlay_Prefix))
);
}
19
View Source File : IDictionaryResolverTest_TypeIsIDictionary.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void GenerDictionary_SameItemTypeIDictionaryCtor_IsDictionary()
{
IDictionaryResolver.TypeIsDictionary(typeof(_GenerDictionary_SameItemTypeIDictionaryCtor),
out ConstructorInfo constructor, out bool typeIsGeneric, out Type genericTypeDefinition, out Type genericKeyType, out Type genericValueType)
.IsTrue();
genericKeyType.Is(typeof(int));
genericValueType.Is(typeof(int));
constructor.Is(typeof(_GenerDictionary_SameItemTypeIDictionaryCtor).GetConstructor(new Type[] { typeof(Dictionary<int, int>) }));
}
19
View Source File : ModEntry.cs
License : GNU General Public License v3.0
Project Creator : aedenthorn
License : GNU General Public License v3.0
Project Creator : aedenthorn
public override void Entry(IModHelper helper)
{
config = Helper.ReadConfig<ModConfig>();
if (!config.EnableMod)
return;
PMonitor = Monitor;
PHelper = helper;
mp = helper.Reflection.GetField<Multiplayer>(typeof(Game1), "multiplayer").GetValue();
myRand = new Random();
helper.Events.GameLoop.GameLaunched += HelperEvents.GameLoop_GameLaunched;
helper.Events.GameLoop.SaveLoaded += HelperEvents.GameLoop_SaveLoaded;
helper.Events.Input.ButtonPressed += HelperEvents.Input_ButtonPressed;
helper.Events.GameLoop.DayStarted += HelperEvents.GameLoop_DayStarted;
helper.Events.GameLoop.DayEnding += HelperEvents.GameLoop_DayEnding;
helper.Events.GameLoop.ReturnedToreplacedle += HelperEvents.GameLoop_ReturnedToreplacedle;
NPCPatches.Initialize(Monitor, config);
LocationPatches.Initialize(Monitor);
FarmerPatches.Initialize(Monitor, Helper);
Maps.Initialize(Monitor);
Kissing.Initialize(Monitor);
UIPatches.Initialize(Monitor, Helper);
EventPatches.Initialize(Monitor, Helper);
HelperEvents.Initialize(Monitor, Helper);
FileIO.Initialize(Monitor, Helper);
Misc.Initialize(Monitor, Helper, config);
Divorce.Initialize(Monitor, Helper);
FurniturePatches.Initialize(Monitor, Helper, config);
ObjectPatches.Initialize(Monitor, Helper, config);
NetWorldStatePatches.Initialize(Monitor, Helper, config);
var harmony = new Harmony(ModManifest.UniqueID);
// npc patches
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.marriageDuties)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_marriageDuties_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.getSpouse)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_getSpouse_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.isRoommate)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_isRoommate_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.isMarried)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_isMarried_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.isMarriedOrEngaged)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_isMarriedOrEngaged_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.tryToReceiveActiveObject)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToReceiveActiveObject_Prefix)),
transpiler: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToReceiveActiveObject_Transpiler)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToReceiveActiveObject_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.checkAction)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_checkAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.spouseObstacleCheck)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_spouseObstacleCheck_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), "engagementResponse"),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_engagementResponse_Prefix)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_engagementResponse_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.playSleepingAnimation)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_playSleepingAnimation_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.GetDispositionModifiedString)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_GetDispositionModifiedString_Prefix)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_GetDispositionModifiedString_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), "loadCurrentDialogue"),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_loadCurrentDialogue_Prefix)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_loadCurrentDialogue_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.tryToRetrieveDialogue)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToRetrieveDialogue_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.setSpouseRoomMarriageDialogue)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_setSpouseRoomMarriageDialogue_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.setRandomAfternoonMarriageDialogue)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_setRandomAfternoonMarriageDialogue_Prefix))
);
// Child patches
harmony.Patch(
original: typeof(Character).GetProperty("displayName").GetMethod,
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Character_displayName_Getter_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Child), nameof(Child.reloadSprite)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Child_reloadSprite_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Child), nameof(Child.resetForPlayerEntry)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Child_resetForPlayerEntry_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Child), nameof(Child.dayUpdate)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Child_dayUpdate_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Child), nameof(Child.isInCrib)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Child_isInCrib_Prefix))
);
/*
harmony.Patch(
original: AccessTools.Method(typeof(Child), nameof(Child.tenMinuteUpdate)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Child_tenMinuteUpdate_Postfix))
);
*/
// Location patches
harmony.Patch(
original: AccessTools.Method(typeof(Beach), nameof(Beach.checkAction)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.Beach_checkAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(ManorHouse), nameof(ManorHouse.performAction)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.ManorHouse_performAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.checkAction)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_checkAction_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.updateFarmLayout)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_updateFarmLayout_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.getWalls)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_getWalls_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.getFloors)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_getFloors_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(GameLocation), nameof(GameLocation.performAction)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.GameLocation_performAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(GameLocation), nameof(GameLocation.answerDialogue)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.GameLocation_answerDialogue_prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), "resetLocalState"),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_resetLocalState_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Beach), "resetLocalState"),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.Beach_resetLocalState_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(GameLocation), "checkEventPrecondition"),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.GameLocation_checkEventPrecondition_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.performTenMinuteUpdate)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_performTenMinuteUpdate_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Desert), nameof(Desert.getDesertMerchantTradeStock)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.Desert_getDesertMerchantTradeStock_Postfix))
);
// pregnancy patches
harmony.Patch(
original: AccessTools.Method(typeof(Utility), nameof(Utility.pickPersonalFarmEvent)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.Utility_pickPersonalFarmEvent_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(QuestionEvent), nameof(QuestionEvent.setUp)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.QuestionEvent_setUp_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(BirthingEvent), nameof(BirthingEvent.setUp)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.BirthingEvent_setUp_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(BirthingEvent), nameof(BirthingEvent.tickUpdate)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.BirthingEvent_tickUpdate_Prefix))
);
// Farmer patches
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.doDivorce)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_doDivorce_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.isMarried)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_isMarried_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.getSpouse)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_getSpouse_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.checkAction)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_checkAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.GetSpouseFriendship)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_GetSpouseFriendship_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.getChildren)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_getChildren_Prefix))
);
// UI patches
harmony.Patch(
original: AccessTools.Method(typeof(SocialPage), "drawNPCSlot"),
prefix: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.SocialPage_drawNPCSlot_prefix)),
transpiler: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.SocialPage_drawSlot_transpiler))
);
harmony.Patch(
original: AccessTools.Method(typeof(SocialPage), "drawFarmerSlot"),
transpiler: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.SocialPage_drawSlot_transpiler))
);
harmony.Patch(
original: typeof(DialogueBox).GetConstructor(new Type[] { typeof(List<string>) }),
prefix: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.DialogueBox_Prefix))
);
// Event patches
harmony.Patch(
original: AccessTools.Method(typeof(Event), nameof(Event.answerDialogueQuestion)),
prefix: new HarmonyMethod(typeof(EventPatches), nameof(EventPatches.Event_answerDialogueQuestion_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Event), "setUpCharacters"),
postfix: new HarmonyMethod(typeof(EventPatches), nameof(EventPatches.Event_setUpCharacters_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Event), nameof(Event.command_playSound)),
prefix: new HarmonyMethod(typeof(EventPatches), nameof(EventPatches.Event_command_playSound_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Event), nameof(Event.command_loadActors)),
prefix: new HarmonyMethod(typeof(EventPatches), nameof(EventPatches.Event_command_loadActors_Prefix)),
postfix: new HarmonyMethod(typeof(EventPatches), nameof(EventPatches.Event_command_loadActors_Postfix))
);
// Object patches
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.draw), new Type[] { typeof(SpriteBatch), typeof(int), typeof(int), typeof(float) }),
prefix: new HarmonyMethod(typeof(ObjectPatches), nameof(ObjectPatches.Object_draw_Prefix))
);
// Furniture patches
harmony.Patch(
original: AccessTools.Method(typeof(BedFurniture), nameof(BedFurniture.draw), new Type[] { typeof(SpriteBatch), typeof(int), typeof(int), typeof(float) }),
prefix: new HarmonyMethod(typeof(FurniturePatches), nameof(FurniturePatches.BedFurniture_draw_Prefix))
);
// Game1 patches
harmony.Patch(
original: AccessTools.Method(typeof(Game1), nameof(Game1.prepareSpouseForWedding)),
prefix: new HarmonyMethod(typeof(Game1Patches), nameof(Game1Patches.prepareSpouseForWedding_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Game1), nameof(Game1.getCharacterFromName), new Type[] { typeof(string), typeof(bool), typeof(bool) }),
prefix: new HarmonyMethod(typeof(Game1Patches), nameof(Game1Patches.getCharacterFromName_Prefix))
);
// NetWorldState patch
harmony.Patch(
original: AccessTools.Method(typeof(NetWorldState), nameof(NetWorldState.hasWorldStateID)),
prefix: new HarmonyMethod(typeof(NetWorldStatePatches), nameof(NetWorldStatePatches.hasWorldStateID_Prefix))
);
}
19
View Source File : Ryder.Lightweight.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
public static bool TryPrepareMethod(MethodBase method, RuntimeMethodHandle handle)
{
// First, try the good ol' RuntimeHelpers.PrepareMethod.
if (PrepareMethod != null)
{
PrepareMethod(handle);
return true;
}
// No chance, we gotta go lower.
// Invoke the method with uninitialized arguments.
object sender = null;
object[] GetArguments(ParameterInfo[] parameters)
{
object[] args = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo param = parameters[i];
if (param.HasDefaultValue)
args[i] = param.DefaultValue;
else if (param.ParameterType.GetTypeInfo().IsValueType)
args[i] = Activator.CreateInstance(param.ParameterType);
else
args[i] = null;
}
return args;
}
if (!method.IsStatic)
{
// Gotta make the instance
Type declaringType = method.DeclaringType;
if (declaringType.GetTypeInfo().IsValueType)
{
sender = Activator.CreateInstance(declaringType);
}
else if (declaringType.GetTypeInfo().IsAbstract)
{
// Overkill solution: Find a type in the replacedembly that implements the declaring type,
// and use it instead.
throw new InvalidOperationException("Cannot manually JIT a method");
}
else if (GetUninitializedObject != null)
{
sender = GetUninitializedObject(declaringType);
}
else
{
/* TODO
* Since I just made the whole 'gotta JIT the method' step mandatory
* in the MethodRedirection ctor, i should make sure this always returns true.
* That means looking up every type for overriding types for the throwing step above,
* and testing every possible constructor to create the instance.
*
* Additionally, if we want to go even further, we can repeat this step for every
* single argument of the ctor, thus making sure that we end up having an actual clreplaced.
* In this case, unless the user wants to instantiate an abstract clreplaced with no overriding clreplaced,
* everything'll work. HOWEVER, performances would be less-than-ideal. A simple Redirection
* may mean scanning the replacedembly a dozen times for overriding types, calling their constructors
* hundreds of times, knowing that all of them will be slow (Reflection + Try/Catch blocks aren't
* perfs-friendly).
*/
ConstructorInfo ctor = declaringType.GetConstructor(Type.EmptyTypes);
if (ctor != null)
{
sender = ctor.Invoke(null);
}
else
{
ConstructorInfo[] ctors = declaringType.GetConstructors(ALL_INSTANCE);
Array.Sort(ctors, (a, b) => a.GetParameters().Length.CompareTo(b.GetParameters().Length));
ctor = ctors[0];
try
{
sender = ctor.Invoke(GetArguments(ctor.GetParameters()));
}
catch (TargetInvocationException)
{
// Nothing we can do, give up.
return false;
}
}
}
}
try
{
method.Invoke(sender, GetArguments(method.GetParameters()));
}
catch (TargetInvocationException)
{
// That's okay.
}
return true;
}
19
View Source File : Serializer.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
static Func<Dictionary<string, string>, T> CompileDeserializer()
{
var o_t = typeof(T);
var o_ctor = o_t.GetConstructor(new[] { typeof(SerializationInfo), typeof(StreamingContext) });
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Parameter(d_t, "d");
var d_mi_get_enumerator = d_t.GetMethod("GetEnumerator");
var fc_t = typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_mi_add_value = info_t.GetMethod("AddValue", new[] { typeof(String), typeof(Object) });
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(Dictionary<string, string>.Enumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_mi_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_current = Expression.Property(enumerator, "Current");
var kvp_t = typeof(KeyValuePair<string, string>);
var kvp_pi_key = kvp_t.GetProperty("Key");
var kvp_pi_value = kvp_t.GetProperty("Value");
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { fc, info, ctx, enumerator },
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.replacedign(enumerator, Expression.Call(d, d_mi_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_mi_move_next),
Expression.Call(info, info_mi_add_value, Expression.Property(enumerator_current, kvp_pi_key), Expression.Property(enumerator_current, kvp_pi_value)),
Expression.Break(exit_loop)),
exit_loop),
Expression.MemberInit(Expression.New(o_ctor, info, ctx))
);
return Expression.Lambda<Func<Dictionary<string, string>, T>>(body, d)
.Compile();
}
19
View Source File : ICollectionResolverTest_TypeIsCollection.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void ListIsSpecifiedCapacityCtor()
{
ICollectionResolver.TypeIsCollection(typeof(List<int>),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(int));
constructor.Is(typeof(List<int>).GetConstructor(new Type[] { typeof(int) }));
}
19
View Source File : ZeroDiscover.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
public static Func<TArg, TRes> CreateFunc<TArg, TRes>(TypeInfo callInfo, string methodName, TypeInfo argInfo, TypeInfo resInfo)
{
ConstructorInfo constructor = callInfo.GetConstructor(Type.EmptyTypes);
if (constructor == (ConstructorInfo)null)
throw new ArgumentException("类型" + callInfo.FullName + "没有无参构造函数");
MethodInfo method = callInfo.GetMethod(methodName);
if (method == (MethodInfo)null)
throw new ArgumentException("类型" + callInfo.FullName + "没有名称为" + methodName + "的方法");
if (method.ReturnType != (Type)resInfo)
throw new ArgumentException("类型" + callInfo.FullName + "的方法" + methodName + "返回值不为" + resInfo.FullName);
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 1)
throw new ArgumentException("类型" + callInfo.FullName + "的方法" + methodName + "参数不是一个");
if (parameters[0].ParameterType != (Type)argInfo)
throw new ArgumentException("类型" + callInfo.FullName + "的方法" + methodName + "唯一参数不为" + argInfo.FullName);
DynamicMethod dynamicMethod = new DynamicMethod(methodName, typeof(TRes), new Type[1]
{
typeof (TArg)
});
ILGenerator ilGenerator = dynamicMethod.GetILGenerator();
ilGenerator.Emit(OpCodes.Nop);
ilGenerator.Emit(OpCodes.Ldarg, 0);
ilGenerator.Emit(OpCodes.Castclreplaced, (Type)argInfo);
LocalBuilder local1 = ilGenerator.DeclareLocal((Type)argInfo);
ilGenerator.Emit(OpCodes.Stloc, local1);
ilGenerator.Emit(OpCodes.Newobj, constructor);
LocalBuilder local2 = ilGenerator.DeclareLocal((Type)callInfo);
ilGenerator.Emit(OpCodes.Stloc, local2);
ilGenerator.Emit(OpCodes.Ldloc, local2);
ilGenerator.Emit(OpCodes.Ldloc, local1);
ilGenerator.Emit(OpCodes.Callvirt, method);
LocalBuilder local3 = ilGenerator.DeclareLocal(method.ReturnType);
ilGenerator.Emit(OpCodes.Stloc, local3);
ilGenerator.Emit(OpCodes.Ldloc, local3);
ilGenerator.Emit(OpCodes.Castclreplaced, (Type)typeof(TRes).GetTypeInfo());
LocalBuilder local4 = ilGenerator.DeclareLocal((Type)resInfo);
ilGenerator.Emit(OpCodes.Stloc, local4);
ilGenerator.Emit(OpCodes.Ldloc, local4);
ilGenerator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(typeof(Func<TArg, TRes>)) as Func<TArg, TRes>;
}
19
View Source File : UMAData.cs
License : Apache License 2.0
Project Creator : A7ocin
License : Apache License 2.0
Project Creator : A7ocin
public UMADnaBase GetOrCreateDna(Type type)
{
UMADnaBase dna;
var typeNameHash = UMAUtils.StringToHash(type.Name);
if (umaDna.TryGetValue(typeNameHash, out dna))
{
return dna;
}
dna = type.GetConstructor(System.Type.EmptyTypes).Invoke(null) as UMADnaBase;
umaDna.Add(typeNameHash, dna);
dnaValues.Add(dna);
return dna;
}
19
View Source File : UMAData.cs
License : Apache License 2.0
Project Creator : A7ocin
License : Apache License 2.0
Project Creator : A7ocin
public UMADnaBase GetOrCreateDna(Type type, int dnaTypeHash)
{
UMADnaBase dna;
if (umaDna.TryGetValue(dnaTypeHash, out dna))
{
return dna;
}
dna = type.GetConstructor(System.Type.EmptyTypes).Invoke(null) as UMADnaBase;
dna.DNATypeHash = dnaTypeHash;
umaDna.Add(dnaTypeHash, dna);
dnaValues.Add(dna);
return dna;
}
19
View Source File : ICollectionResolverTest_TypeIsCollection.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void GenerIEnumerableWithNonGenerICollectionImpl_SameItemTypeColloctionCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_GenerIEnumerableWithNonGenerICollection_Int_SameItemTypeColloctionCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(int));
constructor.Is(typeof(_GenerIEnumerableWithNonGenerICollection_Int_SameItemTypeColloctionCtor).GetConstructor(new Type[] { typeof(List<int>) }));
}
19
View Source File : ReaderCache.cs
License : Apache License 2.0
Project Creator : aadreja
License : Apache License 2.0
Project Creator : aadreja
internal static Func<IDataReader, T> ReaderToObject(IDataReader rdr)
{
MethodInfo rdrGetValueMethod = rdr.GetType().GetMethod("get_Item", new Type[] { typeof(int) });
Type[] args = { typeof(IDataReader) };
DynamicMethod method = new DynamicMethod("DynamicRead" + Guid.NewGuid().ToString(), typeof(T), args, typeof(Repository<T>).Module, true);
ILGenerator il = method.GetILGenerator();
LocalBuilder result = il.DeclareLocal(typeof(T)); //loc_0
il.Emit(OpCodes.Newobj, typeof(T).GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc_0, result); //Pops the current value from the top of the evaluation stack and stores it in a the local variable list at a specified index.
Label tryBlock = il.BeginExceptionBlock();
LocalBuilder valueCopy = il.DeclareLocal(typeof(object)); //declare local variable to store object value. loc_1
il.DeclareLocal(typeof(int)); //declare local variable to store index //loc_2
il.Emit(OpCodes.Ldc_I4_0); //load 0 in index
il.Emit(OpCodes.Stloc_2); //pop and save to local variable loc 2
//get FieldInfo of all properties
TableAttribute tableInfo = EnreplacedyCache.Get(typeof(T));
for (int i = 0; i < rdr.FieldCount; i++)
{
tableInfo.Columns.TryGetValue(rdr.GetName(i), out ColumnAttribute columnInfo);
if (columnInfo != null && columnInfo.SetMethod != null)
{
Label endIfLabel = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);//load the argument. Loads the argument at index 0 onto the evaluation stack.
il.Emit(OpCodes.Ldc_I4, i); //push field index as int32 to the stack. Pushes a supplied value of type int32 onto the evaluation stack as an int32.
il.Emit(OpCodes.Dup);//copy value
il.Emit(OpCodes.Stloc_2);//pop and save value to loc 2
il.Emit(OpCodes.Callvirt, rdrGetValueMethod); //Call rdr[i] method - Calls a late - bound method on an object, pushing the return value onto the evaluation stack.
//TODO: dynamic location using valueCopyLocal
il.Emit(OpCodes.Stloc_1); //pop the value and push in stack location 1
il.Emit(OpCodes.Ldloc_1); //load the variable in location 1
il.Emit(OpCodes.Isinst, typeof(DBNull)); //check whether value is null - Tests whether an object reference (type O) is an instance of a particular clreplaced.
il.Emit(OpCodes.Brtrue, endIfLabel); //go to end block if value is null
il.Emit(OpCodes.Ldloc_0); //load T result
il.Emit(OpCodes.Ldloc_1); //TODO: dynamic location using valueCopyLocal
//when Enum are without number values
if (columnInfo.Property.PropertyType.IsEnum)
{
Type numericType = Enum.GetUnderlyingType(columnInfo.Property.PropertyType);
if (rdr.GetFieldType(i) == typeof(string))
{
LocalBuilder stringEnumLocal = il.DeclareLocal(typeof(string));
il.Emit(OpCodes.Castclreplaced, typeof(string)); // stack is now [...][string]
il.Emit(OpCodes.Stloc, stringEnumLocal); // stack is now [...]
il.Emit(OpCodes.Ldtoken, columnInfo.Property.PropertyType); // stack is now [...][enum-type-token]
il.EmitCall(OpCodes.Call, typeof(Type).GetMethod(nameof(Type.GetTypeFromHandle)), null);// stack is now [...][enum-type]
il.Emit(OpCodes.Ldloc, stringEnumLocal); // stack is now [...][enum-type][string]
il.Emit(OpCodes.Ldc_I4_1); // stack is now [...][enum-type][string][true]
il.EmitCall(OpCodes.Call, enumParse, null); // stack is now [...][enum-as-object]
il.Emit(OpCodes.Unbox_Any, columnInfo.Property.PropertyType); // stack is now [...][typed-value]
}
else
{
ConvertValueToEnum(il, rdr.GetFieldType(i), columnInfo.Property.PropertyType, numericType);
}
}
else if (columnInfo.Property.PropertyType.IsValueType)
il.Emit(OpCodes.Unbox_Any, rdr.GetFieldType(i)); //type cast
// for nullable type fields
if (columnInfo.Property.PropertyType.IsGenericType && columnInfo.Property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable<>))
{
var underlyingType = Nullable.GetUnderlyingType(columnInfo.Property.PropertyType);
il.Emit(OpCodes.Newobj, columnInfo.Property.PropertyType.GetConstructor(new Type[] { underlyingType }));
}
il.Emit(OpCodes.Callvirt, columnInfo.SetMethod);
il.Emit(OpCodes.Nop);
il.MarkLabel(endIfLabel);
}
}
il.BeginCatchBlock(typeof(Exception)); //begin try block. exception is in stack
il.Emit(OpCodes.Ldloc_2); //load index
il.Emit(OpCodes.Ldarg_0); //load argument reader
il.Emit(OpCodes.Ldloc_1); //load value //TODO: dynamic location using valueCopyLocal
il.EmitCall(OpCodes.Call, typeof(ReaderCache<T>).GetMethod(nameof(ReaderCache<T>.HandleException)), null); //call exception handler
il.EndExceptionBlock();
il.Emit(OpCodes.Ldloc, result);
il.Emit(OpCodes.Ret);
var funcType = System.Linq.Expressions.Expression.GetFuncType(typeof(IDataReader), typeof(T));
return (Func<IDataReader, T>)method.CreateDelegate(funcType);
}
19
View Source File : RandomHelper.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
public static object RandomValue(this Type t, bool stringValueAllowEmpty = true)
{
if (t.IsPrimitive)
{
if (t == typeof(byte))
{
return (byte)(Rand.Next(byte.MaxValue - byte.MinValue + 1) + byte.MinValue);
}
if (t == typeof(sbyte))
{
return (sbyte)(Rand.Next(sbyte.MaxValue - sbyte.MinValue + 1) + sbyte.MinValue);
}
if (t == typeof(short))
{
return (short)(Rand.Next(short.MaxValue - short.MinValue + 1) + short.MinValue);
}
if (t == typeof(ushort))
{
return (ushort)(Rand.Next(ushort.MaxValue - ushort.MinValue + 1) + ushort.MinValue);
}
if (t == typeof(int))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToInt32(bytes, 0);
}
if (t == typeof(uint))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToUInt32(bytes, 0);
}
if (t == typeof(long))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToInt64(bytes, 0);
}
if (t == typeof(ulong))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToUInt64(bytes, 0);
}
if (t == typeof(float))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
var f = BitConverter.ToSingle(bytes, 0);
if (float.IsNaN(f))
f = (float)RandomValue<short>();
return f;
}
if (t == typeof(double))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
var d = BitConverter.ToDouble(bytes, 0);
if (double.IsNaN(d))
d = (double)RandomValue<short>();
return d;
}
if (t == typeof(char))
{
var roll = Rand.Next(ASCII.Length);
return ASCII[roll];
}
if (t == typeof(bool))
{
return (Rand.Next(2) == 1);
}
throw new InvalidOperationException();
}
if (t == typeof(decimal))
{
return new decimal((int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), false, 28);
}
if (t == typeof(string))
{
int start = stringValueAllowEmpty ? 0 : 1;
var len = Rand.Next(start, 28);
var c = new char[len];
for (var i = 0; i < c.Length; i++)
{
c[i] = (char)typeof(char).RandomValue();
}
return new string(c);
}
if (t == typeof(DateTime))
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var bytes = new byte[4];
Rand.NextBytes(bytes);
var secsOffset = BitConverter.ToInt32(bytes, 0);
var retDate = epoch.AddSeconds(secsOffset);
return retDate;
}
if (t == typeof(TimeSpan))
{
return new TimeSpan(RandomValue<DateTime>().Ticks);
}
if (t == typeof(DataTable))
{
DataTable dt = new DataTable();
int coluCount = Rand.Next(10, 30);
for (int i = 0; i < coluCount; i++)
{
dt.Columns.Add(RandomHelper.RandomValue<string>(false), typeof(object));
}
int rowCount = Rand.Next(20, 50);
for (int i = 0; i < rowCount; i++)
{
var row = new object[coluCount];
for (int zi = 0; zi < coluCount; zi++)
{
row[zi] = RandomHelper.RandomValue<object>();
}
dt.Rows.Add(row);
}
return dt;
}
if (t.IsNullable())
{
// leave it unset
if (Rand.Next(2) == 0)
{
// null!
return Activator.CreateInstance(t);
}
var underlying = Nullable.GetUnderlyingType(t);
var val = underlying.RandomValue(stringValueAllowEmpty);
var cons = t.GetConstructor(new[] { underlying });
return cons.Invoke(new object[] { val });
}
if (t.IsEnum)
{
var allValues = Enum.GetValues(t);
var ix = Rand.Next(allValues.Length);
return allValues.GetValue(ix);
}
if (t.IsArray)
{
var valType = t.GetElementType();
var len = Rand.Next(20, 50);
var ret = Array.CreateInstance(valType, len);
//var add = t.GetMethod("SetValue");
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
ret.SetValue(elem, i);
}
return ret;
}
if (t.IsGenericType)
{
var defind = t.GetGenericTypeDefinition();
if (defind == typeof(HashSet<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("Contains");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
while (elem == null || (bool)contains.Invoke(ret, new object[] { elem }))
elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(Dictionary<,>))
{
var keyType = t.GetGenericArguments()[0];
var valType = t.GetGenericArguments()[1];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("ContainsKey");
var len = Rand.Next(20, 50);
if (keyType == typeof(Boolean))
len = 2;
for (var i = 0; i < len; i++)
{
var val = valType.RandomValue(stringValueAllowEmpty);
var key = keyType.RandomValue(stringValueAllowEmpty);
while (key == null || (bool)contains.Invoke(ret, new object[] { key }))
key = keyType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { key, val });
}
return ret;
}
if (defind == typeof(List<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(ArraySegment<>))
{
var valType = t.GetGenericArguments()[0];
var ary = valType.MakeArrayType().RandomValue(stringValueAllowEmpty);
var lenT = ary.GetType().GetProperty("Length");
var offset = Rand.Next(0, (int)lenT.GetValue(ary) - 1);
var len = (int)lenT.GetValue(ary) - offset;
return Activator.CreateInstance(t, ary, offset, len);
}
}
if (t == typeof(Guid))
return Guid.NewGuid();
if (t == typeof(object))
{
var code = Rand.Next(0, 9);
switch (code)
{
case 0:
return RandomValue<int>();
case 1:
return RandomValue<long>();
case 2:
return RandomValue<Char>();
case 3:
return RandomValue<DateTime>();
case 4:
return RandomValue<string>(stringValueAllowEmpty);
case 5:
return RandomValue<Guid>();
case 6:
return RandomValue<decimal>();
case 7:
return RandomValue<double>();
case 8:
return RandomValue<float>();
default:
return RandomValue<short>();
}
}
//model
var retObj = Activator.CreateInstance(t);
foreach (var p in t.GetFields())
{
//if (Rand.Next(5) == 0) continue;
var fieldType = p.FieldType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
foreach (var p in t.GetProperties())
{
//if (Rand.Next(5) == 0) continue;
if (p.CanWrite && p.CanRead)
{
var fieldType = p.PropertyType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
}
return retObj;
}
19
View Source File : Helpers.cs
License : MIT License
Project Creator : ad313
License : MIT License
Project Creator : ad313
private static Func<object, Dictionary<string, object>> CreateDictionaryGenerator(Type type)
{
var dm = new DynamicMethod($"Dictionary{Guid.NewGuid()}", typeof(Dictionary<string, object>), new[] { typeof(object) }, type, true);
ILGenerator il = dm.GetILGenerator();
il.DeclareLocal(typeof(Dictionary<string, object>));
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Newobj, typeof(Dictionary<string, object>).GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc_0);
foreach (var item in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
string columnName = item.Name;
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ldstr, columnName);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, item.GetGetMethod());
if (item.PropertyType.IsValueType)
{
il.Emit(OpCodes.Box, item.PropertyType);
}
il.Emit(OpCodes.Callvirt, typeof(Dictionary<string, object>).GetMethod("Add"));
}
il.Emit(OpCodes.Nop);
il.Emit(OpCodes.Ldloc_0);
il.Emit(OpCodes.Ret);
return (Func<object, Dictionary<string, object>>)dm.CreateDelegate(typeof(Func<object, Dictionary<string, object>>));
}
19
View Source File : PrefixWriter.cs
License : MIT License
Project Creator : Abc-Arbitrage
License : MIT License
Project Creator : Abc-Arbitrage
private static Action<PrefixWriter, ILogEventHeader> BuildAppendMethod(ICollection<PatternPart> parts, Dictionary<string, (int offset, int length)> stringMap)
{
var method = new DynamicMethod("WritePrefix", typeof(void), new[] { typeof(PrefixWriter), typeof(ILogEventHeader) }, typeof(PrefixWriter), false)
{
InitLocals = false
};
var il = method.GetILGenerator();
var stringBufferLocal = il.DeclareLocal(typeof(StringBuffer));
var stringsLocal = il.DeclareLocal(typeof(char).MakeByRefType(), true);
var dateTimeLocal = default(LocalBuilder);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, typeof(PrefixWriter).GetField(nameof(_stringBuffer), BindingFlags.Instance | BindingFlags.NonPublic)!);
il.Emit(OpCodes.Stloc, stringBufferLocal);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, typeof(PrefixWriter).GetField(nameof(_strings), BindingFlags.Instance | BindingFlags.NonPublic)!);
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldelema, typeof(char));
il.Emit(OpCodes.Stloc, stringsLocal);
foreach (var part in parts)
{
switch (part.Type)
{
case PatternPartType.String:
{
// _stringBuffer.Append(&_strings[0] + offset * sizeof(char), length);
var (offset, length) = stringMap[part.Value!];
il.Emit(OpCodes.Ldloc, stringBufferLocal);
il.Emit(OpCodes.Ldloc, stringsLocal);
il.Emit(OpCodes.Conv_U);
il.Emit(OpCodes.Ldc_I4, offset * sizeof(char));
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ldc_I4, length);
il.Emit(OpCodes.Call, typeof(StringBuffer).GetMethod(nameof(StringBuffer.Append), new[] { typeof(char*), typeof(int) })!);
break;
}
case PatternPartType.Date:
{
// _stringBuffer.Append(logEventHeader.Timestamp, new StringView(&_strings[0] + offset * sizeof(char), length));
var (offset, length) = stringMap[_dateFormat];
il.Emit(OpCodes.Ldloc, stringBufferLocal);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt, typeof(ILogEventHeader).GetProperty(nameof(ILogEventHeader.Timestamp))?.GetGetMethod()!);
il.Emit(OpCodes.Ldloc, stringsLocal);
il.Emit(OpCodes.Conv_U);
il.Emit(OpCodes.Ldc_I4, offset * sizeof(char));
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ldc_I4, length);
il.Emit(OpCodes.Newobj, typeof(StringView).GetConstructor(new[] { typeof(char*), typeof(int) })!);
il.Emit(OpCodes.Call, typeof(StringBuffer).GetMethod(nameof(StringBuffer.Append), new[] { typeof(DateTime), typeof(StringView) })!);
break;
}
case PatternPartType.Time:
{
// _stringBuffer.Append(logEventHeader.Timestamp.TimeOfDay, StringView.Empty);
il.Emit(OpCodes.Ldloc, stringBufferLocal);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt, typeof(ILogEventHeader).GetProperty(nameof(ILogEventHeader.Timestamp))?.GetGetMethod()!);
il.Emit(OpCodes.Stloc, dateTimeLocal ??= il.DeclareLocal(typeof(DateTime)));
il.Emit(OpCodes.Ldloca, dateTimeLocal);
il.Emit(OpCodes.Call, typeof(DateTime).GetProperty(nameof(DateTime.TimeOfDay))?.GetGetMethod()!);
il.Emit(OpCodes.Ldsfld, typeof(StringView).GetField(nameof(StringView.Empty))!);
il.Emit(OpCodes.Call, typeof(StringBuffer).GetMethod(nameof(StringBuffer.Append), new[] { typeof(TimeSpan), typeof(StringView) })!);
break;
}
case PatternPartType.Thread:
{
// AppendThread(logEventHeader.Thread);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt, typeof(ILogEventHeader).GetProperty(nameof(ILogEventHeader.Thread))?.GetGetMethod()!);
il.Emit(OpCodes.Call, typeof(PrefixWriter).GetMethod(nameof(AppendThread), BindingFlags.Instance | BindingFlags.NonPublic)!);
break;
}
case PatternPartType.Level:
{
// _stringBuffer.Append(LevelStringCache.GetLevelString(logEventHeader.Level));
il.Emit(OpCodes.Ldloc, stringBufferLocal);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt, typeof(ILogEventHeader).GetProperty(nameof(ILogEventHeader.Level))?.GetGetMethod()!);
il.Emit(OpCodes.Call, typeof(LevelStringCache).GetMethod(nameof(LevelStringCache.GetLevelString))!);
il.Emit(OpCodes.Call, typeof(StringBuffer).GetMethod(nameof(StringBuffer.Append), new[] { typeof(string) })!);
break;
}
case PatternPartType.Logger:
{
// _stringBuffer.Append(logEventHeader.Name);
il.Emit(OpCodes.Ldloc, stringBufferLocal);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Callvirt, typeof(ILogEventHeader).GetProperty(nameof(ILogEventHeader.Name))?.GetGetMethod()!);
il.Emit(OpCodes.Call, typeof(StringBuffer).GetMethod(nameof(StringBuffer.Append), new[] { typeof(string) })!);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
il.Emit(OpCodes.Ret);
return (Action<PrefixWriter, ILogEventHeader>)method.CreateDelegate(typeof(Action<PrefixWriter, ILogEventHeader>));
}
19
View Source File : DotNetToJScript.cs
License : MIT License
Project Creator : 1y0n
License : MIT License
Project Creator : 1y0n
static HashSet<string> GetValidClreplacedes(byte[] replacedembly)
{
replacedembly asm = replacedembly.Load(replacedembly);
return new HashSet<string>(asm.GetTypes().Where(t => t.IsPublic && t.GetConstructor(new Type[0]) != null).Select(t => t.FullName));
}
19
View Source File : ObjectFactory.cs
License : GNU General Public License v3.0
Project Creator : Adam-Wilkinson
License : GNU General Public License v3.0
Project Creator : Adam-Wilkinson
public object CreateInstance(Type type)
{
if (type == typeof(IObjectFactory))
{
return this;
}
if (type == typeof(Instance))
{
return _instance;
}
if (TryGetImplementation(type, out Type implementationType))
{
return CreateInstance(implementationType);
}
if (type.GetConstructor(Type.EmptyTypes) is not null)
{
return Activator.CreateInstance(type);
}
ConstructorInfo info = type.GetConstructors()[0];
ParameterInfo[] parameters = info.GetParameters();
object[] parameterObjects = new object[parameters.Length];
int i = 0;
foreach (ParameterInfo parameter in info.GetParameters())
{
parameterObjects[i] = CreateInstance(parameter.ParameterType);
i++;
}
return Activator.CreateInstance(type, parameterObjects);
}
19
View Source File : IDictionaryResolverTest_TypeIsIDictionary.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void SortedListIsSpecifiedCapacityCtor()
{
IDictionaryResolver.TypeIsDictionary(typeof(SortedList<int, int>),
out ConstructorInfo constructor, out bool typeIsGeneric, out Type genericTypeDefinition, out Type genericKeyType, out Type genericValueType)
.IsTrue();
genericKeyType.Is(typeof(int));
genericValueType.Is(typeof(int));
constructor.Is(typeof(SortedList<int, int>).GetConstructor(new Type[] { typeof(int) }));
}
19
View Source File : ModEntry.cs
License : GNU General Public License v3.0
Project Creator : aedenthorn
License : GNU General Public License v3.0
Project Creator : aedenthorn
public override void Entry(IModHelper helper)
{
context = this;
Config = Helper.ReadConfig<ModConfig>();
if (!Config.EnableMod)
return;
SMonitor = Monitor;
SHelper = Helper;
Helper.Events.GameLoop.GameLaunched += GameLoop_GameLaunched;
var harmony = new Harmony(ModManifest.UniqueID);
ConstructorInfo ci = typeof(ItemGrabMenu).GetConstructor(new Type[] { typeof(IList<Item>), typeof(object) });
harmony.Patch(
original: ci,
prefix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.ItemGrabMenu_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FishingRod), nameof(FishingRod.startMinigameEndFunction)),
prefix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.startMinigameEndFunction_Prefix))
);
}
19
View Source File : Serializer.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
static Func<Dictionary<string, string>, T> CompileDeserializer()
{
var o_t = typeof(T);
var o_ctor = o_t.GetConstructor(new[] { typeof(SerializationInfo), typeof(StreamingContext) });
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Parameter(d_t, "d");
var d_mi_get_enumerator = d_t.GetMethod("GetEnumerator");
var fc_t = typeof(IFormatterConverter);// typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(typeof(System.Runtime.Serialization.FormatterConverter))); //Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_mi_add_value = info_t.GetMethod("AddValue", new[] { typeof(String), typeof(Object) });
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(Dictionary<string, string>.Enumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_mi_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_current = Expression.Property(enumerator, "Current");
var kvp_t = typeof(KeyValuePair<string, string>);
var kvp_pi_key = kvp_t.GetProperty("Key");
var kvp_pi_value = kvp_t.GetProperty("Value");
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { fc, info, ctx, enumerator },
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.replacedign(enumerator, Expression.Call(d, d_mi_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_mi_move_next),
Expression.Call(info, info_mi_add_value, Expression.Property(enumerator_current, kvp_pi_key), Expression.Property(enumerator_current, kvp_pi_value)),
Expression.Break(exit_loop)),
exit_loop),
Expression.MemberInit(Expression.New(o_ctor, info, ctx))
);
return Expression.Lambda<Func<Dictionary<string, string>, T>>(body, d)
.Compile();
}
19
View Source File : ModEntry.cs
License : GNU General Public License v3.0
Project Creator : aedenthorn
License : GNU General Public License v3.0
Project Creator : aedenthorn
public override void Entry(IModHelper helper)
{
context = this;
Config = Helper.ReadConfig<ModConfig>();
SMonitor = Monitor;
var harmony = new Harmony(ModManifest.UniqueID);
harmony.Patch(
original: AccessTools.Method(typeof(MineShaft), "chooseStoneType"),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.chooseStoneType_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(GameLocation), "breakStone"),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.breakStone_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Object), nameof(Object.draw), new Type[] { typeof(SpriteBatch), typeof(int), typeof(int), typeof(float) }),
prefix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.Object_draw_Prefix))
);
if (Config.AllowCustomOreNodesAboveGround)
{
ConstructorInfo ci = typeof(Object).GetConstructor(new Type[] { typeof(Vector2), typeof(int), typeof(string), typeof(bool), typeof(bool), typeof(bool), typeof(bool) });
harmony.Patch(
original: ci,
prefix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.Object_Prefix)),
postfix: new HarmonyMethod(typeof(ModEntry), nameof(ModEntry.Object_Postfix))
);
}
helper.Events.GameLoop.GameLaunched += GameLoop_GameLaunched;
}
19
View Source File : ICollectionResolver.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
internal static bool TypeIsCollection(Type t, out ConstructorInfo constructor, out Type itemType, out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList)
{
constructor = null;
itemType = null;
IsImplIList = false;
isImplGenerIList = false;
isImplGenerICollec = false;
isImplIReadOnlyList = false;
if (t.IsInterface)
{
if (t == typeof(IEnumerable) || t == typeof(ICollection) || t == typeof(IList))
{
itemType = typeof(object);
if (t == typeof(IList))
{
IsImplIList = true;
}
return true;
}
if (t.IsGenericType)
{
Type genericType = t.GetGenericTypeDefinition();
if (genericType == typeof(IEnumerable<>) || genericType == typeof(IList<>) || genericType == typeof(ICollection<>) || genericType == typeof(ISet<>) || genericType == typeof(IReadOnlyList<>) || genericType == typeof(IReadOnlyCollection<>))
{
if (genericType == typeof(IList<>))
{
isImplGenerIList = true;
isImplGenerICollec = true;
}
else if (genericType == typeof(ICollection<>) || genericType == typeof(ISet<>))
{
isImplGenerICollec = true;
}
else if (genericType == typeof(IReadOnlyList<>))
{
isImplIReadOnlyList = true;
}
itemType = t.GetGenericArguments()[0];
return true;
}
}
return false;
}
if (t.IsGenericType)
{
Type genericType = t.GetGenericTypeDefinition();
if (genericType == typeof(List<>))
{
itemType = t.GetGenericArguments()[0];
isImplGenerIList = true;
IsImplIList = true;
isImplGenerICollec = true;
isImplIReadOnlyList = true;
constructor = t.GetConstructor(new Type[] { typeof(int) });
return true;
}
}
bool isImplGenerIEnumerable = false;
bool isImplICollection = false;
Type generIEnumerableItemType = null;
Type generILisreplacedemType = null;
Type generICollectionItemType = null;
Type[] intserfaces = t.GetInterfaces();
foreach (Type item in intserfaces)
{
if (item.IsGenericType)
{
Type genericTypeDefinition = item.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(IEnumerable<>))
{
isImplGenerIEnumerable = true;
generIEnumerableItemType = item.GetGenericArguments()[0];
}
else if (genericTypeDefinition == typeof(ICollection<>))
{
isImplGenerICollec = true;
generICollectionItemType = item.GetGenericArguments()[0];
}
else if (genericTypeDefinition == typeof(IList<>))
{
isImplGenerIList = true;
generILisreplacedemType = item.GetGenericArguments()[0];
}
}
else if (item == typeof(ICollection))
{
isImplICollection = true;
}
else if (item == typeof(IList))
{
IsImplIList = true;
}
}
if (isImplGenerIList)
{
if (TryGetConstructorInfo(t, generILisreplacedemType, true, out constructor))
{
itemType = generILisreplacedemType;
return true;
}
}
if (isImplGenerICollec)
{
if (TryGetConstructorInfo(t, generICollectionItemType, true, out constructor))
{
itemType = generICollectionItemType;
return true;
}
}
if (isImplGenerIEnumerable && isImplICollection)
{
if (TryGetConstructorInfo(t, generIEnumerableItemType, false, out constructor))
{
itemType = generIEnumerableItemType;
return true;
}
}
if (IsImplIList)
{
if (TryGetConstructorInfo(t, typeof(object), true, out constructor))
{
itemType = typeof(object);
return true;
}
}
if (isImplICollection)
{
if (TryGetConstructorInfo(t, typeof(object), false, out constructor))
{
itemType = typeof(object);
return true;
}
}
return false;
}
19
View Source File : ModEntry.cs
License : GNU General Public License v3.0
Project Creator : aedenthorn
License : GNU General Public License v3.0
Project Creator : aedenthorn
public override void Entry(IModHelper helper)
{
config = Helper.ReadConfig<ModConfig>();
if (!config.EnableMod)
return;
PMonitor = Monitor;
PHelper = helper;
mp = helper.Reflection.GetField<Multiplayer>(typeof(Game1), "multiplayer").GetValue();
myRand = new Random();
helper.Events.GameLoop.GameLaunched += HelperEvents.GameLoop_GameLaunched;
helper.Events.GameLoop.SaveLoaded += HelperEvents.GameLoop_SaveLoaded;
helper.Events.GameLoop.DayStarted += HelperEvents.GameLoop_DayStarted;
helper.Events.GameLoop.OneSecondUpdateTicked += HelperEvents.GameLoop_OneSecondUpdateTicked;
PathFindControllerPatches.Initialize(Monitor, config, helper);
Integrations.Initialize(Monitor, config, helper);
Divorce.Initialize(Monitor, config, helper);
NPCPatches.Initialize(Monitor, config, helper);
LocationPatches.Initialize(Monitor, config, helper);
FarmerPatches.Initialize(Monitor, config, helper);
UIPatches.Initialize(Monitor, config, helper);
EventPatches.Initialize(Monitor, config, helper);
HelperEvents.Initialize(Monitor, config, helper);
Misc.Initialize(Monitor, config, helper);
var harmony = new Harmony(ModManifest.UniqueID);
// npc patches
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.marriageDuties)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_marriageDuties_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.getSpouse)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_getSpouse_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.isRoommate)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_isRoommate_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.isMarried)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_isMarried_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.isMarriedOrEngaged)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_isMarriedOrEngaged_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.tryToReceiveActiveObject)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToReceiveActiveObject_Prefix)),
transpiler: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToReceiveActiveObject_Transpiler))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), "engagementResponse"),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_engagementResponse_Prefix)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_engagementResponse_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.playSleepingAnimation)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_playSleepingAnimation_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.GetDispositionModifiedString)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_GetDispositionModifiedString_Prefix)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_GetDispositionModifiedString_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), "loadCurrentDialogue"),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_loadCurrentDialogue_Prefix)),
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_loadCurrentDialogue_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.tryToRetrieveDialogue)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_tryToRetrieveDialogue_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(NPC), nameof(NPC.checkAction)),
prefix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.NPC_checkAction_Prefix))
);
// Child patches
harmony.Patch(
original: typeof(Character).GetProperty("displayName").GetMethod,
postfix: new HarmonyMethod(typeof(NPCPatches), nameof(NPCPatches.Character_displayName_Getter_Postfix))
);
// Path patches
harmony.Patch(
original: AccessTools.Constructor(typeof(PathFindController), new Type[] { typeof(Character), typeof(GameLocation), typeof(Point), typeof(int), typeof(bool), typeof(bool) }),
prefix: new HarmonyMethod(typeof(PathFindControllerPatches), nameof(PathFindControllerPatches.PathFindController_Prefix))
);
harmony.Patch(
original: AccessTools.Constructor(typeof(PathFindController), new Type[] { typeof(Character), typeof(GameLocation), typeof(Point), typeof(int), typeof(PathFindController.endBehavior) }),
prefix: new HarmonyMethod(typeof(PathFindControllerPatches), nameof(PathFindControllerPatches.PathFindController_Prefix))
);
harmony.Patch(
original: AccessTools.Constructor(typeof(PathFindController), new Type[] { typeof(Character), typeof(GameLocation), typeof(Point), typeof(int) }),
prefix: new HarmonyMethod(typeof(PathFindControllerPatches), nameof(PathFindControllerPatches.PathFindController_Prefix))
);
// Location patches
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.GetSpouseBed)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_GetSpouseBed_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(FarmHouse), nameof(FarmHouse.getSpouseBedSpot)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.FarmHouse_getSpouseBedSpot_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Beach), nameof(Beach.checkAction)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.Beach_checkAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Beach), "resetLocalState"),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.Beach_resetLocalState_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(GameLocation), "checkEventPrecondition"),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.GameLocation_checkEventPrecondition_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Desert), nameof(Desert.getDesertMerchantTradeStock)),
postfix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.Desert_getDesertMerchantTradeStock_Postfix))
);
harmony.Patch(
original: AccessTools.Method(typeof(ManorHouse), nameof(ManorHouse.performAction)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.ManorHouse_performAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(GameLocation), nameof(GameLocation.answerDialogue)),
prefix: new HarmonyMethod(typeof(LocationPatches), nameof(LocationPatches.GameLocation_answerDialogue_prefix))
);
// pregnancy patches
harmony.Patch(
original: AccessTools.Method(typeof(Utility), nameof(Utility.pickPersonalFarmEvent)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.Utility_pickPersonalFarmEvent_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(QuestionEvent), nameof(QuestionEvent.setUp)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.QuestionEvent_setUp_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(BirthingEvent), nameof(BirthingEvent.setUp)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.BirthingEvent_setUp_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(BirthingEvent), nameof(BirthingEvent.tickUpdate)),
prefix: new HarmonyMethod(typeof(Pregnancy), nameof(Pregnancy.BirthingEvent_tickUpdate_Prefix))
);
// Farmer patches
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.doDivorce)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_doDivorce_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.isMarried)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_isMarried_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.getSpouse)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_getSpouse_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.checkAction)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_checkAction_Prefix))
);
harmony.Patch(
original: AccessTools.Method(typeof(Farmer), nameof(Farmer.GetSpouseFriendship)),
prefix: new HarmonyMethod(typeof(FarmerPatches), nameof(FarmerPatches.Farmer_GetSpouseFriendship_Prefix))
);
// UI patches
harmony.Patch(
original: AccessTools.Method(typeof(SocialPage), "drawNPCSlot"),
prefix: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.SocialPage_drawNPCSlot_prefix)),
transpiler: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.SocialPage_drawSlot_transpiler))
);
harmony.Patch(
original: AccessTools.Method(typeof(SocialPage), "drawFarmerSlot"),
transpiler: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.SocialPage_drawSlot_transpiler))
);
harmony.Patch(
original: typeof(DialogueBox).GetConstructor(new Type[] { typeof(List<string>) }),
prefix: new HarmonyMethod(typeof(UIPatches), nameof(UIPatches.DialogueBox_Prefix))
);
// Event patches
harmony.Patch(
original: AccessTools.Method(typeof(Event), nameof(Event.answerDialogueQuestion)),
prefix: new HarmonyMethod(typeof(EventPatches), nameof(EventPatches.Event_answerDialogueQuestion_Prefix))
);
}
19
View Source File : JSONParser.cs
License : MIT License
Project Creator : 5minlab
License : MIT License
Project Creator : 5minlab
internal static object ParseValue(Type type, string json) {
if (type == typeof(string)) {
if (json.Length <= 2)
return string.Empty;
string str = json.Substring(1, json.Length - 2);
return str.Replace("\\\\", "\"\"").Replace("\\", string.Empty).Replace("\"\"", "\\");
}
if (type == typeof(int)) {
int result;
int.TryParse(json, out result);
return result;
}
if (type == typeof(float)) {
float result;
float.TryParse(json, out result);
return result;
}
if (type == typeof(double)) {
double result;
double.TryParse(json, out result);
return result;
}
if (type == typeof(bool)) {
return json.ToLower() == "true";
}
if (json == "null") {
return null;
}
if (type.IsArray) {
Type arrayType = type.GetElementType();
if (json[0] != '[' || json[json.Length - 1] != ']')
return null;
List<string> elems = Split(json);
Array newArray = Array.CreateInstance(arrayType, elems.Count);
for (int i = 0; i < elems.Count; i++)
newArray.SetValue(ParseValue(arrayType, elems[i]), i);
splitArrayPool.Push(elems);
return newArray;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>)) {
Type listType = type.GetGenericArguments()[0];
if (json[0] != '[' || json[json.Length - 1] != ']')
return null;
List<string> elems = Split(json);
var list = (IList)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count });
for (int i = 0; i < elems.Count; i++)
list.Add(ParseValue(listType, elems[i]));
splitArrayPool.Push(elems);
return list;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<,>)) {
Type keyType, valueType;
{
Type[] args = type.GetGenericArguments();
keyType = args[0];
valueType = args[1];
}
//Refuse to parse dictionary keys that aren't of type string
if (keyType != typeof(string))
return null;
//Must be a valid dictionary element
if (json[0] != '{' || json[json.Length - 1] != '}')
return null;
//The list is split into key/value pairs only, this means the split must be divisible by 2 to be valid JSON
List<string> elems = Split(json);
if (elems.Count % 2 != 0)
return null;
var dictionary = (IDictionary)type.GetConstructor(new Type[] { typeof(int) }).Invoke(new object[] { elems.Count / 2 });
for (int i = 0; i < elems.Count; i += 2) {
if (elems[i].Length <= 2)
continue;
string keyValue = elems[i].Substring(1, elems[i].Length - 2);
object val = ParseValue(valueType, elems[i + 1]);
dictionary.Add(keyValue, val);
}
return dictionary;
}
if (type == typeof(object)) {
return ParseAnonymousValue(json);
}
if (json[0] == '{' && json[json.Length - 1] == '}') {
return ParseObject(type, json);
}
return null;
}
19
View Source File : InitializePhase.cs
License : GNU General Public License v3.0
Project Creator : Aekras1a
License : GNU General Public License v3.0
Project Creator : Aekras1a
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
context.Logger.Log("Initializing DarksVM");
foreach (ModuleDefMD module in context.Modules)
{
context.Logger.LogFormat("Protecting '{0}' with DarksVM...", module.Name);
}
var random = context.Registry.GetService<IRandomService>();
var refProxy = context.Registry.GetService<IReferenceProxyService>();
var nameSrv = context.Registry.GetService<INameService>();
var seed = random.GetRandomGenerator(Parent.FullId).NextInt32();
string rtName = null;
bool dbg = false, stackwalk = false;
ModuleDef merge = null;
foreach(var module in context.Modules)
{
if(rtName == null)
rtName = parameters.GetParameter<string>(context, module, "rtName");
if(dbg == false)
dbg = parameters.GetParameter<bool>(context, module, "dbgInfo");
if(stackwalk == false)
stackwalk = parameters.GetParameter<bool>(context, module, "stackwalk");
merge = module;
rtName = "Virtualization";
}
rtName = rtName ?? "KoiVM.Runtime--test";
ModuleDefMD rtModule;
var resStream = typeof(Virtualizer).replacedembly.GetManifestResourceStream("KoiVM.Runtime.dll");
if(resStream != null)
{
rtModule = ModuleDefMD.Load(resStream, context.Resolver.DefaultModuleContext);
}
else
{
var rtPath = Path.Combine(koiDir, "KoiVM.Runtime.dll");
rtModule = ModuleDefMD.Load(rtPath, context.Resolver.DefaultModuleContext);
}
rtModule.replacedembly.Name = rtName;
rtModule.Name = rtName + ".dll";
var vr = new Virtualizer(seed, context.Project.Debug);
vr.ExportDbgInfo = dbg;
vr.DoStackWalk = stackwalk;
vr.Initialize(rtModule);
context.Annotations.Set(context, Fish.VirtualizerKey, vr);
context.Annotations.Set(context, Fish.MergeKey, merge);
if(merge != null)
{
var types = new List<TypeDef>(vr.RuntimeModule.GetTypes());
types.Remove(vr.RuntimeModule.GlobalType);
vr.CommitRuntime(merge);
foreach(var type in types)
foreach(var def in type.FindDefinitions())
{
if(def is TypeDef && def != type) // nested type
continue;
nameSrv.SetCanRename(def, false);
ProtectionParameters.SetParameters(context, def, new ProtectionSettings());
}
}
else
{
vr.CommitRuntime(merge);
}
var ctor = typeof(InternalsVisibleToAttribute).GetConstructor(new[] {typeof(string)});
foreach(ModuleDef module in context.Modules)
{
var methods = new HashSet<MethodDef>();
foreach(var type in module.GetTypes())
foreach(var method in type.Methods)
if(ProtectionParameters.GetParameters(context, method).ContainsKey(Parent))
methods.Add(method);
if(methods.Count > 0)
{
var ca = new CustomAttribute((ICustomAttributeType) module.Import(ctor));
ca.ConstructorArguments.Add(new CAArgument(module.CorLibTypes.String, vr.RuntimeModule.replacedembly.Name.String));
module.replacedembly.CustomAttributes.Add(ca);
}
foreach(var entry in new Scanner(module, methods).Scan().WithProgress(context.Logger))
{
if(entry.Item2)
context.Annotations.Set(entry.Item1, Fish.ExportKey, Fish.ExportKey);
else
refProxy.ExcludeTarget(context, entry.Item1);
context.CheckCancellation();
}
}
}
19
View Source File : RandomHelper.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
public static object RandomValue(this Type t, bool stringValueAllowEmpty = true)
{
if (t.IsPrimitive)
{
if (t == typeof(byte))
{
return (byte)(Rand.Next(byte.MaxValue - byte.MinValue + 1) + byte.MinValue);
}
if (t == typeof(sbyte))
{
return (sbyte)(Rand.Next(sbyte.MaxValue - sbyte.MinValue + 1) + sbyte.MinValue);
}
if (t == typeof(short))
{
return (short)(Rand.Next(short.MaxValue - short.MinValue + 1) + short.MinValue);
}
if (t == typeof(ushort))
{
return (ushort)(Rand.Next(ushort.MaxValue - ushort.MinValue + 1) + ushort.MinValue);
}
if (t == typeof(int))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToInt32(bytes, 0);
}
if (t == typeof(uint))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
return BitConverter.ToUInt32(bytes, 0);
}
if (t == typeof(long))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToInt64(bytes, 0);
}
if (t == typeof(ulong))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
return BitConverter.ToUInt64(bytes, 0);
}
if (t == typeof(float))
{
var bytes = new byte[4];
Rand.NextBytes(bytes);
var f = BitConverter.ToSingle(bytes, 0);
if (float.IsNaN(f))
f = (float)RandomValue<short>();
return f;
}
if (t == typeof(double))
{
var bytes = new byte[8];
Rand.NextBytes(bytes);
var d= BitConverter.ToDouble(bytes, 0);
if (double.IsNaN(d))
d = (double)RandomValue<short>();
return d;
}
if (t == typeof(char))
{
var roll = Rand.Next(ASCII.Length);
return ASCII[roll];
}
if (t == typeof(bool))
{
return (Rand.Next(2) == 1);
}
throw new InvalidOperationException();
}
if (t == typeof(decimal))
{
return new decimal((int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), (int)typeof(int).RandomValue(), false, 28);
}
if (t == typeof(string))
{
int start = stringValueAllowEmpty ? 0 : 1;
var len = Rand.Next(start, 40);
var c = new char[len];
for (var i = 0; i < c.Length; i++)
{
c[i] = (char)typeof(char).RandomValue();
}
return new string(c);
}
if (t == typeof(DateTime))
{
var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
var bytes = new byte[4];
Rand.NextBytes(bytes);
var secsOffset = BitConverter.ToInt32(bytes, 0);
var retDate = epoch.AddSeconds(secsOffset);
return retDate;
}
if (t == typeof(TimeSpan))
{
return new TimeSpan(RandomValue<DateTime>().Ticks);
}
if (t == typeof(DataTable))
{
DataTable dt = new DataTable();
int coluCount = Rand.Next(10, 30);
for (int i = 0; i < coluCount; i++)
{
string n = RandomHelper.RandomValue<string>(false);
while(dt.Columns.Contains(n))
n = RandomHelper.RandomValue<string>(false);
dt.Columns.Add(n, typeof(object));
}
int rowCount = Rand.Next(20, 50);
for (int i = 0; i < rowCount; i++)
{
var row = new object[coluCount];
for (int zi = 0; zi < coluCount; zi++)
{
row[zi] = RandomHelper.RandomValue<object>();
}
dt.Rows.Add(row);
}
return dt;
}
if (t.IsNullable())
{
// leave it unset
if (Rand.Next(2) == 0)
{
// null!
return Activator.CreateInstance(t);
}
var underlying = Nullable.GetUnderlyingType(t);
var val = underlying.RandomValue(stringValueAllowEmpty);
var cons = t.GetConstructor(new[] { underlying });
return cons.Invoke(new object[] { val });
}
if (t.IsEnum)
{
var allValues = Enum.GetValues(t);
var ix = Rand.Next(allValues.Length);
return allValues.GetValue(ix);
}
if (t.IsArray)
{
var valType = t.GetElementType();
var len = Rand.Next(20, 50);
var ret = Array.CreateInstance(valType, len);
//var add = t.GetMethod("SetValue");
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
ret.SetValue(elem, i);
}
return ret;
}
if (t.IsGenericType)
{
var defind = t.GetGenericTypeDefinition();
if (defind == typeof(HashSet<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("Contains");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
while (elem == null || (bool)contains.Invoke(ret, new object[] { elem }))
elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(Dictionary<,>))
{
var keyType = t.GetGenericArguments()[0];
var valType = t.GetGenericArguments()[1];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var contains = t.GetMethod("ContainsKey");
var len = Rand.Next(20, 50);
if (keyType == typeof(Boolean))
len = 2;
for (var i = 0; i < len; i++)
{
var val = valType.RandomValue(stringValueAllowEmpty);
var key = keyType.RandomValue(stringValueAllowEmpty);
while (key == null || (bool)contains.Invoke(ret, new object[] { key }))
key = keyType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { key, val });
}
return ret;
}
if (defind == typeof(List<>))
{
var valType = t.GetGenericArguments()[0];
var ret = Activator.CreateInstance(t);
var add = t.GetMethod("Add");
var len = Rand.Next(20, 50);
for (var i = 0; i < len; i++)
{
var elem = valType.RandomValue(stringValueAllowEmpty);
add.Invoke(ret, new object[] { elem });
}
return ret;
}
if (defind == typeof(ArraySegment<>))
{
var valType = t.GetGenericArguments()[0];
var ary = valType.MakeArrayType().RandomValue(stringValueAllowEmpty);
var lenT = ary.GetType().GetProperty("Length");
var offset = Rand.Next(0, (int)lenT.GetValue(ary) - 1);
var len = (int)lenT.GetValue(ary) - offset;
return Activator.CreateInstance(t, ary, offset, len);
}
}
if (t == typeof(Guid))
return Guid.NewGuid();
if (t == typeof(object))
{
var code = Rand.Next(0, 9);
switch (code)
{
case 0:
return RandomValue<int>();
case 1:
return RandomValue<long>();
case 2:
return RandomValue<Char>();
case 3:
return RandomValue<DateTime>();
case 4:
return RandomValue<string>(stringValueAllowEmpty);
case 5:
return RandomValue<Guid>();
case 6:
return RandomValue<decimal>();
case 7:
return RandomValue<double>();
case 8:
return RandomValue<float>();
default:
return RandomValue<short>();
}
}
//model
var retObj = Activator.CreateInstance(t);
foreach (var p in t.GetFields())
{
//if (Rand.Next(5) == 0) continue;
var fieldType = p.FieldType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
foreach (var p in t.GetProperties())
{
//if (Rand.Next(5) == 0) continue;
if (p.CanWrite && p.CanRead)
{
var fieldType = p.PropertyType;
p.SetValue(retObj, fieldType.RandomValue(stringValueAllowEmpty));
}
}
return retObj;
}
19
View Source File : PluginManager.cs
License : GNU General Public License v2.0
Project Creator : afrantzis
License : GNU General Public License v2.0
Project Creator : afrantzis
private void AddPluginFile(string file)
{
try {
replacedembly asm = replacedembly.LoadFile(file);
Type[] types = asm.GetTypes();
foreach(Type t in types) {
if (t.BaseType == pluginType) {
//Console.WriteLine(" Found Type {0}", t.FullName);
ConstructorInfo ctor = t.GetConstructor(ctorArgTypes);
AddToPluginCollection((Plugin)ctor.Invoke(ctorArgs));
}
}
}
catch (Exception e) {
System.Console.WriteLine(e.Message);
}
}
19
View Source File : Helpers.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
public static bool TryPrepareMethod(MethodBase method, RuntimeMethodHandle handle)
{
// First, try the good ol' RuntimeHelpers.PrepareMethod.
if (PrepareMethod != null)
{
PrepareMethod(handle);
return true;
}
// No chance, we gotta go lower.
// Invoke the method with uninitialized arguments.
object sender = null;
object[] GetArguments(ParameterInfo[] parameters)
{
object[] args = new object[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo param = parameters[i];
if (param.HasDefaultValue)
args[i] = param.DefaultValue;
else if (param.ParameterType.GetTypeInfo().IsValueType)
args[i] = Activator.CreateInstance(param.ParameterType);
else
args[i] = null;
}
return args;
}
if (!method.IsStatic)
{
// Gotta make the instance
Type declaringType = method.DeclaringType;
if (declaringType.GetTypeInfo().IsValueType)
{
sender = Activator.CreateInstance(declaringType);
}
else if (declaringType.GetTypeInfo().IsAbstract)
{
// Overkill solution: Find a type in the replacedembly that implements the declaring type,
// and use it instead.
throw new InvalidOperationException("Cannot manually JIT a method");
}
else if (GetUninitializedObject != null)
{
sender = GetUninitializedObject(declaringType);
}
else
{
/* TODO
* Since I just made the whole 'gotta JIT the method' step mandatory
* in the MethodRedirection ctor, i should make sure this always returns true.
* That means looking up every type for overriding types for the throwing step above,
* and testing every possible constructor to create the instance.
*
* Additionally, if we want to go even further, we can repeat this step for every
* single argument of the ctor, thus making sure that we end up having an actual clreplaced.
* In this case, unless the user wants to instantiate an abstract clreplaced with no overriding clreplaced,
* everything'll work. HOWEVER, performances would be less-than-ideal. A simple Redirection
* may mean scanning the replacedembly a dozen times for overriding types, calling their constructors
* hundreds of times, knowing that all of them will be slow (Reflection + Try/Catch blocks aren't
* perfs-friendly).
*/
ConstructorInfo ctor = declaringType.GetConstructor(Type.EmptyTypes);
if (ctor != null)
{
sender = ctor.Invoke(null);
}
else
{
ConstructorInfo[] ctors = declaringType.GetConstructors(ALL_INSTANCE);
Array.Sort(ctors, (a, b) => a.GetParameters().Length.CompareTo(b.GetParameters().Length));
ctor = ctors[0];
try
{
sender = ctor.Invoke(GetArguments(ctor.GetParameters()));
}
catch (TargetInvocationException)
{
// Nothing we can do, give up.
return false;
}
}
}
}
try
{
method.Invoke(sender, GetArguments(method.GetParameters()));
}
catch (TargetInvocationException)
{
// That's okay.
}
return true;
}
19
View Source File : Serializer.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
static Func<T, Dictionary<string, string>> CompileSerializer()
{
var o_t = typeof(T);
var o = Expression.Parameter(o_t, "original");
var o_get_object_data = o_t.GetMethod("GetObjectData");
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Variable(d_t, "d"); // define object variable
var d_init = Expression.MemberInit(Expression.New(d_t)); // object ctor
var d_add = d_t.GetMethod("Add"); // add method
var fc_t = typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_get_enumerator = info_t.GetMethod("GetEnumerator");
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(SerializationInfoEnumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_name = Expression.Property(enumerator, "Name");
var enumerator_value = Expression.Property(enumerator, "Value");
var mi_to_string = typeof(Object).GetMethod("ToString", new Type[0]);
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { d, fc, info, ctx },
Expression.replacedign(d, d_init),
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.Call(o, o_get_object_data, info, ctx),
Expression.Block(new[] { enumerator },
Expression.replacedign(enumerator, Expression.Call(info, info_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_move_next), // test
Expression.IfThen(
Expression.NotEqual(enumerator_value, Expression.Constant(null)),
Expression.Call(d, d_add, enumerator_name, Expression.Call(enumerator_value, mi_to_string))
),
Expression.Break(exit_loop)), // if false
exit_loop)),
d); // return
// compile
return Expression.Lambda<Func<T, Dictionary<string, string>>>(body, o)
.Compile();
}
19
View Source File : EntityMapperProvider.cs
License : Apache License 2.0
Project Creator : 1448376744
License : Apache License 2.0
Project Creator : 1448376744
private Func<object, Dictionary<string, object>> CreateTypeDeserializerHandler(Type type)
{
var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
var methodName = $"{type.Name}Deserializer{Guid.NewGuid():N}";
var dynamicMethod = new DynamicMethod(methodName, typeof(Dictionary<string, object>), new Type[] { typeof(object) }, type, true);
var generator = dynamicMethod.GetILGenerator();
LocalBuilder enreplacedyLocal1 = generator.DeclareLocal(typeof(Dictionary<string, object>));
LocalBuilder enreplacedyLocal2 = generator.DeclareLocal(type);
generator.Emit(OpCodes.Newobj, typeof(Dictionary<string, object>).GetConstructor(Type.EmptyTypes));
generator.Emit(OpCodes.Stloc, enreplacedyLocal1);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Castclreplaced, type);
generator.Emit(OpCodes.Stloc, enreplacedyLocal2);
foreach (var item in properties)
{
generator.Emit(OpCodes.Ldloc, enreplacedyLocal1);
generator.Emit(OpCodes.Ldstr, item.Name);
generator.Emit(OpCodes.Ldloc, enreplacedyLocal2);
generator.Emit(OpCodes.Callvirt, item.GetGetMethod());
if (item.PropertyType.IsValueType)
{
generator.Emit(OpCodes.Box, item.PropertyType);
}
var addMethod = typeof(Dictionary<string, object>).GetMethod(nameof(Dictionary<string, object>.Add), new Type[] { typeof(string), typeof(object) });
generator.Emit(OpCodes.Callvirt, addMethod);
}
generator.Emit(OpCodes.Ldloc, enreplacedyLocal1);
generator.Emit(OpCodes.Ret);
return dynamicMethod.CreateDelegate(typeof(Func<object, Dictionary<string, object>>)) as Func<object, Dictionary<string, object>>;
}
19
View Source File : TypeExtend.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
public static Func<TRes> CreateFunc<TRes>(TypeInfo callInfo, string methodName, TypeInfo resInfo)
{
var typeConstructor = resInfo.GetConstructor(Type.EmptyTypes);
if (typeConstructor == null)
throw new ArgumentException($"类型{callInfo.FullName}没有无参构造函数");
var innerMethod = callInfo.GetMethod(methodName);
if (innerMethod == null)
throw new ArgumentException($"类型{callInfo.FullName}没有名称为{methodName}的方法");
if (innerMethod.ReturnType != resInfo)
throw new ArgumentException($"类型{callInfo.FullName}的方法{methodName}返回值不为{resInfo.FullName}");
var args = innerMethod.GetParameters();
if (args.Length > 0)
throw new ArgumentException($"类型{callInfo.FullName}的方法{methodName}参数不为空");
//构造匿名方法
var callMethod = new DynamicMethod(methodName, typeof(TRes), null);
//构造动态IL(方法内部实现)
var il = callMethod.GetILGenerator();
il.Emit(OpCodes.Nop);
//1 调用对象构造
il.Emit(OpCodes.Newobj, typeConstructor);
var call = il.DeclareLocal(callInfo);
il.Emit(OpCodes.Stloc, call);
//3 方法调用
il.Emit(OpCodes.Ldloc, call);
il.Emit(OpCodes.Callvirt, innerMethod);
var ret = il.DeclareLocal(innerMethod.ReturnType);
//4 返回值转换
il.Emit(OpCodes.Stloc, ret);
il.Emit(OpCodes.Ldloc, ret);
il.Emit(OpCodes.Castclreplaced, typeof(TRes).GetTypeInfo());
var res = il.DeclareLocal(resInfo);
//5 返回
il.Emit(OpCodes.Stloc, res);
il.Emit(OpCodes.Ldloc, res);
il.Emit(OpCodes.Ret);
//返回动态委托
return callMethod.CreateDelegate(typeof(Func<TRes>)) as Func<TRes>;
}
19
View Source File : UMAData.cs
License : Apache License 2.0
Project Creator : A7ocin
License : Apache License 2.0
Project Creator : A7ocin
public T GetOrCreateDna<T>()
where T : UMADnaBase
{
T res = GetDna<T>();
if (res == null)
{
res = typeof(T).GetConstructor(System.Type.EmptyTypes).Invoke(null) as T;
umaDna.Add(res.DNATypeHash, res);
dnaValues.Add(res);
}
return res;
}
19
View Source File : ICollectionResolverTest_TypeIsCollection.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void IListImpl_ObjecreplacedemTypeColloctionCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_IList_ObjecreplacedemTypeColloctionCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(object));
constructor.Is(typeof(_IList_ObjecreplacedemTypeColloctionCtor).GetConstructor(new Type[] { typeof(List<object>) }));
}
19
View Source File : EntityMapperProvider.cs
License : Apache License 2.0
Project Creator : 1448376744
License : Apache License 2.0
Project Creator : 1448376744
public ConstructorInfo FindConstructor(Type csharpType)
{
var constructor = csharpType.GetConstructor(Type.EmptyTypes);
if (constructor == null)
{
var constructors = csharpType.GetConstructors();
constructor = constructors.Where(a => a.GetParameters().Length == constructors.Max(s => s.GetParameters().Length)).FirstOrDefault();
}
return constructor;
}
19
View Source File : NativeDecimalGetterHelper.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
private static Func<Decimal, DecimalBinaryBits> Build()
{
ParameterExpression de = Expression.Parameter(typeof(Decimal));
Expression low, mid, high, flags;
try
{
//FRAMEWORK
low = Expression.Field(de, typeof(Decimal).GetField("lo", BindingFlags.Instance | BindingFlags.NonPublic));
mid = Expression.Field(de, typeof(Decimal).GetField("mid", BindingFlags.Instance | BindingFlags.NonPublic));
high = Expression.Field(de, typeof(Decimal).GetField("hi", BindingFlags.Instance | BindingFlags.NonPublic));
flags = Expression.Field(de, typeof(Decimal).GetField("flags", BindingFlags.Instance | BindingFlags.NonPublic));
}
catch
{
try
{
low = Expression.Convert(Expression.Field(de, typeof(Decimal).GetField("Low", BindingFlags.Instance | BindingFlags.NonPublic)), typeof(int));
mid = Expression.Convert(Expression.Field(de, typeof(Decimal).GetField("Mid", BindingFlags.Instance | BindingFlags.NonPublic)), typeof(int));
high = Expression.Convert(Expression.Field(de, typeof(Decimal).GetField("High", BindingFlags.Instance | BindingFlags.NonPublic)), typeof(int));
flags = Expression.Field(de, typeof(Decimal).GetField("_flags", BindingFlags.Instance | BindingFlags.NonPublic));
}
catch (Exception ex)
{
throw BssomSerializationTypeFormatterException.TypeFormatterError(typeof(decimal), ex.Message);
}
}
NewExpression body = Expression.New(typeof(DecimalBinaryBits).GetConstructor(new Type[] { typeof(int), typeof(int), typeof(int), typeof(int) }), low, mid, high, flags);
return Expression.Lambda<Func<Decimal, DecimalBinaryBits>>(body, de).Compile();
}
19
View Source File : IDictionaryResolverTest_TypeIsIDictionary.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void DictionaryIsSpecifiedCapacityCtor()
{
IDictionaryResolver.TypeIsDictionary(typeof(Dictionary<int, int>),
out ConstructorInfo constructor, out bool typeIsGeneric, out Type genericTypeDefinition, out Type genericKeyType, out Type genericValueType)
.IsTrue();
genericKeyType.Is(typeof(int));
genericValueType.Is(typeof(int));
constructor.Is(typeof(Dictionary<int, int>).GetConstructor(new Type[] { typeof(int) }));
}
19
View Source File : ICollectionResolverTest_TypeIsCollection.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
[Fact]
public void GenerIListImpl_SameItemTypeColloctionCtor_IsCollection()
{
ICollectionResolver.TypeIsCollection(typeof(_GenerIList_Int_SameItemTypeColloctionCtor),
out ConstructorInfo constructor,
out Type itemType,
out bool isImplGenerIList, out bool IsImplIList, out bool isImplGenerICollec, out bool isImplIReadOnlyList).IsTrue();
itemType.Is(typeof(int));
constructor.Is(typeof(_GenerIList_Int_SameItemTypeColloctionCtor).GetConstructor(new Type[] { typeof(List<int>) }));
isImplGenerIList.IsTrue();
}
19
View Source File : ActivationConfigurationTests.cs
License : MIT License
Project Creator : ababik
License : MIT License
Project Creator : ababik
[TestMethod]
public void ConfigureByConstructorAndParameters_InvalidParameter_Fail()
{
var user = new User(1, "Joe", "Doe");
var constructor = user.GetType().GetConstructor(new[] { typeof(string), typeof(string) });
var type = typeof(Employee);
var firstNameParameter = type.GetConstructor(new[] { typeof(Guid), typeof(string), typeof(string) }).GetParameters().Single(x => x.Name == "firstName");
var firstNameProperty = type.GetProperty("FirstName");
try
{
var config = new ActivationConfiguration()
.Configure(constructor, new Dictionary<ParameterInfo, PropertyInfo>() { [firstNameParameter] = firstNameProperty });
}
catch (Exception ex) when (ex.Message == $"Invalid parameter '{firstNameParameter.Name}'. Parameter must be a member of '{constructor.DeclaringType}' constructor.")
{
return;
}
replacedert.Fail();
}
See More Examples