it-swarm.com.de

Was ist und wie ein System.TypeInitializationException-Fehler behoben werden kann?

private static void Main(string[] args)
{
    string str = null;
    Logger.InitUserLogWithRotation();            // <--- error occur
    ...
}

Wenn ich ein Projekt baue, hat es keinen Fehler. Aber wenn ich es ausführte, wurde es immer abgebrochen.

Ich habe versucht, ein Projekt zu debuggen, aber in der ersten Zeile ist ein System.TypeInitializationException-Fehler aufgetreten.

Ich habe schon versucht zu googeln, habe aber noch keine Lösung gefunden.

Es scheint, dass jeder Initialisierungscode einer Variablen falsch ist, ihn aber nicht finden kann.

Bitte hilf mir. Ich bin neu in C #.

Vielen Dank.

※ Hier ist der Logger-Klassencode

public class Logger
{
    private static int HDLOG_PRIORITY_DEBUG = 4;
    private static int HDLOG_PRIORITY_ERROR = 1;
    private static int HDLOG_PRIORITY_FATAL = 0;
    private static int HDLOG_PRIORITY_INFO = 3;
    private static int HDLOG_PRIORITY_WARNING = 2;
    public static int LOG_LEVEL_DEBUG = 4;
    public static int LOG_LEVEL_ERROR = 2;
    public static int LOG_LEVEL_FATAL = 1;
    public static int LOG_LEVEL_INFO = 5;
    public static int LOG_LEVEL_WARNING = 3;
    private static string s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
    private static string s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");
    private static string s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
    private static bool s_consoleLogging = false;
    private static FileStream s_fileStream;
    public static HdLoggerCallback s_HdLoggerCallback;
    private static string s_logDir = null;
    private static string s_logFileName = "XXXX";
    private static string s_logFilePath = null;
    public static int s_logFileSize = 0xa00000;
    private static bool s_loggerInited = false;
    private static string s_logLevels = null;
    private static int s_logRotationTime = 0x7530;
    private static string s_logStringDebug = "DEBUG";
    private static string s_logStringError = "ERROR";
    private static string s_logStringFatal = "FATAL";
    private static string s_logStringInfo = "INFO";
    private static string s_logStringWarning = "WARNING";
    private static int s_processId = -1;
    private static string s_processName = "Unknown";
    private static object s_sync = new object();
    public static int s_totalLogFileNum = 5;
    private static TextWriter writer = Console.Error;

    private static void Close()
    {
        if (!s_consoleLogging)
        {
            writer.Close();
            s_fileStream.Dispose();
            writer.Dispose();
        }
    }

    public static void Debug(string msg)
    {
        Debug("{0}", new object[] { msg });
    }

    public static void Debug(string fmt, params object[] args)
    {
        Print(LOG_LEVEL_DEBUG, s_processName, fmt, args);
    }

    private static void DoLogRotation()
    {
    Label_0000:
        Thread.Sleep(s_logRotationTime);
        try
        {
            lock (s_sync)
            {
                FileInfo info = new FileInfo(s_logFilePath);
                if (info.Length >= s_logFileSize)
                {
                    string destFileName = s_logFilePath + ".1";
                    string path = s_logFilePath + "." + s_totalLogFileNum;
                    if (File.Exists(path))
                    {
                        File.Delete(path);
                    }
                    for (int i = s_totalLogFileNum - 1; i >= 1; i--)
                    {
                        string str3 = s_logFilePath + "." + i;
                        string str4 = s_logFilePath + "." + (i + 1);
                        if (File.Exists(str3))
                        {
                            File.Move(str3, str4);
                        }
                    }
                    File.Move(s_logFilePath, destFileName);
                }
            }
            goto Label_0000;
        }
        catch (Exception)
        {
            goto Label_0000;
        }
    }

    public static void Error(string msg)
    {
        Error("{0}", new object[] { msg });
    }

    public static void Error(string fmt, params object[] args)
    {
        Print(LOG_LEVEL_ERROR, s_processName, fmt, args);
    }

    public static void Fatal(string msg)
    {
        Fatal("{0}", new object[] { msg });
    }

    public static void Fatal(string fmt, params object[] args)
    {
        Print(LOG_LEVEL_FATAL, s_processName, fmt, args);
    }

    private static string GetLogDir(bool userSpecificLog)
    {
        string str;
        if (s_logDir != null)
        {
            return s_logDir;
        }
        try
        {
            if (userSpecificLog)
            {
                str = Path.Combine(s_bstUserDataDir, "Logs");
            }
            else
            {
                str = (string) Registry.LocalMachine.OpenSubKey(@"Software\XXXX").GetValue("LogDir");
            }
        }
        catch (Exception)
        {
            str = Path.Combine(s_bstUserDataDir, "Logs");
        }
        s_logDir = str;
        return str;
    }

