Formule dans une propriété

Bonjour à tous,

J'aurais besoin d'aide pour résoudre un problème ci-dessous mes petites question en commentaires.

Un gros merci d'avance aux personnes pour votre aide :)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public static Type CompileResultType(string Name)
        {
            var typeBuilder = GetTypeBuilder(Name);
            ConstructorBuilder constructor = typeBuilder.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
            CreateProperty(typeBuilder, "Date2", typeof(DateTime));
            CreateProperty(typeBuilder, "Date1", typeof(DateTime)); 
 
          //for my third property   i would like to have a formula 
         // example:return Date2.Value.Subtract(Date1.Value).TotalMinutes
 
         //pour ma troisième propriété  j'aimerais avoir une formule 
         // exemple: return Date2.Value.Subtract(Date1.Value).TotalMinutes
 
            var newType = typeBuilder.CreateType();
            return newType;
        }
 
private static TypeBuilder GetTypeBuilder(string Name)
        {
            var typeSignature = Name;
            var an = new AssemblyName(typeSignature);
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(Assembly.GetExecutingAssembly().Location);
            TypeBuilder tb = moduleBuilder.DefineType(typeSignature,
                    TypeAttributes.Public |
                    TypeAttributes.Class |
                    TypeAttributes.AutoClass |
                    TypeAttributes.AnsiClass |
                    TypeAttributes.BeforeFieldInit |
                    TypeAttributes.AutoLayout,
                    null);
            return tb;
        }
 
private static void CreateProperty(TypeBuilder tb, string propertyName, Type propertyType)
        {
            FieldBuilder fieldBuilder = tb.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
 
            PropertyBuilder propertyBuilder = tb.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
            MethodBuilder getPropMthdBldr = tb.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType, Type.EmptyTypes);
            ILGenerator getIl = getPropMthdBldr.GetILGenerator();
 
            getIl.Emit(OpCodes.Ldarg_0);
            getIl.Emit(OpCodes.Ldfld, fieldBuilder);
            getIl.Emit(OpCodes.Ret);
 
            MethodBuilder setPropMthdBldr =
                tb.DefineMethod("set_" + propertyName,
                  MethodAttributes.Public |
                  MethodAttributes.SpecialName |
                  MethodAttributes.HideBySig,
                  null, new[] { propertyType });
 
            ILGenerator setIl = setPropMthdBldr.GetILGenerator();
            Label modifyProperty = setIl.DefineLabel();
            Label exitSet = setIl.DefineLabel();
 
            setIl.MarkLabel(modifyProperty);
            setIl.Emit(OpCodes.Ldarg_0);
            setIl.Emit(OpCodes.Ldarg_1);
            setIl.Emit(OpCodes.Stfld, fieldBuilder);
 
            setIl.Emit(OpCodes.Nop);
            setIl.MarkLabel(exitSet);
            setIl.Emit(OpCodes.Ret);
 
            propertyBuilder.SetGetMethod(getPropMthdBldr);
            propertyBuilder.SetSetMethod(setPropMthdBldr);
        }

bonjour

Formule ,formule magique dirait-je,dans une prop en IL ...
Faire une référence dans une prop A à une prop B dans un TypeBuilder ou constructeur de type exige simplement d'avoir
-une référence sur le Property Builder de B dans la Property Builder de A.
Faire référence dans une prop A à un method M dans un TypeBuilder exige simplement d'avoir
-une référence sur le Method Builder de M dans la Property Builder de A.
La raison vient simplement du fait que le "type" décrit par le TypeBuilder n'est pas encore créé (on ne peut écrire des choses du genre typeof(tontype) et donc la Reflection ne peut être utilisée).
Une autre conséquence est que les Property Builder ou Method Builder référencés doivent être définis en premier...

l'exemple code suivant illustre la déclaration du type C# suivant:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 public class Foo
    {
        public DateTime Date1 { get; set; }
        public DateTime Date2 { get; set; }
        public int ThirdProperty
        { 
            get { return CalcMinutes(Date2,Date1); } 
        }
 
 
        public Foo()
        {
        }
 
        public int CalcMinutes(DateTime t2, DateTime t1)
        {
            TimeSpan tms = t2.Subtract(t1);
            return tms.Days  * 3600+tms.Hours * 60+tms.Minutes ;
        }
    }

le même code émît en IL donne le class "generator" (ça me rappelle le géniteur) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
namespace WinEmitIL
{
    public static class TypeGenerator
    {
        public static Type BuildDynamicClass()
        {
 
            //AppDomain
            AppDomain myDomain = Thread.GetDomain();
 
            //Assembly
            AssemblyName myAsmName = new AssemblyName();
            myAsmName.Name = "MyDynamicAssembly";
 
            //Assembly  generate  persistable assembly .
            AssemblyBuilder myAsmBuilder = 
                myDomain.DefineDynamicAssembly(
                myAsmName, AssemblyBuilderAccess.RunAndSave);
 
            // DynamicModule.
            ModuleBuilder myModBuilder =
                myAsmBuilder.DefineDynamicModule(
                myAsmName.Name,
                myAsmName.Name + ".dll");
 
            // TypeBuilder 
            TypeBuilder tb = 
                myModBuilder.DefineType(
                "ClassData", TypeAttributes.Public);
 
            ConstructorInfo ctor =CreateCtor(tb);
 
            string propName1 = "Date1";
            PropertyBuilder propBld1= 
                CreateProperty(tb ,propName1,typeof(DateTime));
 
            string propName2 = "Date2"; 
            PropertyBuilder propBld2 = 
                CreateProperty(tb, propName2, typeof(DateTime));
 
 
            string mthdName = "CalcMinutes";
            Type[] mthdParams = { typeof(DateTime), typeof(DateTime) };
            Type returnType = typeof(int);
            MethodBuilder mthdBuilder = CalcMinutes(
                tb, mthdName,returnType,mthdParams,
                propBld2,propBld1);
 
            // note que cette prop est "construite"  apres 
            // la prop Date1,prop Date2 et le method CalcMinutes
            string propName3 = "ThirdProperty";
            PropertyBuilder propBld3 =
                CreateThirdProperty(tb, propName3, typeof(int), propBld2, propBld1, mthdBuilder);
 
            Type retval = tb.CreateType();
            myAsmBuilder.Save(myAsmName.Name + ".dll");
            return retval;
        }
 
        public static ConstructorBuilder CreateCtor(TypeBuilder tb)
        {
            var ctor = tb.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
            return ctor;
        }
 
