Discussion :

[zoubidaman]

Bonjour à tous,

j'ai vu dans la MSDN qu'une variable statique est initialisée lorsque le CLR charge la classe/namespace qui contient la variable.

Comment est-ce que je peux faire comme en C++ où les variables statiques sont chargées lorsque l'application se lance?

Je voudrais faire une factory où les objets qui peuvent être créés se chargent eux-même dans la factory, sans qu'on ait besoin d'ajouter manuellement les objets dans le code de la factory.

Voici le code que j'ai actuellement:

La factory:

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Test_Factory
{
    delegate ObjectFactory CreateObject();
 
    class Factory
    {
        private SortedDictionary<string, CreateObject> MapObjects = new SortedDictionary<string, CreateObject>();
        public List<string> ListObjects
        {
            get
            {
                return MapObjects.Keys.ToList();
            }
        }
 
        public bool Register(string ID, CreateObject createObjectDelegate)
        {
            try
            {
                MapObjects.Add(ID, createObjectDelegate);
            }
            catch (ArgumentException exp)
            {
                return false;
            }
 
            return true;
        }       
    }

Un objet qui peut-être créé par la factory

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Test_Factory
{
    class Object1 : ObjectFactory
    {
        private static string Identifier { get { return "Object1"; } }
        public static bool Created = Factory.Instance.Register("Object1", delegate() { return new Object1(); });
 
        public Object1()
        {
 
        }        
    }
}

Pour enregistrer l'objet dans la factory, je suis pour l'instant obligé de le faire manuellement dans le main de l'application:

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Test_Factory
{
    class Program
    {
        static void Main(string[] args)
        {
            bool f = Object1.Created;
 
            var query = from a in Factory.Instance.ListObjects
                        select a;
 
            foreach (var a in query)
                Console.WriteLine(a);
 
            Console.Read();
        }
    }
}

Des idées?

Merci d'avance

PS: j'ai pour l'instant une solution qui fonctionne à base de réflection, mais je suis assez circonspect vis à vis des performances ou de l'efficacité de cette solution.

[Sphax]

Hello,

Tu ne peux pas faire ça en C#. A l'époque ou j'ai voulu faire ce genre de chose pour les mêmes raisons (des classes qui s'enregistrent auprés d'une factory) j'ai trouvé ça (j'avais recopié le contenu d'un site et j'ai plus l'url désolé):

A static constructor is only guaranteed to run before the first use of the class ... so it won't run at assembly load time.

A module constructor is exactly what it sounds like, its a method that gets called when a module is loaded. Unfortunately, C# does not provide any way to create one, you'll have to dip down to the IL level (C++/CLI may also offer the ability to create a module constructor -- I'm not sure).

In order to add one to your C# code, you'll need a post-processing step. If in you C# code, you had an internal static method on MyClass in namespace MyNamespace called ModuleConstructor, you could build your C# assembly, then run it through ildasm to create an .il file. After the headers, add code like this:

.method private hidebysig specialname rtspecialname static void .cctor() cil managed
{
call void MyNamespace.MyClass::ModuleConstructor()
ret
}

Note, this code should go outside of any classes. That will cause your ModuleConstructor method to be called from the actual module constructor, allowing you to code the actual work in C# rather than IL.

Once you've modified the IL file, you can then ilasm it back into an assembly.

Je n'ai pas voulu implémenter cette solution .