    private static string GetPrefix(string tag, string logLevel)
    {
        int managedThreadId = Thread.CurrentThread.ManagedThreadId;
        DateTime now = DateTime.Now;
        return string.Format("{0:D4}-{1:D2}-{2:D2} {3:D2}:{4:D2}:{5:D2}.{6:D3} {7}:{8:X8} ({9}). {10}: ", new object[] { now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond, s_processId, managedThreadId, tag, logLevel });
    }

    public static TextWriter GetWriter()
    {
        return new Writer(delegate (string msg) {
            Print(msg);
        });
    }

    private static void HdLogger(int prio, uint tid, string tag, string msg)
    {
        int level = 0;
        if (prio == HDLOG_PRIORITY_FATAL)
        {
            level = LOG_LEVEL_FATAL;
        }
        else if (prio == HDLOG_PRIORITY_ERROR)
        {
            level = LOG_LEVEL_ERROR;
        }
        else if (prio == HDLOG_PRIORITY_WARNING)
        {
            level = LOG_LEVEL_WARNING;
        }
        else if (prio == HDLOG_PRIORITY_INFO)
        {
            level = LOG_LEVEL_INFO;
        }
        else if (prio == HDLOG_PRIORITY_DEBUG)
        {
            level = LOG_LEVEL_DEBUG;
        }
        Print(level, tag, "{0:X8}: {1}", new object[] { tid, msg });
    }

    public static void Info(string msg)
    {
        Info("{0}", new object[] { msg });
    }

    public static void Info(string fmt, params object[] args)
    {
        Print(LOG_LEVEL_INFO, s_processName, fmt, args);
    }

    public static void InitConsoleLog()
    {
        InitLog("-", true, false);
    }

    public static void InitLog(string logFileName, bool userSpecificLog, bool doLogRotation)
    {
        s_loggerInited = true;
        s_HdLoggerCallback = new HdLoggerCallback(Logger.HdLogger);
        s_processId = Process.GetCurrentProcess().Id;
        s_processName = Process.GetCurrentProcess().ProcessName;
        if (logFileName == "-")
        {
            writer = Console.Error;
            s_consoleLogging = true;
        }
        else
        {
            if (logFileName == null)
            {
                logFileName = s_logFileName;
            }
            if (userSpecificLog)
            {
                logFileName = logFileName + "Users";
            }
            string logDir = GetLogDir(userSpecificLog);
            string str2 = string.Format(@"{0}\{1}.log", logDir, logFileName);
            if (!Directory.Exists(logDir))
            {
                Directory.CreateDirectory(logDir);
            }
            s_logFilePath = str2;
            LogLevelsInit();
            lock (s_sync)
            {
                Open();
            }
            if (doLogRotation)
            {
                new Thread(() => DoLogRotation()) { IsBackground = true }.Start();
            }
        }
    }

    public static void InitSystemLog()
    {
        InitLog(null, false, false);
    }

    public static void InitSystemLogWithRotation()
    {
        InitLog(null, false, true);
    }

    public static void InitUserLog()
    {
        InitLog(null, true, false);
    }

    public static void InitUserLogWithRotation()
    {
        InitLog(null, true, true);
    }

    private static bool IsLogLevelEnabled(string tag, string level)
    {
        if (s_logLevels == null)
        {
            return false;
        }
        return (s_logLevels.StartsWith("ALL") || s_logLevels.Contains((tag + ":" + level).ToUpper()));
    }

    private static void LogLevelsInit()
    {
        string name = @"Software\XXXX\Config";
        try
        {
            using (RegistryKey key = Registry.LocalMachine.OpenSubKey(name))
            {
                s_logLevels = (string) key.GetValue("DebugLogs");
            }
        }
        catch (Exception)
        {
            return;
        }
        if (s_logLevels != null)
        {
            s_logLevels = s_logLevels.ToUpper();
        }
    }

    private static void Open()
    {
        if (!s_consoleLogging)
        {
            if (!s_loggerInited)
            {
                InitLog("-", false, false);
                s_loggerInited = true;
            }
            else
            {
                s_fileStream = new FileStream(s_logFilePath, FileMode.Append, FileAccess.Write, FileShare.Delete | FileShare.ReadWrite);
                writer = new StreamWriter(s_fileStream, Encoding.UTF8);
            }
        }
    }

    public static void Print(string msg)
    {
        Print("{0}", new object[] { msg });
    }

    public static void Print(string fmt, params object[] args)
    {
        Print(LOG_LEVEL_INFO, s_processName, fmt, args);
    }

