Verfolgung der statischen Konstruktorausführung

Question

Ich stieß hier auf ein Problem, bei dem ein statischer Konstruktor einer meiner Klassen angerufen wird, bevor er sein sollte. (Dh di/ioc ist nicht eingerichtet und wird vom Service -Locator zurückgezogen.)

Ich habe leider nicht viel Kontrolle über den statischen Konstruktor. Fragen Sie mich nicht, warum es sich auf DI/IOC verlässt, um eingerichtet zu werden, aber es ist.

In meiner App sollte nichts auf diese Klasse statisch oder auf andere Weise verweisen, bevor mein IOC bereit ist, zu gehen, aber der statische Konstruktor wird trotzdem ausgeführt.

Gibt es eine einfache Möglichkeit, festzustellen, welche Linie der Konstruktor ausführte? HINWEIS: Ich kann in der nicht brechen static constructor Da dies alles passiert, bevor der Remote -Debugger für ASP.NET mit dem Webserver anhängen kann (in global.asax.cs)

Answer 1

Sie haben keine Kontrolle darüber, wann der statische Konstruktor ausgeführt wird. Bewegen Sie alles, was Sie tun, von Ihrem Konstruktor zu einer Statik Initialisieren() Funktion. Rufen Sie das an, wenn Sie bereit sind. Hängen Sie nicht ab, wann der statische Konstruktor ausgeführt wird.

Überprüfen Sie dies Verknüpfung

Statische Konstrukteure haben die folgenden

Eigenschaften:

Ein statischer Konstruktor wird automatisch aufgerufen, um die Klasse zu initialisieren, bevor die erste Instanz erstellt wird oder statische Mitglieder verwiesen werden.

Ein statischer Konstruktor kann nicht direkt aufgerufen werden.

Der Benutzer hat keine Kontrolle darüber, wann der statische Konstruktor im Programm ausgeführt wird.

Answer 2

Wie immer verwenden Sie:

Debugger.Break()

Answer 3

Dies könnte mit Windbg und Sosex erfolgen. Hier ist der Beispielcode

using System;
namespace Code
{
class Test
{
  public static int i;
  static Test()
  {
    i = 10;
    Console.WriteLine(i);
  }
  static void Main()
  {
    Console.WriteLine(Test.i);
    Console.Read();
  }
}
}

Und hier sind die Schritte

1. Befestigen Sie den Prozess an Windbg
2. Laden Sie Sosex mit .load sosex
3. Nächste Ausgabe des Befehls !mbm *Code.Test..cctor*
4. Der Debugger bricht den Anruf zum statischen Konstruktor aus !mk Um den Callstack zu bekommen

Hier ist die Ausgabe von !mk Für die obige Probe

0:000> !mk
Thread 0:
     ESP              EIP
00:M 000000000026def8 000007ff00150120 Code.Test..cctor()(+0x0 IL)(+0x0 Native)
01:U 000000000026df00 000007fef43a10b4 clr!CallDescrWorker+0x84
02:U 000000000026df40 000007fef43a11c9 clr!CallDescrWorkerWithHandler+0xa9
03:U 000000000026dfc0 000007fef43a32b4 clr!DispatchCallDebuggerWrapper+0x74
04:U 000000000026e060 000007fef43aafdf clr!MethodTable::RunClassInitEx+0x1ff
05:U 000000000026e1b0 000007fef43aaca8 clr!MethodTable::DoRunClassInitThrowing+0x55e
06:U 000000000026ec70 000007fef43a3470 clr!MethodTable::CheckRunClassInitThrowing+0xe3
07:U 000000000026eca0 000007fef44cb848 clr!MethodDesc::DoPrestub+0x587
08:U 000000000026edb0 000007fef43a23f3 clr!PreStubWorker+0x1df
09:U 000000000026ee70 000007fef4362d07 clr!ThePreStubAMD64+0x87
0a:U 000000000026ef40 000007fef43a10b4 clr!CallDescrWorker+0x84
0b:U 000000000026ef80 000007fef43a11c9 clr!CallDescrWorkerWithHandler+0xa9
0c:U 000000000026f000 000007fef43a1245 clr!MethodDesc::CallDescr+0x2a1
0d:U 000000000026f230 000007fef44a1675 clr!ClassLoader::RunMain+0x228
0e:U 000000000026f480 000007fef44a17ac clr!Assembly::ExecuteMainMethod+0xac
0f:U 000000000026f730 000007fef44a1562 clr!SystemDomain::ExecuteMainMethod+0x452
10:U 000000000026fce0 000007fef44a3dd6 clr!ExecuteEXE+0x43
11:U 000000000026fd40 000007fef44a3cf3 clr!CorExeMainInternal+0xc4
12:U 000000000026fdb0 000007fef4527365 clr!CorExeMain+0x15
13:U 000000000026fdf0 000007fef6883309 mscoreei!CorExeMain+0x41
14:U 000000000026fe20 000007fef6915b21 MSCOREE!CorExeMain_Exported+0x57
15:U 000000000026fe50 0000000077a6f56d KERNEL32!BaseThreadInitThunk+0xd
16:U 000000000026fe80 0000000077ba3021 ntdll!RtlUserThreadStart+0x1d

HTH

Answer 4

Vielleicht sollten Sie mit dem statischen Konstruktor überspringen? Ist es notwendigerweise?

public class SomeClass
{
    private static bool IsInizialized = false;

    public SomeClass()
    {
        if (!IsInizialized)
        {
            // static constuctor thread safe but this doesn't
            //
            lock (this)
            {
                if (!IsInizialized)
                {
                    IsInizialized = true;
                    // all what static constructor does
                }
            }
        }
    }
}