        public static PropertyBuilder CreateProperty(
               TypeBuilder tb,
               string propertyName,
               Type propertyType)
        {
            FieldBuilder fieldBuilder = tb.DefineField(
                "_" + propertyName,
                propertyType, FieldAttributes.Private);
 
            PropertyBuilder propertyBuilder =
                tb.DefineProperty(propertyName,
                PropertyAttributes.HasDefault,
                propertyType, null);
 
 
            //  get  and property set  attributes.
            MethodAttributes getsetAttr =
                MethodAttributes.Public | MethodAttributes.SpecialName |
                    MethodAttributes.HideBySig;
            //get method
            MethodBuilder getPropMthdBldr =
                tb.DefineMethod("get_" + propertyName,
                getsetAttr,
                propertyType, Type.EmptyTypes);
            ILGenerator ILout = getPropMthdBldr.GetILGenerator();
 
            ILout.Emit(OpCodes.Ldarg_0);
            ILout.Emit(OpCodes.Ldfld, fieldBuilder);
            ILout.Emit(OpCodes.Ret);
 
            //set method
            MethodBuilder setPropMthdBldr =
                tb.DefineMethod("set_" + propertyName,
                  getsetAttr,
                  null, new[] { propertyType });
 
            ILout = setPropMthdBldr.GetILGenerator();
 
            ILout.Emit(OpCodes.Ldarg_0);
            ILout.Emit(OpCodes.Ldarg_1);
            ILout.Emit(OpCodes.Stfld, fieldBuilder);
            ILout.Emit(OpCodes.Ret);
 
            propertyBuilder.SetGetMethod(getPropMthdBldr);
            propertyBuilder.SetSetMethod(setPropMthdBldr);
            return propertyBuilder;
        }
        public static PropertyBuilder CreateThirdProperty(
            TypeBuilder tb,
            string propertyName,
            Type propertyType,
            PropertyBuilder propBld2,
            PropertyBuilder propBld1,
            MethodBuilder mthdBld)
        {
 
            PropertyBuilder propertyBuilder =
                tb.DefineProperty(propertyName,
                PropertyAttributes.HasDefault,
                propertyType, null);
 
 
            //  get  and property set  attributes.
            MethodAttributes getsetAttr =
                MethodAttributes.Public | MethodAttributes.SpecialName |
                    MethodAttributes.HideBySig;
            //get method
            MethodBuilder getPropMthdBldr =
                tb.DefineMethod("get_" + propertyName,
                getsetAttr,
                propertyType, Type.EmptyTypes);
 
 
            ILGenerator ILout = getPropMthdBldr.GetILGenerator();
            LocalBuilder date2 = ILout.DeclareLocal(typeof(DateTime));
            LocalBuilder date1 = ILout.DeclareLocal(typeof(DateTime));
 
 
            ILout.Emit(OpCodes.Ldarg, 0);   // // adress of  first argument(aka tb)
            ILout.Emit(OpCodes.Call, propBld2.GetGetMethod());
            ILout.Emit(OpCodes.Stloc, date2);// store in local variable
 
            ILout.Emit(OpCodes.Ldarg,0);
            ILout.Emit(OpCodes.Call,propBld1.GetGetMethod());
            ILout.Emit(OpCodes.Stloc, date1);// store in local variable
 
            ILout.Emit(OpCodes.Ldloc, date2); // value of  date2
            ILout.Emit(OpCodes.Ldloc, date1); // value of  date2
 
            ILout.Emit(OpCodes.Call, mthdBld);//call method on instance class(aka tb)
            ILout.Emit(OpCodes.Ret); // retourne la valeur calculée qui est toujours sur la pile 
 
            //pas de set method
            propertyBuilder.SetGetMethod(getPropMthdBldr);
            return propertyBuilder;
        }
 