    public static void Print(int level, string tag, string fmt, params object[] args)
    {
        string str = "UNKNOWN";
        if (level == LOG_LEVEL_FATAL)
        {
            str = s_logStringFatal;
        }
        else if (level == LOG_LEVEL_ERROR)
        {
            str = s_logStringError;
        }
        else if (level == LOG_LEVEL_WARNING)
        {
            str = s_logStringWarning;
        }
        else if (level == LOG_LEVEL_INFO)
        {
            str = s_logStringInfo;
        }
        else if (level == LOG_LEVEL_DEBUG)
        {
            str = s_logStringDebug;
        }
        if ((level != LOG_LEVEL_DEBUG) || IsLogLevelEnabled(tag, str))
        {
            lock (s_sync)
            {
                Open();
                writer.WriteLine(GetPrefix(tag, str) + fmt, args);
                writer.Flush();
                Close();
            }
        }
    }

    public static void SetLogDir(string logDir)
    {
        s_logDir = logDir;
    }

    public static void Warning(string msg)
    {
        Warning("{0}", new object[] { msg });
    }

    public static void Warning(string fmt, params object[] args)
    {
        Print(LOG_LEVEL_WARNING, s_processName, fmt, args);
    }

    public delegate void HdLoggerCallback(int prio, uint tid, string tag, string msg);

    public class Writer : TextWriter
    {
        private WriteFunc writeFunc;

        public Writer(WriteFunc writeFunc)
        {
            this.writeFunc = writeFunc;
        }

        public override void WriteLine(string msg)
        {
            this.writeFunc(msg);
        }

        public override void WriteLine(string fmt, object obj)
        {
            this.writeFunc(string.Format(fmt, obj));
        }

        public override void WriteLine(string fmt, object[] objs)
        {
            this.writeFunc(string.Format(fmt, objs));
        }

        public override System.Text.Encoding Encoding
        {
            get
            {
                return System.Text.Encoding.UTF8;
            }
        }

        public delegate void WriteFunc(string msg);
    }
}
33
bTagTiger

Wenn eine Variable TypeInitializationException ausgelöst wird, überprüfen Sie die gesamte Initialisierungslogik des Typs, auf den Sie zum ersten Mal in der Anweisung verweisen, in der die Ausnahme ausgelöst wird - in Ihrem Fall: Logger.

Die Initialisierungslogik umfasst: den statischen Konstruktor des Typs (den Sie - wenn ich ihn nicht vermisst habe - nicht für Logger haben) und die Feldinitialisierung.

Die Feldinitialisierung ist in Logger mit Ausnahme der folgenden Zeilen ziemlich "unkritisch":

private static string s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
private static string s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");
private static string s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);

s_commonAppData ist null an dem Punkt, an dem Path.Combine(s_commonAppData, "XXXX"); aufgerufen wird. Für mich geschehen diese Initialisierungen in der Reihenfolge genau, in der Sie sie geschrieben haben - also s_commonAppData um mindestens zwei Zeilen hochlegen;)

30
olydis

System.TypeInitializationException passiert, wenn der Code, der während des Ladens des Typs ausgeführt wird, eine Ausnahme auslöst.

Wenn .NET den Typ lädt, muss es alle statischen Felder vorbereiten, bevor Sie den Typ zum ersten Mal verwenden. Manchmal erfordert die Initialisierung das Ausführen von Code. Wenn dieser Code fehlschlägt, erhalten Sie einen System.TypeInitializationException.

In Ihrem speziellen Fall führen die folgenden drei statischen Felder Code aus:

private static string s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
private static string s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");
private static string s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);

Beachten Sie, dass s_bstCommonAppData von s_commonAppData abhängt, jedoch vor seiner Abhängigkeit deklariert wird. Daher ist der Wert von s_commonAppData zum Zeitpunkt des Aufrufs von Path.Combinenull, was ArgumentNullException zur Folge hat. Gleiches gilt für s_bstUserDataDir und s_bstCommonAppData: Sie werden in umgekehrter Reihenfolge zur gewünschten Initialisierungsreihenfolge deklariert.

Ordnen Sie die Zeilen neu an, um dieses Problem zu beheben:

private static string s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
private static string s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
private static string s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");
15
dasblinkenlight

Diese Zeilen sind Ihr Problem (oder mindestens eine Ihrer Probleme, falls es mehr gibt):

private static string s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
private static string s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");
private static string s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);

Sie verweisen auf statische Member in den Initialisierungen für andere statische Member. Dies ist eine schlechte Idee, da der Compiler nicht weiß, in welcher Reihenfolge er initialisiert werden soll. Das Ergebnis ist, dass während der Initialisierung von s_bstCommonAppData das abhängige Feld s_commonAppData noch nicht initialisiert wurde, so dass Sie Path.Combine(null, "XXXX") aufrufen und diese Methode keine NULL-Argumente akzeptiert.

Sie können dies beheben, indem Sie sicherstellen, dass Felder, die bei der Initialisierung anderer Felder verwendet werden, zuerst deklariert werden:

