Wie hat Microsoft Assemblys mit Zirkelverweisen erstellt?

In der .NET BCL gibt es Zirkelverweise zwischen:

• System.dll und System.Xml.dll
• System.dll und System.Configuration.dll
• System.Xml.dll und System.Configuration.dll

Hier ist ein Screenshot von .NET Reflector, der zeigt, was ich meine:

Wie Microsoft diese Assemblys erstellt hat, ist mir ein Rätsel. Ist ein spezieller Kompilierungsprozess erforderlich, um dies zu ermöglichen? Ich stelle mir vor, dass hier etwas Interessantes los ist.

Ich kann nur sagen, wie das Mono-Projekt das macht. Der Satz ist recht einfach, obwohl er ein Code-Chaos verursacht.

Sie kompilieren zuerst System.Configuration.dll, ohne dass der Teil den Verweis auf System.Xml.dll benötigt. Danach kompilieren sie System.Xml.dll auf normale Weise. Jetzt kommt die Magie. Sie kompilieren System.configuration.dll neu, wobei der Teil den Verweis auf System.Xml.dll benötigt. Jetzt gibt es eine erfolgreiche Zusammenstellung mit dem Zirkelverweis.

Zusamenfassend:

• A wird kompiliert, ohne dass der Code B und den Verweis auf B benötigt.
• B wird kompiliert.
• A wird neu kompiliert.

RBarryYoung und Dykam sind auf etwas. Microsoft verwendet ein internes Tool, das ILDASM verwendet, um Assemblys zu zerlegen, alle internen / privaten Inhalte und Methodenkörper zu entfernen und IL (mithilfe von ILASM) erneut in eine sogenannte "dehydrierte Assembly" oder Metadatenassemblierung zu kompilieren. Dies erfolgt jedes Mal, wenn die öffentliche Schnittstelle der Assembly geändert wird.

Während des Builds werden Metadaten-Assemblys anstelle von realen verwendet. Auf diese Weise wird der Zyklus unterbrochen.

Es kann so gemacht werden, wie Dykam es beschrieben hat, aber Visual Studio hindert Sie daran.

Sie müssen den Befehlszeilen-Compiler csc.exe direkt verwenden.

1. csc / target: Bibliothek ClassA.cs

2. csc / target: library ClassB.cs /reference:ClassA.dll

3. csc / target: Bibliothek ClassA.cs ClassC.cs /reference:ClassB.dll

//ClassA.cs
namespace CircularA {
    public class ClassA {
    }
}


//ClassB.cs
using CircularA;
namespace CircularB {
    public class ClassB : ClassA  {
    }
}


//ClassC.cs
namespace CircularA {
    class ClassC : ClassB {
    }
}

In Visual Studio ist dies ziemlich einfach, solange Sie keine Projektreferenzen verwenden ... Versuchen Sie Folgendes:

1. Visual Studio öffnen
2. Erstellen Sie 2 Klassenbibliotheksprojekte "ClassLibrary1" & "ClassLibrary2".
3. Bauen
4. Fügen Sie in ClassLibrary1 einen Verweis auf ClassLibrary2 hinzu, indem Sie zu der in Schritt 3 erstellten DLL navigieren.
5. Fügen Sie in ClassLibrary2 einen Verweis auf ClassLibrary1 hinzu, indem Sie zu der in Schritt 3 erstellten DLL navigieren.
6. Erneut erstellen (Hinweis: Wenn Sie in beiden Projekten Änderungen vornehmen, müssen Sie zweimal erstellen, um beide Referenzen "frisch" zu machen.)

So machst du es also. Aber im Ernst ... Mach das NIEMALS in einem echten Projekt! Wenn Sie dies tun, bringt Ihnen der Weihnachtsmann dieses Jahr keine Geschenke.

Ich denke, dies könnte erreicht werden, indem man mit einem azyklischen Satz von Baugruppen beginnt und ILMerge verwendet, um die kleineren Baugruppen dann zu logisch verwandten Gruppen zusammenzufassen.

Nun, ich habe es noch nie unter Windows gemacht, aber ich habe es in vielen Compile-Link-RTL-Umgebungen gemacht, die als praktische Vorläufer dafür dienten. Was Sie tun, ist, zuerst Stub- "Ziele" ohne Querverweise zu erstellen, dann zu verknüpfen, dann die Zirkelverweise hinzuzufügen und dann erneut zu verknüpfen. Die Linker kümmern sich im Allgemeinen nicht um kreisförmige Verweise oder das Verfolgen von Verweisketten, sondern nur darum, dass sie jede Referenz für sich auflösen können.

Wenn Sie also zwei Bibliotheken haben, A und B, die aufeinander verweisen müssen, versuchen Sie Folgendes:

1. Link A ohne Verweise auf B.
2. Verknüpfe B mit Verweisen auf A.
3. Link A, Hinzufügen der Refs zu B.

Dykam macht einen guten Punkt, es ist kompilieren, nicht in .Net verlinken, aber das Prinzip bleibt das gleiche: Machen Sie Ihre Quellen mit Querverweisen, mit ihren exportierten Einstiegspunkten, aber mit allen bis auf einen, die ihre eigenen Verweise auf die anderen haben aus. Baue sie so. Entfernen Sie dann die externen Referenzen und erstellen Sie sie neu. Dies sollte auch ohne spezielle Tools funktionieren. Tatsächlich hat dieser Ansatz auf jedem Betriebssystem funktioniert, auf dem ich es jemals ausprobiert habe (ungefähr 6 davon). Obwohl es offensichtlich etwas ist, das es automatisiert, wäre es eine große Hilfe.

Ein möglicher Ansatz besteht darin, die bedingte Kompilierung (#if) zu verwenden, um zuerst eine System.dll zu kompilieren, die nicht von diesen anderen Assemblys abhängt, dann die anderen Assemblys zu kompilieren und schließlich System.dll neu zu kompilieren, um die Teile abhängig von Xml und Aufbau.

Technisch ist es möglich, dass diese überhaupt nicht kompiliert und von Hand zusammengesetzt wurden. Immerhin handelt es sich um Bibliotheken auf niedriger Ebene.