IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

Formule dans une propriété


Sujet :

C#

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Futur Membre du Club
    Homme Profil pro
    Responsable de compte
    Inscrit en
    Novembre 2019
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Responsable de compte
    Secteur : Service public

    Informations forums :
    Inscription : Novembre 2019
    Messages : 2
    Par défaut 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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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);
            }

  2. #2
    Membre extrêmement actif
    Inscrit en
    Avril 2008
    Messages
    2 573
    Détails du profil
    Informations personnelles :
    Âge : 65

    Informations forums :
    Inscription : Avril 2008
    Messages : 2 573
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ...

  3. #3
    Futur Membre du Club
    Homme Profil pro
    Responsable de compte
    Inscrit en
    Novembre 2019
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Responsable de compte
    Secteur : Service public

    Informations forums :
    Inscription : Novembre 2019
    Messages : 2
    Par défaut Un gros merci
    Un très gros merci

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 1
    Dernier message: 15/09/2016, 21h41
  2. Une question pour les RadioButton
    Par jacko842 dans le forum Windows Forms
    Réponses: 3
    Dernier message: 26/02/2010, 16h24
  3. Une question pour un champion
    Par yoann7638 dans le forum Débuter avec Java
    Réponses: 3
    Dernier message: 26/06/2008, 10h04
  4. Bonjour à tous, j'ai quelques questions
    Par Apolloman dans le forum Windows Vista
    Réponses: 30
    Dernier message: 27/01/2008, 00h58
  5. Encore une question, pour retrouver 2 valeur d'une table
    Par danje dans le forum Langage SQL
    Réponses: 5
    Dernier message: 15/09/2005, 00h11

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo