Skip to content

Commit 15ef85f

Browse files
metoulemetoule
authored
No longer store MethodData as static variables (#365)
1 parent f71c941 commit 15ef85f

File tree

5 files changed

+191
-46
lines changed

5 files changed

+191
-46
lines changed

‎src/DynamicExpresso.Core/Parsing/ParseSignatures.cs‎

Lines changed: 21 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,43 +1,42 @@
11
using System;
22
using System.Collections.Generic;
33
using System.Linq;
4+
using System.Reflection;
45
using DynamicExpresso.Reflection;
56

67
namespace DynamicExpresso.Parsing
78
{
9+
/// <summary>
10+
/// Contains all the signatures for the binary and unary operators supported by DynamicExpresso.
11+
/// It allows to reuse the existing method resolutions logic in <see cref="Resolution.MethodResolution"/>.
12+
/// </summary>
813
internal static class ParseSignatures
914
{
10-
private static MethodData[] MakeUnarySignatures(params Type[] possibleOperandTypes)
15+
private static MethodBase[] MakeUnarySignatures(params Type[] possibleOperandTypes)
1116
{
12-
var signatures = new MethodData[possibleOperandTypes.Length];
17+
var signatures = new MethodBase[possibleOperandTypes.Length];
1318
for (var i = 0; i < possibleOperandTypes.Length; i++)
1419
{
15-
signatures[i] = new MethodData
16-
{
17-
Parameters = new[] { new SimpleParameterInfo(possibleOperandTypes[i]) },
18-
};
20+
signatures[i] = new SimpleMethodSignature(possibleOperandTypes[i]);
1921
}
2022
return signatures;
2123
}
2224

23-
private static MethodData[] MakeBinarySignatures(IList<(Type, Type)> possibleOperandTypes)
25+
private static MethodBase[] MakeBinarySignatures(IList<(Type, Type)> possibleOperandTypes)
2426
{
25-
var signatures = new MethodData[possibleOperandTypes.Count];
27+
var signatures = new MethodBase[possibleOperandTypes.Count];
2628
for (var i = 0; i < possibleOperandTypes.Count; i++)
2729
{
2830
var (left, right) = possibleOperandTypes[i];
29-
signatures[i] = new MethodData
30-
{
31-
Parameters = new[] { new SimpleParameterInfo(left), new SimpleParameterInfo(right) },
32-
};
31+
signatures[i] = new SimpleMethodSignature(left, right);
3332
}
3433
return signatures;
3534
}
3635

3736
/// <summary>
3837
/// Signatures for the binary logical operators.
3938
/// </summary>
40-
public static MethodData[] LogicalSignatures = MakeBinarySignatures(new[]
39+
public static MethodBase[] LogicalSignatures = MakeBinarySignatures(new[]
4140
{
4241
(typeof(bool), typeof(bool) ),
4342
(typeof(bool?), typeof(bool?)),
@@ -46,7 +45,7 @@ private static MethodData[] MakeBinarySignatures(IList<(Type, Type)> possibleOpe
4645
/// <summary>
4746
/// Signatures for the binary arithmetic operators.
4847
/// </summary>
49-
public static MethodData[] ArithmeticSignatures = MakeBinarySignatures(new[]
48+
public static MethodBase[] ArithmeticSignatures = MakeBinarySignatures(new[]
5049
{
5150
(typeof(int), typeof(int) ),
5251
(typeof(uint), typeof(uint) ),
@@ -67,7 +66,7 @@ private static MethodData[] MakeBinarySignatures(IList<(Type, Type)> possibleOpe
6766
/// <summary>
6867
/// Signatures for the binary relational operators.
6968
/// </summary>
70-
public static MethodData[] RelationalSignatures = ArithmeticSignatures.Concat(MakeBinarySignatures(new[]
69+
public static MethodBase[] RelationalSignatures = ArithmeticSignatures.Concat(MakeBinarySignatures(new[]
7170
{
7271
(typeof(string), typeof(string) ),
7372
(typeof(char), typeof(char) ),
@@ -81,12 +80,12 @@ private static MethodData[] MakeBinarySignatures(IList<(Type, Type)> possibleOpe
8180
/// <summary>
8281
/// Signatures for the binary equality operators.
8382
/// </summary>
84-
public static MethodData[] EqualitySignatures = RelationalSignatures.Concat(LogicalSignatures).ToArray();
83+
public static MethodBase[] EqualitySignatures = RelationalSignatures.Concat(LogicalSignatures).ToArray();
8584

8685
/// <summary>
8786
/// Signatures for the binary + operators.
8887
/// </summary>
89-
public static MethodData[] AddSignatures = ArithmeticSignatures.Concat(MakeBinarySignatures(new[]
88+
public static MethodBase[] AddSignatures = ArithmeticSignatures.Concat(MakeBinarySignatures(new[]
9089
{
9190
(typeof(DateTime), typeof(TimeSpan) ),
9291
(typeof(TimeSpan), typeof(TimeSpan) ),
@@ -97,7 +96,7 @@ private static MethodData[] MakeBinarySignatures(IList<(Type, Type)> possibleOpe
9796
/// <summary>
9897
/// Signatures for the binary - operators.
9998
/// </summary>
100-
public static MethodData[] SubtractSignatures = AddSignatures.Concat(MakeBinarySignatures(new[]
99+
public static MethodBase[] SubtractSignatures = AddSignatures.Concat(MakeBinarySignatures(new[]
101100
{
102101
(typeof(DateTime), typeof(DateTime)),
103102
(typeof(DateTime?), typeof(DateTime?)),
@@ -106,28 +105,28 @@ private static MethodData[] MakeBinarySignatures(IList<(Type, Type)> possibleOpe
106105
/// <summary>
107106
/// Signatures for the unary - operators.
108107
/// </summary>
109-
public static MethodData[] NegationSignatures = MakeUnarySignatures(
108+
public static MethodBase[] NegationSignatures = MakeUnarySignatures(
110109
typeof(int), typeof(uint), typeof(long), typeof(ulong), typeof(float), typeof(double), typeof(decimal),
111110
typeof(int?), typeof(uint?), typeof(long?), typeof(ulong?), typeof(float?), typeof(double?), typeof(decimal?)
112111
);
113112

114113
/// <summary>
115114
/// Signatures for the unary not (!) operator.
116115
/// </summary>
117-
public static MethodData[] NotSignatures = MakeUnarySignatures(typeof(bool), typeof(bool?));
116+
public static MethodBase[] NotSignatures = MakeUnarySignatures(typeof(bool), typeof(bool?));
118117

119118
/// <summary>
120119
/// Signatures for the bitwise completement operators.
121120
/// </summary>
122-
public static MethodData[] BitwiseComplementSignatures = MakeUnarySignatures(
121+
public static MethodBase[] BitwiseComplementSignatures = MakeUnarySignatures(
123122
typeof(int), typeof(uint), typeof(long), typeof(ulong),
124123
typeof(int?), typeof(uint?), typeof(long?), typeof(ulong?)
125124
);
126125

127126
/// <summary>
128127
/// Signatures for the left and right shift operators.
129128
/// </summary>
130-
public static MethodData[] ShiftSignatures = MakeBinarySignatures(new[]
129+
public static MethodBase[] ShiftSignatures = MakeBinarySignatures(new[]
131130
{
132131
(typeof(int), typeof(int) ),
133132
(typeof(uint), typeof(int) ),

‎src/DynamicExpresso.Core/Parsing/Parser.cs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1893,14 +1893,14 @@ private bool IsDynamicExpression(Expression instance)
18931893
// return GetNonNullableType(type).IsEnum;
18941894
//}
18951895

1896-
private void CheckAndPromoteOperand(MethodData[] unarySignatures, ref Expression expr)
1896+
private void CheckAndPromoteOperand(MethodBase[] unarySignatures, ref Expression expr)
18971897
{
18981898
var args = PrepareOperandArguments(unarySignatures, new[] { expr });
18991899

19001900
expr = args[0];
19011901
}
19021902

1903-
private void CheckAndPromoteOperands(MethodData[] binarySignatures, ref Expression left, ref Expression right)
1903+
private void CheckAndPromoteOperands(MethodBase[] binarySignatures, ref Expression left, ref Expression right)
19041904
{
19051905
// if one of the operands is the nullable version of the other, promote the non-nullablte to the nullable version
19061906
if (TypeUtils.TryGetNonNullableType(left.Type, out var nonNullableLeftType) && nonNullableLeftType == right.Type)
@@ -1914,7 +1914,7 @@ private void CheckAndPromoteOperands(MethodData[] binarySignatures, ref Expressi
19141914
right = args[1];
19151915
}
19161916

1917-
private IList<Expression> PrepareOperandArguments(MethodData[] signatures, Expression[] args)
1917+
private IList<Expression> PrepareOperandArguments(MethodBase[] signatures, Expression[] args)
19181918
{
19191919
var applicableMethods = MethodResolution.FindBestMethod(signatures, args);
19201920
if (applicableMethods.Count == 1)

‎src/DynamicExpresso.Core/Reflection/SimpleMethodSignature.cs‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
using System;
2+
using System.Globalization;
3+
using System.Reflection;
4+
5+
namespace DynamicExpresso.Reflection
6+
{
7+
/// <summary>
8+
/// A simple implementation of <see cref="MethodBase"/> that only provides the method signature (ie. the parameter types).
9+
/// </summary>
10+
internal class SimpleMethodSignature : MethodBase
11+
{
12+
private class SimpleParameterInfo : ParameterInfo
13+
{
14+
public SimpleParameterInfo(Type parameterType)
15+
{
16+
ClassImpl = parameterType;
17+
DefaultValueImpl = null;
18+
}
19+
20+
public override bool HasDefaultValue => false;
21+
}
22+
23+
public override MethodAttributes Attributes { get; } = MethodAttributes.Public;
24+
public override MemberTypes MemberType { get; } = MemberTypes.Method;
25+
26+
private readonly ParameterInfo[] _parameterInfos;
27+
public SimpleMethodSignature(params Type[] parameterTypes)
28+
{
29+
_parameterInfos = new ParameterInfo[parameterTypes.Length];
30+
for (var i = 0; i < parameterTypes.Length; i++)
31+
{
32+
_parameterInfos[i] = new SimpleParameterInfo(parameterTypes[i]);
33+
}
34+
}
35+
36+
public override ParameterInfo[] GetParameters()
37+
{
38+
return _parameterInfos;
39+
}
40+
41+
public override RuntimeMethodHandle MethodHandle => throw new NotImplementedException();
42+
public override string Name => throw new NotImplementedException();
43+
public override Type DeclaringType => throw new NotImplementedException();
44+
public override Type ReflectedType => throw new NotImplementedException();
45+
46+
public override object[] GetCustomAttributes(bool inherit)
47+
{
48+
throw new NotImplementedException();
49+
}
50+
51+
public override object[] GetCustomAttributes(Type attributeType, bool inherit)
52+
{
53+
throw new NotImplementedException();
54+
}
55+
56+
public override MethodImplAttributes GetMethodImplementationFlags()
57+
{
58+
throw new NotImplementedException();
59+
}
60+
61+
public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
62+
{
63+
throw new NotImplementedException();
64+
}
65+
66+
public override bool IsDefined(Type attributeType, bool inherit)
67+
{
68+
throw new NotImplementedException();
69+
}
70+
}
71+
}

‎src/DynamicExpresso.Core/Reflection/SimpleParameterInfo.cs‎

Lines changed: 0 additions & 21 deletions
This file was deleted.

‎test/DynamicExpresso.UnitTest/ThreadingTest.cs‎

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,96 @@
1+
using System.Collections.Generic;
2+
using System.Globalization;
3+
using System.Linq;
4+
using System.Threading;
5+
using System.Threading.Tasks;
6+
using NUnit.Framework;
7+
8+
namespace DynamicExpresso.UnitTest
9+
{
10+
[TestFixture]
11+
public class ThreadingTest
12+
{
13+
private static void DynamicExpresso_Interpreter_Eval1()
14+
{
15+
var parser = new Interpreter();
16+
parser.SetVariable("C0", 5);
17+
parser.SetVariable("x", 50);
18+
Assert.That(parser.Identifiers.First(i => i.Name == "C0").Expression.ToString(), Is.EqualTo("5"));
19+
Assert.That(parser.Identifiers.First(i => i.Name == "x").Expression.ToString(), Is.EqualTo("50"));
20+
21+
var result = parser.Eval<double>("x*C0");
22+
Assert.That(result, Is.EqualTo(250d));
23+
}
24+
25+
private static void DynamicExpresso_Interpreter_Eval2()
26+
{
27+
var parser = new Interpreter();
28+
parser.SetVariable("C0", 5);
29+
parser.SetVariable("y", 250);
30+
Assert.That(parser.Identifiers.First(i => i.Name == "C0").Expression.ToString(), Is.EqualTo("5"));
31+
Assert.That(parser.Identifiers.First(i => i.Name == "y").Expression.ToString(), Is.EqualTo("250"));
32+
33+
var result = parser.Eval<double>("y/C0");
34+
Assert.That(result, Is.EqualTo(50d));
35+
}
36+
37+
private static void DynamicExpresso_Interpreter_Eval_Sequence()
38+
{
39+
for (var i = 0; i < 10; i++)
40+
{
41+
DynamicExpresso_Interpreter_Eval1();
42+
DynamicExpresso_Interpreter_Eval2();
43+
}
44+
}
45+
46+
[Test]
47+
public async Task DynamicExpresso_Interpreter_Eval_Threading()
48+
{
49+
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
50+
51+
const int NumTasks = 5;
52+
53+
var tasksToRun = new List<Task>();
54+
for (var i = 0; i < NumTasks; i++)
55+
{
56+
var taskToRunLater = new Task(DynamicExpresso_Interpreter_Eval_Sequence);
57+
tasksToRun.Add(taskToRunLater);
58+
}
59+
60+
foreach (var taskToRunLater in tasksToRun)
61+
{
62+
taskToRunLater.Start();
63+
}
64+
65+
foreach (var taskToRunLater in tasksToRun)
66+
{
67+
await taskToRunLater;
68+
}
69+
}
70+
71+
[Test]
72+
public void Should_Pass_Parallel_Eval()
73+
{
74+
var target = new Interpreter();
75+
var conds = Enumerable.Repeat("Country != \"France\"", 10);
76+
var parameters = new[] { new Parameter("Country", "Italy") };
77+
Parallel.ForEach(conds, exp =>
78+
{
79+
Assert.That(target.Eval(exp, parameters), Is.True);
80+
});
81+
}
82+
83+
[Test]
84+
public void Should_Fail_Parallel_Eval()
85+
{
86+
var target = new Interpreter();
87+
var conds = Enumerable.Repeat("Country != \"France\"", 10);
88+
89+
Parallel.ForEach(conds, exp =>
90+
{
91+
var parameters = new[] { new Parameter("Country", "Italy") };
92+
Assert.That(target.Eval(exp, parameters), Is.True);
93+
});
94+
}
95+
}
96+
}

0 commit comments

Comments
 (0)