private static string s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
private static string s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
private static string s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");

Oder verwenden Sie einen statischen Konstruktor, um die Zuweisungen explizit zu ordnen:

private static string s_bstCommonAppData;
private static string s_bstUserDataDir;
private static string s_commonAppData;

static Logger()
{
    s_commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
    s_bstCommonAppData = Path.Combine(s_commonAppData, "XXXX");
    s_bstUserDataDir = Path.Combine(s_bstCommonAppData, "UserData");
}
4
cdhowie

ich. Bitte überprüfen Sie die InnerException-Eigenschaft der TypeInitializationException.

ii. Dies kann auch aufgrund von Unstimmigkeiten zwischen den Laufzeitversionen der Assemblys auftreten. Bitte überprüfen Sie die Laufzeitversionen der Hauptassembly (aufrufende Anwendung) und der verwiesenen Assembly

4
ShivanandSK

Ich habe den System.TypeInitializationException aufgrund eines anderen Fehlers in der app.config meines .NET Framework 4-Projekts festgestellt. Vielen Dank an pStan, dass Sie mir die app.config angesehen haben. Meine Konfigurationsabschnitte wurden ordnungsgemäß definiert. Ein undefiniertes Element in einem der Abschnitte hat jedoch dazu geführt, dass die Ausnahme ausgelöst wurde.

Fazit: Probleme in der app.config können diese sehr irreführende TypeInitializationException erzeugen.

Eine aussagekräftigere ConfigurationErrorsException kann durch denselben Fehler in der app.config generiert werden, indem auf den Zugriff auf die Konfigurationswerte gewartet wird, bis Sie sich innerhalb einer Methode und nicht auf Klassenebene des Codes befinden.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;
using System.Collections.Specialized;

namespace ConfigTest
{
    class Program
    {
        public static string machinename;
        public static string hostname;
        public static NameValueCollection _AppSettings;

        static void Main(string[] args)
        {
            machinename = System.Net.Dns.GetHostName().ToLower();
            hostname = "abc.com";// System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName()).HostName.ToLower().Replace(machinename + ".", "");
            _AppSettings = ConfigurationManager.GetSection("domain/" + hostname) as System.Collections.Specialized.NameValueCollection;
        }
    }
}
2
Jeff

Wenn Sie im App-Set benutzerdefinierte Attribute haben. Beweg dein 

     <configSections> 
     </configSections>

tag zum ersten Kind im <confuguration>

1
Telwa Gangnam

Ich weiß, dass dies eine alte Frage ist, aber kürzlich hatte ich diesen Fehler, und ich dachte, ich würde meine Lösung weitergeben. 

Meine Fehler stammen scheinbar aus einer alten App.Config-Datei und dem "In Place" -Upgrade von .NET 4.0 auf .NET 4.5.1. 

Als ich nach dem Upgrade auf Framework 4.5.1 das ältere Projekt startete, bekam ich die TypeInitializationException ... sofort aus dem Stand. Ich konnte nicht einmal eine Codezeile durchlaufen. 

Nachdem ich ein brandneues wpf-Projekt zum Testen erstellt hatte, stellte ich fest, dass die neuere App.Config-Datei Folgendes wünscht.

  <configSections>
    <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
      <section name="YourAppName.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
    </sectionGroup>
  </configSections>  

Nachdem ich das reingelegt hatte, war ich im Geschäft. 

Beachten Sie, dass Ihr Bedarf möglicherweise etwas anders ist. Ich würde ein Dummy-Projekt erstellen, die generierte App.Config-Datei auschecken und sehen, ob noch etwas fehlt. 

Hoffe das hilft jemandem. Viel Spaß beim Codieren!

1
pStan

Ich habe den Fehler system.typeintialzationException, der darauf zurückzuführen ist, als ich versuchte, die Datei wie folgt zu verschieben:

 File.Move(DestinationFilePath, SourceFilePath)

Dieser Fehler war darauf zurückzuführen, dass ich den Pfad tatsächlich ausgetauscht hatte. Richtig ist:

 File.Move(SourceFilePath, DestinationFilePath)
0
Vishal

Die TypeInitializationException, die als Wrapper für die Ausnahme durch den Klasseninitialisierer geworfen wird Diese Klasse kann nicht vererbt werden.

TypeInitializationException wird auch als statische Konstruktoren bezeichnet.

0
Hitesh Modha

Hatte ein ähnliches Problem die gleiche Ausnahme. Hat einige Zeit gebraucht, um zu finden. In meinem Fall hatte ich eine statische Dienstprogrammklasse mit einem Konstruktor, der die Ausnahme auslöste (umhüllt). Also lag mein Problem im statischen Konstruktor.

0
Acorax