Aliase für Typ und Auflösung externer Assemblykollision

Typ-Aliasse

Es kann vorkommen, dass wir zwei Klassen mit demselben Namen in derselben Assembly oder in verschiedenen Assemblys haben, aber wir können den Namen der Klassen aufgrund von Designeinschränkungen nicht ändern.

Angenommen, ich habe eine Klasse in AssemblyA, wie in der folgenden Abbildung 1 gezeigt.

Und ich verweise auf AssemblyA in meinem Projekt und verwende eine Instanz von MyClass, wie im folgenden Codeausschnitt gezeigt.

using AssemblyA;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TypeAliases
{
    class Program
    {
        static void Main(string[] args)
        {
            var instance = new MyClass();
        }
    }
}

Nun entsteht im Projekt die Notwendigkeit, eine neue Klasse namens MyClass im selben Projekt zu erstellen, die sich aber in derselben Assembly oder in einer anderen Assembly befinden könnte. Und wir müssen die neue Klasse nur aufgrund einiger Namensbeschränkungen oder aufgrund einiger anderer Bedenken als MyClass benennen, wie in der folgenden Abbildung gezeigt.

Wenn wir nun auf die neue Klasse entlang der zuvor erstellten Klasse zugreifen müssen, müssen wir einen vollständig qualifizierten Namen der Klasse zusammen mit der Assembly verwenden, wie im folgenden Codeausschnitt gezeigt.

static void Main(string[] args)
        {
            var instance = new MyClass();
            var instance2 = new AssemblyA.SubAssembly.MyClass();
        }

Der obige Code kann etwas umständlich und schwierig zu warten sein, wenn wir an vielen Stellen dieselbe Klasse verwenden müssen.
Stattdessen können wir Typ-Aliase erstellen, wie in gezeigt das folgende Code-Snippet und verwenden Sie es anstelle des vollständigen Namespace-Namens.

using AssemblyA;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MyClass2 = AssemblyA.SubAssembly.MyClass;

namespace TypeAliases
{
    class Program
    {
        static void Main(string[] args)
        {
            var instance = new MyClass();
            var instance2 = new MyClass2();
        }
    }
}

Wenn wir den obigen Code ausführen, können wir sehen, dass die Instanz2 der im Unterordner von AssemblyA vorhandenen MyClass erstellt wird, wie in der Abbildung gezeigt.

Assembly-Konflikte für Klassen lösen

Manchmal gibt es Fälle, in denen ein und derselbe Klassenname in zwei Assemblys mit denselben Namespaces existiert, auf die wir in unserem Projekt verweisen möchten. Wenn beide dieser Assemblys von uns erstellt werden, können wir in diesem Fall einfach den Namen der Klasse sowie der Assembly ändern, wenn dies möglich ist. Angenommen, diese beiden Assemblys werden von Drittanbietern entwickelt, dann ist es fast unmöglich, den Namen der Klasse zu ändern. In diesem Fall kann der Compiler nicht herausfinden, auf welchen Namespace er verweisen muss, um eine Instanz der Klasse zu erstellen.
Angenommen, ich habe zwei Assemblys ClassLibrary1 und ClassLibrary2, aber mit demselben Namespace und Klassennamen wie MyNamespace bzw. MyClass, wie in gezeigt die folgenden Codeschnipsel.

namespace MyNamespace
{
    public class MyClass
    {
        public override string ToString()
        {
            return "I am in ClassLibrary1";
        }
    }
}

namespace MyNamespace
{
    public class MyClass
    {
        public override string ToString()
        {
            return "I am in classLibrary2";
        }
    }
}

Wenn ich einen Verweis auf diese beiden Assemblys hinzufüge und versuche, eine Instanz von MyClass zu erstellen, erhalten wir einen Kompilierungsfehler als „MyClass existiert sowohl in ClassLibrary1 als auch in ClassLibrary2“ oder „vollständig qualifizierter Typ existiert in beiden Assemblys“
Um diesen Fehler zu beheben, müssen wir diesen beiden Assemblys den Alias ​​wie unten gezeigt geben.
Klicken Sie mit der rechten Maustaste auf die Assembly und öffnen Sie die Eigenschaften wie unten gezeigt Zahl. Ich habe den Alias ​​für beide Assemblys in Lib1 und Lib2 geändert.

Nachdem wir den Alias ​​für den Namensraum geändert haben, müssen wir in unserem Code auf den geänderten Alias ​​verweisen, wie unten gezeigt.

extern alias Lib2;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;



namespace TypeAliases
{
    class Program
    {
        static void Main(string[] args)
        {
            var inst1 = new Lib1.MyNamespace.MyClass();
            var inst2 = new Lib2.MyNamespace.MyClass();
        }
    }
}

Nach dem Debuggen des obigen Codes können wir sehen, dass diese beiden erstellten Instanzen zu den jeweiligen Klassen gehören.

In diesem Blog habe ich demonstriert, wie wir Typ-Alias ​​sowie Assembly-Alias ​​hinzufügen können.