W jaki sposób Microsoft stworzył zespoły, które mają odniesienia okrągłe?

RBarryYoung i Dykam na coś wpadli. Microsoft używa wewnętrznego narzędzia, które wykorzystuje ILDASM do demontażu zespołów, usuwania wszystkich wewnętrznych / prywatnych rzeczy i ciał metod oraz rekompilowania IL ponownie (za pomocą ILASM) do tak zwanego "zestawu odwodnionego" lub zestawu metadanych. Odbywa się to za każdym razem, gdy zmienia się publiczny Interfejs montażu.

Podczas kompilacji używane są zestawy metadanych zamiast rzeczywistych. W ten sposób cykl zostaje przerwany.

Można to zrobić w sposób opisany przez Dykam, ale Visual Studio blokuje ci to.

Będziesz musiał użyć kompilatora wiersza poleceń csc.exe bezpośrednio.

1. Csc / target: biblioteka ClassA.cs

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

3. Csc / target: biblioteka 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 {
    }
}

Jest to dość łatwe do zrobienia w Visual Studio, o ile nie używasz referencji do projektów... Spróbuj tego:

1. Open visual studio
2. Utwórz 2 projekty biblioteki klas "ClassLibrary1" i "ClassLibrary2".
3. Build
4. z ClassLibrary1 Dodaj odwołanie do ClassLibrary2 przeglądając bibliotekę dll utworzoną w kroku 3.
5. z ClassLibrary2 Dodaj odwołanie do ClassLibrary1 przeglądając bibliotekę dll utworzoną w kroku 3.
6. Build again (Uwaga: Jeśli dokonasz zmian w obu projekty, które musisz zbudować dwa razy, aby oba odniesienia były "świeże")

Więc tak to się robi. Ale poważnie... Nigdy nie rób tego w prawdziwym projekcie! Jeśli to zrobisz, Mikołaj nie przyniesie Ci żadnych prezentów w tym roku.

Myślę, że można to zrobić, zaczynając od acyklicznego zestawu zespołów i używając ILMerge, aby następnie połączyć mniejsze zespoły w logicznie powiązane grupy.

Cóż, nigdy nie robiłem tego na Windowsie, ale robiłem to na wielu środowiskach compile-link-rtl, które służyły jako praktyczne prekursory dla niego. To, co robisz, to najpierw zrób "cele" wstępu bez odsyłaczy, a następnie link, a następnie dodaj odniesienia kołowe, a następnie ponownie połącz. Linkerzy zazwyczaj nie dbają o okrągłe refy lub następujące łańcuchy ref, dbają tylko o to, aby móc rozwiązać każde odniesienie na własną rękę.

Więc jeśli masz dwie biblioteki, A i B, które trzeba się do siebie odwoływać, spróbuj czegoś takiego:

1. Link a bez refów do B.
2. Link B with refs to A.
3. Link A, dodając w refach do B.

Dykam ma rację, to kompilacja, a nie link w. Net, ale zasada pozostaje taka sama: twórz powiązane źródła, z ich wyeksportowanymi punktami wejścia, ale wszystkie oprócz jednego z nich mają własne odniesienia do innych stubów. Zbuduj je w ten sposób. Następnie unstub zewnętrzne odniesienia i odbudować je. Powinno to działać nawet bez żadnych specjalnych narzędzi, w rzeczywistości takie podejście działało na każdym systemie operacyjnym ,na którym kiedykolwiek próbowałem (około 6 z nich). Chociaż oczywiście coś, co automatyzuje to byłoby bardzo pomocne.

Jednym z możliwych sposobów jest użycie kompilacji warunkowej (#if) do kompilacji systemu.biblioteki dll, które nie zależą od innych złożeń, następnie kompilują Pozostałe złożenia i w końcu przekompilują System.dll zawierać części w zależności od XML i konfiguracji.

Technicznie możliwe, że nie zostały one w ogóle skompilowane i zmontowane ręcznie. W końcu są to biblioteki niskiego poziomu.