        public static MethodBuilder CalcMinutes(
            TypeBuilder tb,
            string mthdName,
            Type returnType,
            Type[] mthdParams,
            PropertyBuilder propBld2,
            PropertyBuilder propBld1)
        {
 
            //method attributes
            MethodAttributes mthdAttr = MethodAttributes.Public | MethodAttributes.Static;
 
            MethodBuilder mthdBuilder = tb.DefineMethod(
                mthdName, mthdAttr,returnType , mthdParams) ;
 
 
            ILGenerator ILout = mthdBuilder.GetILGenerator();
            LocalBuilder date2 = ILout.DeclareLocal(typeof(DateTime));
            LocalBuilder date1 = ILout.DeclareLocal(typeof(DateTime));
            LocalBuilder tms = ILout.DeclareLocal(typeof(TimeSpan));
            LocalBuilder minutesDays = ILout.DeclareLocal(typeof(int));
            LocalBuilder minutesHours = ILout.DeclareLocal(typeof(int));
            LocalBuilder minutes = ILout.DeclareLocal(typeof(int));
            LocalBuilder num = ILout.DeclareLocal(typeof(int));
 
 
 
 
 
            ILout.Emit(OpCodes.Ldarga,0);     // adress of  first argument(aka tb)
            ILout.Emit(OpCodes.Call, propBld2.GetGetMethod());
            ILout.Emit(OpCodes.Stloc, date2); // store in local variable
 
            ILout.Emit(OpCodes.Ldarga, 0); // adress of first argument(aka tb)
            ILout.Emit(OpCodes.Call, propBld1.GetGetMethod());
            ILout.Emit(OpCodes.Stloc, date1);
 
            ILout.Emit(OpCodes.Ldarga, date2);// adress of  date2
            ILout.Emit(OpCodes.Ldarg, date1); // value  of  date1
            ILout.Emit(OpCodes.Call, typeof(DateTime).
                GetMethod("Subtract", new Type[] { typeof(DateTime) }));
            ILout.Emit(OpCodes.Stloc, tms);    // store in local variable of type TimeSpan
 
            // calc minutesDays
            ILout.Emit(OpCodes.Ldloca, tms);// adress of  tms
            ILout.Emit(OpCodes.Call, typeof(TimeSpan).
                GetProperty("Days", typeof(int)).GetGetMethod());
            ILout.Emit(OpCodes.Ldc_I4, 3600);
            ILout.Emit(OpCodes.Mul);
            ILout.Emit(OpCodes.Stloc, minutesDays);
 
             //calc minutesHours
            ILout.Emit(OpCodes.Ldloca, tms);
            ILout.Emit(OpCodes.Call, typeof(TimeSpan).
                 GetProperty("Hours", typeof(int)).GetGetMethod());
            ILout.Emit(OpCodes.Ldc_I4, 60);
            ILout.Emit(OpCodes.Mul);
            ILout.Emit(OpCodes.Stloc, minutesHours);
 
            // calc minutes
            ILout.Emit(OpCodes.Ldloca, tms); 
            ILout.Emit(OpCodes.Call, typeof(TimeSpan).
             GetProperty("Minutes", typeof(int)).GetGetMethod());
            ILout.Emit(OpCodes.Stloc, minutes);
 
            ILout.Emit(OpCodes.Ldloc, minutesDays);// load value of  local variale in stack
            ILout.Emit(OpCodes.Ldloc, minutesHours);// etc...
            ILout.Emit(OpCodes.Add);
            ILout.Emit(OpCodes.Ldloc, minutes);
            ILout.Emit(OpCodes.Add);
 
            ILout.Emit(OpCodes.Ret);
            return mthdBuilder;
        }
 
 
 
    }

le form user de test:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
namespace WinEmitIL
{
    public partial class TestGenerator : Form
    {
        private StringBuilder sb = null;
        public TestGenerator()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            sb = new StringBuilder();
 
 
            Type myType = TypeGenerator.BuildDynamicClass();
 
            object instance = Activator.CreateInstance(myType);
 
            var date1 = new DateTime(2019, 11, 21, 10, 17, 0);
            string propName1 = "Date1";
            myType.InvokeMember(
                propName1,
                BindingFlags.SetProperty,
                null,
                instance,
                new object[] { date1 });
            string propName2 = "Date2";
            var date2 = new DateTime(2019, 12, 21, 12, 39, 0);
            myType.InvokeMember(
                propName2,
                BindingFlags.SetProperty,
                null,
                instance,
                new object[] { date2 });
 
            //display properties values 
            DateTime getdt1 =
                (DateTime)myType.InvokeMember(
                propName1,
                BindingFlags.GetProperty,
                null,
                instance,
                null);
 
            DateTime getdt2 =
                (DateTime)myType.InvokeMember(
                propName2,
                BindingFlags.GetProperty,
                null,
                instance,
                null);
 
 
            //display properties values 
            string propName3 = "ThirdProperty";
            int getThirdProp =
                (int)myType.InvokeMember(
                propName3,
                BindingFlags.GetProperty,
                null,
                instance,
                null);
 
            sb.AppendLine("Date1 : " + getdt1.ToShortDateString() + " " + getdt1.ToLongTimeString());
            sb.AppendLine("Date2 : " + getdt2.ToShortDateString() + " " + getdt2.ToLongTimeString());
            sb.AppendLine("ThirdProp : " + getThirdProp.ToString());
 
            textBox1.Text = sb.ToString();
 
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            // verification
            sb = new StringBuilder();
            var date1 = new DateTime(2019, 11, 21, 10, 17, 0);
            var date2 = new DateTime(2019, 12, 21, 12, 39, 0);
 
            int test = date2.Subtract(date1).Days * 3600 +
                 date2.Subtract(date1).Hours * 60 +
                 date2.Subtract(date1).Minutes;
            sb.AppendLine("verification : " + test.ToString());
            textBox2.Text = sb.ToString();     
        }
    }
}

bon code ...

Un gros merci

Un très gros merci :)